diff --git a/cmf/cmf_core.py b/cmf/cmf_core.py
index 8d6d437c..1da8dc6a 100644
--- a/cmf/cmf_core.py
+++ b/cmf/cmf_core.py
@@ -103,29 +103,70 @@ def set_attr(self, name, value):
SHARED_PTR_DISOWN = _cmf_core.SHARED_PTR_DISOWN
def get_parallel_threads(*args):
- """get_parallel_threads() -> int"""
+ """
+ get_parallel_threads() -> int
+
+ int
+ cmf::math::get_parallel_threads()
+
+ Returns the max number of threads used by OpenMP in parallel sections
+ of the code.
+ """
return _cmf_core.get_parallel_threads(*args)
def set_parallel_threads(*args, **kwargs):
- """set_parallel_threads(int numthreads) -> int"""
+ """
+ set_parallel_threads(int numthreads) -> int
+
+ int
+ cmf::math::set_parallel_threads(int numthreads)
+
+ Set the number of threads used by OpenMP in parallel sections of the
+ code.
+ """
return _cmf_core.set_parallel_threads(*args, **kwargs)
class cubicspline(object):
- """Proxy of C++ cmf::math::cubicspline class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
- """__init__(cmf::math::cubicspline self, cmf::math::num_array const & x, cmf::math::num_array const & y) -> cubicspline"""
+ """
+ __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)
+ """
_cmf_core.cubicspline_swiginit(self, _cmf_core.new_cubicspline(*args, **kwargs))
def generate(self, *args, **kwargs):
- """generate(cubicspline self)"""
+ """
+ generate(cubicspline self)
+
+ void
+ generate()
+ """
return _cmf_core.cubicspline_generate(self, *args, **kwargs)
def size(self, *args, **kwargs):
- """size(cubicspline self) -> size_t"""
+ """
+ size(cubicspline self) -> size_t
+
+ size_t size()
+ const
+ """
return _cmf_core.cubicspline_size(self, *args, **kwargs)
@@ -141,7 +182,18 @@ def __call__(self, *args, **kwargs):
cubicspline_swigregister(cubicspline)
class point(object):
- """Proxy of C++ cmf::geometry::point class."""
+ """
+
+
+ 2D-Point Class.
+
+ Used as location property anywhere in the text Calculation of
+ distances
+
+ +,-,-=,*= Operators overloaded
+
+ C++ includes: geometry.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -154,21 +206,52 @@ 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.
"""
_cmf_core.point_swiginit(self, _cmf_core.new_point(*args))
def distanceTo(self, *args, **kwargs):
- """distanceTo(point self, point p) -> double"""
+ """
+ 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}`
+ """
return _cmf_core.point_distanceTo(self, *args, **kwargs)
def z_weight_distance(self, *args, **kwargs):
- """z_weight_distance(point self, point p, double z_weight) -> double"""
+ """
+ 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|`
+
+ """
return _cmf_core.point_z_weight_distance(self, *args, **kwargs)
def distance3DTo(self, *args, **kwargs):
- """distance3DTo(point self, point p) -> double"""
+ """
+ distance3DTo(point self, point p) -> double
+
+ double
+ distance3DTo(point p) const
+
+ Returns the euclidian distance in space to another point p.
+ """
return _cmf_core.point_distance3DTo(self, *args, **kwargs)
@@ -179,27 +262,61 @@ def distance(*args, **kwargs):
distance = staticmethod(distance)
def distance_max(self, *args, **kwargs):
- """distance_max(point self, point p) -> double"""
+ """
+ distance_max(point self, point p) -> double
+
+ double
+ distance_max(point p) const
+
+ Returns the distance by the maximum orthogonal offset.
+ """
return _cmf_core.point_distance_max(self, *args, **kwargs)
def azimuth(self, *args, **kwargs):
- """azimuth(point self, point p) -> double"""
+ """
+ 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.
+ """
return _cmf_core.point_azimuth(self, *args, **kwargs)
def angleToXAxis(self, *args, **kwargs):
- """angleToXAxis(point self, point p) -> double"""
+ """
+ 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.
+ """
return _cmf_core.point_angleToXAxis(self, *args, **kwargs)
def sum(self, *args, **kwargs):
- """sum(point self) -> double"""
+ """
+ sum(point self) -> double
+
+ double sum() const
+
+ Returns x+y+z.
+ """
return _cmf_core.point_sum(self, *args, **kwargs)
def length(self, *args, **kwargs):
- """length(point self) -> double"""
+ """
+ length(point self) -> double
+
+ double length()
+ const
+ """
return _cmf_core.point_length(self, *args, **kwargs)
@@ -334,14 +451,30 @@ def point_distance(*args, **kwargs):
def dot(*args, **kwargs):
- """dot(point p1, point p2) -> double"""
+ """
+ dot(point p1, point p2) -> double
+
+ double
+ cmf::geometry::dot(const point &p1, const point &p2)
+ """
return _cmf_core.dot(*args, **kwargs)
def distance(*args, **kwargs):
- """distance(point p1, point p2) -> double"""
+ """
+ distance(point p1, point p2) -> double
+
+ double
+ cmf::geometry::distance(const point &p1, const point &p2)
+ """
return _cmf_core.distance(*args, **kwargs)
class point_vector(object):
- """Proxy of C++ cmf::geometry::point_vector class."""
+ """
+
+
+ Holds three arrays x,y and z for fast access of point coordinates.
+
+ C++ includes: geometry.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -350,21 +483,48 @@ class point_vector(object):
Z = _swig_property(_cmf_core.point_vector_Z_get, _cmf_core.point_vector_Z_set)
def __init__(self, *args, **kwargs):
- """__init__(cmf::geometry::point_vector self, ptrdiff_t size) -> point_vector"""
+ """
+ __init__(cmf::geometry::point_vector self, ptrdiff_t size) -> point_vector
+
+ point_vector(ptrdiff_t size)
+
+ Create a point vector of a specific size.
+ """
_cmf_core.point_vector_swiginit(self, _cmf_core.new_point_vector(*args, **kwargs))
def get(self, *args, **kwargs):
- """get(point_vector self, ptrdiff_t index) -> point"""
+ """
+ get(point_vector self, ptrdiff_t index) -> point
+
+ point
+ get(ptrdiff_t index) const
+
+ Return a point at index.
+ """
return _cmf_core.point_vector_get(self, *args, **kwargs)
def set(self, *args, **kwargs):
- """set(point_vector self, ptrdiff_t index, point p)"""
+ """
+ set(point_vector self, ptrdiff_t index, point p)
+
+ void
+ set(ptrdiff_t index, cmf::geometry::point p)
+
+ Change the point at index.
+ """
return _cmf_core.point_vector_set(self, *args, **kwargs)
def size(self, *args, **kwargs):
- """size(point_vector self) -> size_t"""
+ """
+ size(point_vector self) -> size_t
+
+ size_t
+ size() const
+
+ Return the number of points in the point_vector.
+ """
return _cmf_core.point_vector_size(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_point_vector
@@ -380,47 +540,181 @@ def size(self, *args, **kwargs):
def minimum(*args, **kwargs):
- """minimum(real a, real b) -> real"""
+ """
+ minimum(real a, real b) -> real
+
+ real minimum(real a, real b)
+
+ Returns the minimum of two values.
+ """
return _cmf_core.minimum(*args, **kwargs)
def maximum(*args, **kwargs):
- """maximum(real a, real b) -> real"""
+ """
+ maximum(real a, real b) -> real
+
+ real maximum(real a, real b)
+ """
return _cmf_core.maximum(*args, **kwargs)
def minmax(*args, **kwargs):
- """minmax(real x, real min, real max) -> real"""
+ """
+ minmax(real x, real min, real max) -> real
+
+ real minmax(real x, real min, real
+ max)
+ """
return _cmf_core.minmax(*args, **kwargs)
def mean(*args, **kwargs):
- """mean(real a, real b) -> real"""
+ """
+ mean(real a, real b) -> real
+
+ real mean(real a, real b)
+ """
return _cmf_core.mean(*args, **kwargs)
def geo_mean(*args, **kwargs):
- """geo_mean(real a, real b) -> real"""
+ """
+ geo_mean(real a, real b) -> real
+
+ real geo_mean(real a, real b)
+ """
return _cmf_core.geo_mean(*args, **kwargs)
def harmonic_mean(*args, **kwargs):
- """harmonic_mean(real a, real b) -> real"""
+ """
+ harmonic_mean(real a, real b) -> real
+
+ real harmonic_mean(real a, real
+ b)
+ """
return _cmf_core.harmonic_mean(*args, **kwargs)
def piecewise_linear(*args, **kwargs):
- """piecewise_linear(real x, real xmin, real xmax, real ymin=0, real ymax=1) -> real"""
+ """
+ piecewise_linear(real x, real xmin, real xmax, real ymin=0, real ymax=1) -> real
+
+ real piecewise_linear(real
+ x, real xmin, real xmax, real ymin=0, real ymax=1)
+ """
return _cmf_core.piecewise_linear(*args, **kwargs)
def boltzmann(*args, **kwargs):
- """boltzmann(real x, real x_half, real tau) -> real"""
+ """
+ boltzmann(real x, real x_half, real tau) -> real
+
+ real boltzmann(real x, real x_half,
+ real tau)
+
+ The boltzmann function, used in cmf at several places where a s-shaped
+ curve is needed.
+
+
+
+ .. math::
+
+ f(x,x_{1/2},\\tau)=\\frac{1}{1+e^{-\\frac{x-x_{1/2}}{tau}}}
+
+
+ """
return _cmf_core.boltzmann(*args, **kwargs)
def sign(*args, **kwargs):
- """sign(real x) -> real"""
+ """
+ sign(real x) -> real
+
+ real sign(real x)
+ """
return _cmf_core.sign(*args, **kwargs)
def square(*args, **kwargs):
- """square(real x) -> real"""
+ """
+ square(real x) -> real
+
+ real square(real x)
+ """
return _cmf_core.square(*args, **kwargs)
JULIANDAY_0_1_1900 = _cmf_core.JULIANDAY_0_1_1900
class Time(object):
- """Proxy of C++ cmf::math::Time class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -432,51 +726,106 @@ def __init__(self, *args):
__init__(cmf::math::Time self, Date date) -> Time
__init__(cmf::math::Time self, Time t) -> Time
__init__(cmf::math::Time self) -> Time
+
+ Time(long long ms)
"""
_cmf_core.Time_swiginit(self, _cmf_core.new_Time(*args))
def AsDays(self, *args, **kwargs):
- """AsDays(Time self) -> double"""
+ """
+ AsDays(Time self) -> double
+
+ double AsDays() const
+
+ Time in days.
+ """
return _cmf_core.Time_AsDays(self, *args, **kwargs)
def AsHours(self, *args, **kwargs):
- """AsHours(Time self) -> double"""
+ """
+ AsHours(Time self) -> double
+
+ double AsHours()
+ const
+
+ Time in hours.
+ """
return _cmf_core.Time_AsHours(self, *args, **kwargs)
def AsMinutes(self, *args, **kwargs):
- """AsMinutes(Time self) -> double"""
+ """
+ AsMinutes(Time self) -> double
+
+ double AsMinutes()
+ const
+
+ Time in minutes.
+ """
return _cmf_core.Time_AsMinutes(self, *args, **kwargs)
def AsSeconds(self, *args, **kwargs):
- """AsSeconds(Time self) -> double"""
+ """
+ AsSeconds(Time self) -> double
+
+ double AsSeconds()
+ const
+
+ Time in seconds.
+ """
return _cmf_core.Time_AsSeconds(self, *args, **kwargs)
def AsMilliseconds(self, *args, **kwargs):
- """AsMilliseconds(Time self) -> long long"""
+ """
+ AsMilliseconds(Time self) -> long long
+
+ long long
+ AsMilliseconds() const
+
+ Time in milliseconds.
+ """
return _cmf_core.Time_AsMilliseconds(self, *args, **kwargs)
def AsDate(self, *args, **kwargs):
- """AsDate(Time self) -> Date"""
+ """
+ AsDate(Time self) -> Date
+
+ Date AsDate() const
+
+ """
return _cmf_core.Time_AsDate(self, *args, **kwargs)
def to_string(self, *args, **kwargs):
- """to_string(Time self, char seperator) -> std::string"""
+ """
+ to_string(Time self, char seperator) -> std::string
+
+ std::string
+ to_string(char seperator=':')
+ """
return _cmf_core.Time_to_string(self, *args, **kwargs)
def is_not_0(self, *args, **kwargs):
- """is_not_0(Time self) -> bool"""
+ """
+ is_not_0(Time self) -> bool
+
+ bool is_not_0()
+ const
+ """
return _cmf_core.Time_is_not_0(self, *args, **kwargs)
def DOY(self, *args, **kwargs):
- """DOY(Time self) -> double"""
+ """
+ DOY(Time self) -> double
+
+ double DOY() const
+ """
return _cmf_core.Time_DOY(self, *args, **kwargs)
@@ -541,7 +890,14 @@ def __truediv__(self, *args):
def times_in(self, *args, **kwargs):
- """times_in(Time self, Time t1) -> long long"""
+ """
+ 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.
+ """
return _cmf_core.Time_times_in(self, *args, **kwargs)
@@ -629,7 +985,14 @@ def AsPython(self):
Pi = cvar.Pi
class Date(object):
- """Proxy of C++ cmf::math::Date class."""
+ """
+
+
+ An absolute time, not for calculation. Date and Time are
+ interchangable.
+
+ C++ includes: time.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -645,21 +1008,45 @@ def __init__(self, *args):
"""
__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))
"""
_cmf_core.Date_swiginit(self, _cmf_core.new_Date(*args))
def ToTime(self, *args, **kwargs):
- """ToTime(Date self) -> Time"""
+ """
+ ToTime(Date self) -> Time
+
+ Time ToTime()
+
+ Converts a date to Time (based on the 31.12.1899, like in Excel(TM)
+ """
return _cmf_core.Date_ToTime(self, *args, **kwargs)
def DOY(self, *args, **kwargs):
- """DOY(Date self) -> double"""
+ """
+ DOY(Date self) -> double
+
+ double DOY()
+
+ Returns the day of year.
+ """
return _cmf_core.Date_DOY(self, *args, **kwargs)
def to_string(self, *args, **kwargs):
- """to_string(Date self) -> std::string"""
+ """
+ to_string(Date self) -> std::string
+
+ std::string
+ to_string()
+
+ Returns a string representing the date.
+ """
return _cmf_core.Date_to_string(self, *args, **kwargs)
@@ -676,53 +1063,124 @@ def AsPython(self):
Date_swigregister(Date)
class timeseries(object):
- """Proxy of C++ cmf::math::timeseries class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def interpolationpower(self, *args, **kwargs):
- """interpolationpower(timeseries self) -> int"""
+ """
+ interpolationpower(timeseries self) -> int
+
+ int
+ interpolationpower() const
+
+ Method for the interpolation (0 - Nearest neighbor, 1- linear, 2 -
+ cubic spline (not implemented yet)
+ """
return _cmf_core.timeseries_interpolationpower(self, *args, **kwargs)
def add(self, *args, **kwargs):
- """add(timeseries self, double Value)"""
+ """
+ add(timeseries self, double Value)
+
+ void add(double
+ Value)
+
+ Appends a measurement.
+ """
return _cmf_core.timeseries_add(self, *args, **kwargs)
def is_empty(self, *args, **kwargs):
- """is_empty(timeseries self) -> bool"""
+ """
+ is_empty(timeseries self) -> bool
+
+ bool
+ is_empty() const
+
+ returns true if no values are added to the timeseries
+ """
return _cmf_core.timeseries_is_empty(self, *args, **kwargs)
def clear(self, *args, **kwargs):
- """clear(timeseries self)"""
+ """
+ clear(timeseries self)
+
+ void clear()
+ """
return _cmf_core.timeseries_clear(self, *args, **kwargs)
def adress(self, *args, **kwargs):
- """adress(timeseries self) -> size_t"""
+ """
+ adress(timeseries self) -> size_t
+
+ size_t adress()
+ const
+ """
return _cmf_core.timeseries_adress(self, *args, **kwargs)
def copy(self, *args, **kwargs):
- """copy(timeseries self) -> timeseries"""
+ """
+ copy(timeseries self) -> timeseries
+
+ timeseries copy()
+ const
+ """
return _cmf_core.timeseries_copy(self, *args, **kwargs)
def size(self, *args, **kwargs):
- """size(timeseries self) -> size_t"""
+ """
+ size(timeseries self) -> size_t
+
+ size_t size()
+ const
+
+ Number of items in the timeseries.
+ """
return _cmf_core.timeseries_size(self, *args, **kwargs)
def count_values(self, *args, **kwargs):
- """count_values(timeseries self) -> size_t"""
+ """
+ count_values(timeseries self) -> size_t
+
+ size_t
+ count_values() const
+
+ Number of valid values (=size - # of NaN's)
+ """
return _cmf_core.timeseries_count_values(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
- """__init__(cmf::math::timeseries self, Time begin, Time step, int interpolationmethod=1, size_t count=0) -> timeseries"""
+ """
+ __init__(cmf::math::timeseries self, Time begin, Time step, int interpolationmethod=1, size_t count=0) -> timeseries
+
+ timeseries(const cmf::math::timeseries &ts)
+ """
_cmf_core.timeseries_swiginit(self, _cmf_core.new_timeseries(*args, **kwargs))
def from_array(*args, **kwargs):
@@ -744,22 +1202,42 @@ def from_file(*args, **kwargs):
from_file = staticmethod(from_file)
def get_t(self, *args, **kwargs):
- """get_t(timeseries self, Time t) -> double"""
+ """
+ get_t(timeseries self, Time t) -> double
+
+ double
+ get_t(cmf::math::Time t) const
+ """
return _cmf_core.timeseries_get_t(self, *args, **kwargs)
def get_i(self, *args, **kwargs):
- """get_i(timeseries self, ptrdiff_t i) -> double"""
+ """
+ get_i(timeseries self, ptrdiff_t i) -> double
+
+ double
+ get_i(ptrdiff_t i) const
+ """
return _cmf_core.timeseries_get_i(self, *args, **kwargs)
def set_t(self, *args, **kwargs):
- """set_t(timeseries self, Time t, double value)"""
+ """
+ set_t(timeseries self, Time t, double value)
+
+ void
+ set_t(cmf::math::Time t, double value)
+ """
return _cmf_core.timeseries_set_t(self, *args, **kwargs)
def set_i(self, *args, **kwargs):
- """set_i(timeseries self, ptrdiff_t i, double value)"""
+ """
+ set_i(timeseries self, ptrdiff_t i, double value)
+
+ void
+ set_i(ptrdiff_t i, double value)
+ """
return _cmf_core.timeseries_set_i(self, *args, **kwargs)
@@ -767,6 +1245,9 @@ def get_slice(self, *args):
"""
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)
"""
return _cmf_core.timeseries_get_slice(self, *args)
@@ -775,12 +1256,21 @@ def set_slice(self, *args):
"""
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)
"""
return _cmf_core.timeseries_set_slice(self, *args)
def remove_nodata(self, *args, **kwargs):
- """remove_nodata(timeseries self, double nodata_value)"""
+ """
+ remove_nodata(timeseries self, double nodata_value)
+
+ void
+ remove_nodata(double nodata_value)
+ """
return _cmf_core.timeseries_remove_nodata(self, *args, **kwargs)
@@ -850,27 +1340,63 @@ def __neg__(self, *args, **kwargs):
def inv(self, *args, **kwargs):
- """inv(timeseries self) -> timeseries"""
+ """
+ inv(timeseries self) -> timeseries
+
+ timeseries inv()
+ const
+ """
return _cmf_core.timeseries_inv(self, *args, **kwargs)
def reduce_min(self, *args, **kwargs):
- """reduce_min(timeseries self, Time begin, Time step) -> timeseries"""
+ """
+ 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.
+
+ """
return _cmf_core.timeseries_reduce_min(self, *args, **kwargs)
def reduce_max(self, *args, **kwargs):
- """reduce_max(timeseries self, Time begin, Time step) -> timeseries"""
+ """
+ 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.
+
+ """
return _cmf_core.timeseries_reduce_max(self, *args, **kwargs)
def reduce_sum(self, *args, **kwargs):
- """reduce_sum(timeseries self, Time begin, Time step) -> timeseries"""
+ """
+ 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.
+ """
return _cmf_core.timeseries_reduce_sum(self, *args, **kwargs)
def reduce_avg(self, *args, **kwargs):
- """reduce_avg(timeseries self, Time begin, Time step) -> timeseries"""
+ """
+ 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.
+
+ """
return _cmf_core.timeseries_reduce_avg(self, *args, **kwargs)
@@ -878,52 +1404,97 @@ def floating_avg(self, *args):
"""
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
"""
return _cmf_core.timeseries_floating_avg(self, *args)
def floating_max(self, *args, **kwargs):
- """floating_max(timeseries self, Time window_width) -> timeseries"""
+ """
+ floating_max(timeseries self, Time window_width) -> timeseries
+
+ timeseries floating_max(cmf::math::Time window_width) const
+ """
return _cmf_core.timeseries_floating_max(self, *args, **kwargs)
def floating_min(self, *args, **kwargs):
- """floating_min(timeseries self, Time window_width) -> timeseries"""
+ """
+ floating_min(timeseries self, Time window_width) -> timeseries
+
+ timeseries floating_min(cmf::math::Time window_width) const
+ """
return _cmf_core.timeseries_floating_min(self, *args, **kwargs)
def mean(self, *args, **kwargs):
- """mean(timeseries self) -> double"""
+ """
+ mean(timeseries self) -> double
+
+ double mean()
+ const
+ """
return _cmf_core.timeseries_mean(self, *args, **kwargs)
def min(self, *args, **kwargs):
- """min(timeseries self) -> double"""
+ """
+ min(timeseries self) -> double
+
+ double min() const
+
+ """
return _cmf_core.timeseries_min(self, *args, **kwargs)
def max(self, *args, **kwargs):
- """max(timeseries self) -> double"""
+ """
+ max(timeseries self) -> double
+
+ double max() const
+
+ """
return _cmf_core.timeseries_max(self, *args, **kwargs)
def log(self, *args, **kwargs):
- """log(timeseries self) -> timeseries"""
+ """
+ log(timeseries self) -> timeseries
+
+ timeseries log()
+ const
+ """
return _cmf_core.timeseries_log(self, *args, **kwargs)
def log10(self, *args, **kwargs):
- """log10(timeseries self) -> timeseries"""
+ """
+ log10(timeseries self) -> timeseries
+
+ timeseries
+ log10() const
+ """
return _cmf_core.timeseries_log10(self, *args, **kwargs)
def power(self, *args, **kwargs):
- """power(timeseries self, double exponent) -> timeseries"""
+ """
+ power(timeseries self, double exponent) -> timeseries
+
+ timeseries
+ power(double exponent) const
+ """
return _cmf_core.timeseries_power(self, *args, **kwargs)
def exp(self, *args, **kwargs):
- """exp(timeseries self) -> timeseries"""
+ """
+ exp(timeseries self) -> timeseries
+
+ timeseries exp()
+ const
+ """
return _cmf_core.timeseries_exp(self, *args, **kwargs)
begin = _swig_property(_cmf_core.timeseries_begin_get)
@@ -1117,7 +1688,33 @@ def timeseries_from_file(*args, **kwargs):
def nash_sutcliffe(*args, **kwargs):
- """nash_sutcliffe(timeseries model, timeseries observation) -> double"""
+ """
+ nash_sutcliffe(timeseries model, timeseries observation) -> double
+
+ double
+ cmf::math::nash_sutcliffe(const cmf::math::timeseries &model, const
+ cmf::math::timeseries &observation)
+
+ Calculates the Nash-Sutcliffe efficiency of a modeled timeseries in
+ comparison with an observed timeseries.
+
+ The Nash-Sutcliffe efficiancy is defined as:
+
+ .. math::
+
+ E = 1 -
+ \\frac{\\sum_{t=1}^{T}(M_t - O_t)^2}{\\sum_{t=1}^{T}(O_t -
+ \\overline{O})^2}
+
+ where :math:`T` is the number of observation time
+ steps
+
+ :math:`M` is the timeseries of model results matchinig O
+
+ :math:`O` is the timeseries containing observations
+
+ :math:`\\overline{O}` is the arithmetic mean of observations
+ """
return _cmf_core.nash_sutcliffe(*args, **kwargs)
def AsCMFtime(date):
@@ -1131,7 +1728,22 @@ def xtimerange(start,end,step=day):
return (start+step*x for x in range(0,int((end-start)/step)))
class integratable(object):
- """Proxy of C++ cmf::math::integratable class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -1140,22 +1752,52 @@ def __init__(self, *args, **kwargs):
__repr__ = _swig_repr
def integrate(self, *args, **kwargs):
- """integrate(integratable self, Time t)"""
+ """
+ integrate(integratable self, Time t)
+
+ virtual
+ void integrate(Time t)=0
+
+ Integrates the variable until time t.
+ """
return _cmf_core.integratable_integrate(self, *args, **kwargs)
def reset(self, *args, **kwargs):
- """reset(integratable self, Time t)"""
+ """
+ reset(integratable self, Time t)
+
+ virtual void
+ reset(Time t)=0
+
+ Sets the start time of the integral.
+ """
return _cmf_core.integratable_reset(self, *args, **kwargs)
def sum(self, *args, **kwargs):
- """sum(integratable self) -> double"""
+ """
+ sum(integratable self) -> double
+
+ virtual double
+ sum() const =0
+
+ Get the integral from the last reset until the last call of integrate.
+
+ """
return _cmf_core.integratable_sum(self, *args, **kwargs)
def avg(self, *args, **kwargs):
- """avg(integratable self) -> double"""
+ """
+ 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.
+ """
return _cmf_core.integratable_avg(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_integratable
@@ -1167,18 +1809,40 @@ def avg(self, *args, **kwargs):
integratable_swigregister(integratable)
class integratable_list(object):
- """Proxy of C++ cmf::math::integratable_list class."""
+ """
+
+
+ A list of cmf::math::integratable objects.
+
+ Todo TODO: Complete collection interface (getitem with slicing etc.)
+
+ C++ includes: statevariable.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def append(self, *args, **kwargs):
- """append(integratable_list self, cmf::math::integratable::ptr add)"""
+ """
+ append(integratable_list self, cmf::math::integratable::ptr add)
+
+ void
+ append(cmf::math::integratable::ptr add)
+
+ Adds an integratable to the list.
+ """
return _cmf_core.integratable_list_append(self, *args, **kwargs)
def remove(self, *args, **kwargs):
- """remove(integratable_list self, cmf::math::integratable::ptr rm)"""
+ """
+ remove(integratable_list self, cmf::math::integratable::ptr rm)
+
+ void
+ remove(cmf::math::integratable::ptr rm)
+
+ Removes an integratable from the list.
+ """
return _cmf_core.integratable_list_remove(self, *args, **kwargs)
@@ -1188,27 +1852,52 @@ def __getitem(self, *args, **kwargs):
def size(self, *args, **kwargs):
- """size(integratable_list self) -> size_t"""
+ """
+ size(integratable_list self) -> size_t
+
+ size_t
+ size() const
+
+ Number of integratables in the list.
+ """
return _cmf_core.integratable_list_size(self, *args, **kwargs)
def avg(self, *args, **kwargs):
- """avg(integratable_list self) -> cmf::math::num_array"""
+ """
+ avg(integratable_list self) -> cmf::math::num_array
+
+ cmf::math::num_array avg() const
+ """
return _cmf_core.integratable_list_avg(self, *args, **kwargs)
def sum(self, *args, **kwargs):
- """sum(integratable_list self) -> cmf::math::num_array"""
+ """
+ sum(integratable_list self) -> cmf::math::num_array
+
+ cmf::math::num_array sum() const
+ """
return _cmf_core.integratable_list_sum(self, *args, **kwargs)
def reset(self, *args, **kwargs):
- """reset(integratable_list self, Time t)"""
+ """
+ reset(integratable_list self, Time t)
+
+ void
+ reset(Time t)
+ """
return _cmf_core.integratable_list_reset(self, *args, **kwargs)
def integrate(self, *args, **kwargs):
- """integrate(integratable_list self, Time t)"""
+ """
+ integrate(integratable_list self, Time t)
+
+ void
+ integrate(Time t)
+ """
return _cmf_core.integratable_list_integrate(self, *args, **kwargs)
@@ -1216,6 +1905,8 @@ 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)
"""
_cmf_core.integratable_list_swiginit(self, _cmf_core.new_integratable_list(*args))
@@ -1251,7 +1942,15 @@ def __getitem__(self,index):
integratable_list_swigregister(integratable_list)
class StateVariable(object):
- """Proxy of C++ cmf::math::StateVariable class."""
+ """
+
+
+ Abstract class state variable.
+
+ Simple exponential system class header implementing a state variable:
+
+ C++ includes: statevariable.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -1260,17 +1959,33 @@ def __init__(self, *args, **kwargs):
__repr__ = _swig_repr
def dxdt(self, *args, **kwargs):
- """dxdt(StateVariable self, Time time) -> real"""
+ """
+ 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.
+ """
return _cmf_core.StateVariable_dxdt(self, *args, **kwargs)
def get_abs_errtol(self, *args, **kwargs):
- """get_abs_errtol(StateVariable self, real rel_errtol) -> real"""
+ """
+ get_abs_errtol(StateVariable self, real rel_errtol) -> real
+
+ virtual real get_abs_errtol(real rel_errtol) const
+ """
return _cmf_core.StateVariable_get_abs_errtol(self, *args, **kwargs)
def to_string(self, *args, **kwargs):
- """to_string(StateVariable self) -> std::string"""
+ """
+ to_string(StateVariable self) -> std::string
+
+ virtual
+ std::string to_string() const =0
+ """
return _cmf_core.StateVariable_to_string(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_StateVariable
@@ -1286,7 +2001,14 @@ def __repr__(self):
StateVariable_swigregister(StateVariable)
class StateVariableOwner(object):
- """Proxy of C++ cmf::math::StateVariableOwner class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -1295,7 +2017,14 @@ def __init__(self, *args, **kwargs):
__repr__ = _swig_repr
def get_states(self, *args, **kwargs):
- """get_states(StateVariableOwner self) -> StateVariableList"""
+ """
+ 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.
+ """
return _cmf_core.StateVariableOwner_get_states(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_StateVariableOwner
@@ -1310,12 +2039,22 @@ class StateVariableList(StateVariableOwner):
__repr__ = _swig_repr
def append(self, *args, **kwargs):
- """append(StateVariableList self, cmf::math::StateVariable::ptr sv)"""
+ """
+ append(StateVariableList self, cmf::math::StateVariable::ptr sv)
+
+ void
+ append(StateVariable::ptr sv)
+ """
return _cmf_core.StateVariableList_append(self, *args, **kwargs)
def extend(self, *args, **kwargs):
- """extend(StateVariableList self, StateVariableOwner svo)"""
+ """
+ extend(StateVariableList self, StateVariableOwner svo)
+
+ void
+ extend(StateVariableOwner &svo)
+ """
return _cmf_core.StateVariableList_extend(self, *args, **kwargs)
@@ -1328,7 +2067,12 @@ def __iadd__(self, *args):
def size(self, *args, **kwargs):
- """size(StateVariableList self) -> size_t"""
+ """
+ size(StateVariableList self) -> size_t
+
+ size_t
+ size() const
+ """
return _cmf_core.StateVariableList_size(self, *args, **kwargs)
@@ -1350,7 +2094,17 @@ def __init__(self, *args, **kwargs):
StateVariableList_swigregister(StateVariableList)
class Integrator(StateVariableOwner):
- """Proxy of C++ cmf::math::Integrator class."""
+ """
+
+
+ Base class for any kind of integrator.
+
+ Pure virtual functions: Integrate
+
+ copy Please provide a custom copy constructor
+
+ C++ includes: integrator.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -1359,17 +2113,34 @@ def __init__(self, *args, **kwargs):
__repr__ = _swig_repr
def get_dxdt(self, *args, **kwargs):
- """get_dxdt(Integrator self, Time time) -> cmf::math::num_array"""
+ """
+ get_dxdt(Integrator self, Time time) -> cmf::math::num_array
+
+ cmf::math::num_array get_dxdt(Time time) const
+ """
return _cmf_core.Integrator_get_dxdt(self, *args, **kwargs)
def add_states(self, *args, **kwargs):
- """add_states(Integrator self, StateVariableOwner stateOwner)"""
+ """
+ add_states(Integrator self, StateVariableOwner stateOwner)
+
+ virtual
+ void add_states(cmf::math::StateVariableOwner &stateOwner)
+
+ Add state variables from a StateVariableOwner.
+ """
return _cmf_core.Integrator_add_states(self, *args, **kwargs)
def add_single_state(self, *args, **kwargs):
- """add_single_state(Integrator self, cmf::math::StateVariable::ptr state)"""
+ """
+ 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.
+ """
return _cmf_core.Integrator_add_single_state(self, *args, **kwargs)
integratables = _swig_property(_cmf_core.Integrator_integratables_get, _cmf_core.Integrator_integratables_set)
@@ -1377,17 +2148,39 @@ def add_single_state(self, *args, **kwargs):
use_OpenMP = _swig_property(_cmf_core.Integrator_use_OpenMP_get, _cmf_core.Integrator_use_OpenMP_set)
def size(self, *args, **kwargs):
- """size(Integrator self) -> size_t"""
+ """
+ size(Integrator self) -> size_t
+
+ size_t size()
+ const
+
+ returns the number of state variables
+ """
return _cmf_core.Integrator_size(self, *args, **kwargs)
def get_state(self, *args, **kwargs):
- """get_state(Integrator self, ptrdiff_t position) -> real"""
+ """
+ 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.
+ """
return _cmf_core.Integrator_get_state(self, *args, **kwargs)
def set_state(self, *args, **kwargs):
- """set_state(Integrator self, ptrdiff_t position, real newState)"""
+ """
+ set_state(Integrator self, ptrdiff_t position, real newState)
+
+ void
+ set_state(ptrdiff_t position, real newState)
+
+ Simplifies the assessment of state variables.
+ """
return _cmf_core.Integrator_set_state(self, *args, **kwargs)
@@ -1395,43 +2188,117 @@ 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
"""
return _cmf_core.Integrator_get_states(self, *args)
__swig_destroy__ = _cmf_core.delete_Integrator
def get_t(self, *args, **kwargs):
- """get_t(Integrator self) -> Time"""
+ """
+ get_t(Integrator self) -> Time
+
+ cmf::math::Time
+ get_t() const
+
+ Returns the current model time.
+ """
return _cmf_core.Integrator_get_t(self, *args, **kwargs)
def set_t(self, *args, **kwargs):
- """set_t(Integrator self, Time val)"""
+ """
+ set_t(Integrator self, Time val)
+
+ void
+ set_t(cmf::math::Time val)
+
+ Sets the current model time.
+ """
return _cmf_core.Integrator_set_t(self, *args, **kwargs)
def get_dt(self, *args, **kwargs):
- """get_dt(Integrator self) -> Time"""
+ """
+ get_dt(Integrator self) -> Time
+
+ cmf::math::Time
+ get_dt() const
+
+ Returns the last time step.
+ """
return _cmf_core.Integrator_get_dt(self, *args, **kwargs)
def reset(self, *args, **kwargs):
- """reset(Integrator self)"""
+ """
+ reset(Integrator self)
+
+ virtual void
+ reset()
+
+ Resets any saved history (for multistep methods)
+ """
return _cmf_core.Integrator_reset(self, *args, **kwargs)
def copy(self, *args, **kwargs):
- """copy(Integrator self) -> Integrator"""
+ """
+ copy(Integrator self) -> Integrator
+
+ virtual
+ Integrator* copy() const =0
+
+ Polymorphic copy constructor.
+ """
return _cmf_core.Integrator_copy(self, *args, **kwargs)
def integrate(self, *args, **kwargs):
- """integrate(Integrator self, Time t_max, Time dt) -> int"""
+ """
+ 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
+ """
return _cmf_core.Integrator_integrate(self, *args, **kwargs)
def integrate_until(self, *args, **kwargs):
- """integrate_until(Integrator self, Time t_max, Time dt, bool reset=False)"""
+ """
+ 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
+ """
return _cmf_core.Integrator_integrate_until(self, *args, **kwargs)
@@ -1476,13 +2343,37 @@ def run(self,start=None,end=None,step=day*1):
Integrator_swigregister(Integrator)
class BDF2(Integrator):
- """Proxy of C++ cmf::math::BDF2 class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def get_error_position(self, *args, **kwargs):
- """get_error_position(BDF2 self) -> int"""
+ """
+ get_error_position(BDF2 self) -> int
+
+ int
+ get_error_position() const
+
+ Returns the position of the biggest error.
+ """
return _cmf_core.BDF2_get_error_position(self, *args, **kwargs)
max_order = _swig_property(_cmf_core.BDF2_max_order_get, _cmf_core.BDF2_max_order_set)
@@ -1492,15 +2383,31 @@ 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
- """
- _cmf_core.BDF2_swiginit(self, _cmf_core.new_BDF2(*args))
- __swig_destroy__ = _cmf_core.delete_BDF2
+
+ BDF2(const Integrator
+ &templ)
+
+ Constructs a new BDF2 integrator.
+
+ Parameters:
+ -----------
+
+ templ: Template to be used to construct a BDF2 method
+ """
+ _cmf_core.BDF2_swiginit(self, _cmf_core.new_BDF2(*args))
+ __swig_destroy__ = _cmf_core.delete_BDF2
BDF2.get_error_position = new_instancemethod(_cmf_core.BDF2_get_error_position, None, BDF2)
BDF2_swigregister = _cmf_core.BDF2_swigregister
BDF2_swigregister(BDF2)
class ExplicitEuler_fixed(Integrator):
- """Proxy of C++ cmf::math::ExplicitEuler_fixed class."""
+ """
+
+
+ An explicit Euler integrator, with a fixed time step.
+
+ C++ includes: explicit_euler.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -1510,6 +2417,10 @@ def __init__(self, *args):
__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
"""
_cmf_core.ExplicitEuler_fixed_swiginit(self, _cmf_core.new_ExplicitEuler_fixed(*args))
__swig_destroy__ = _cmf_core.delete_ExplicitEuler_fixed
@@ -1517,7 +2428,15 @@ def __init__(self, *args):
ExplicitEuler_fixed_swigregister(ExplicitEuler_fixed)
class HeunIntegrator(Integrator):
- """Proxy of C++ cmf::math::HeunIntegrator class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -1528,6 +2447,10 @@ 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
"""
_cmf_core.HeunIntegrator_swiginit(self, _cmf_core.new_HeunIntegrator(*args))
__swig_destroy__ = _cmf_core.delete_HeunIntegrator
@@ -1535,7 +2458,13 @@ def __init__(self, *args):
HeunIntegrator_swigregister(HeunIntegrator)
class ImplicitEuler(Integrator):
- """Proxy of C++ cmf::math::ImplicitEuler class."""
+ """
+
+
+ An implicit (backward) Euler integrator using fixpoint iteration.
+
+ C++ includes: implicit_euler.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -1546,6 +2475,10 @@ 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
"""
_cmf_core.ImplicitEuler_swiginit(self, _cmf_core.new_ImplicitEuler(*args))
__swig_destroy__ = _cmf_core.delete_ImplicitEuler
@@ -1553,7 +2486,14 @@ def __init__(self, *args):
ImplicitEuler_swigregister(ImplicitEuler)
class RKFIntegrator(Integrator):
- """Proxy of C++ cmf::math::RKFIntegrator class."""
+ """
+
+
+ Integrates a vector of cmf::math::StateVariable with the Runge-Kutta-
+ Fehlberg (RKF54) method.
+
+ C++ includes: RKFintegrator.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -1562,6 +2502,18 @@ def __init__(self, *args):
"""
__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)
"""
_cmf_core.RKFIntegrator_swiginit(self, _cmf_core.new_RKFIntegrator(*args))
__swig_destroy__ = _cmf_core.delete_RKFIntegrator
@@ -1569,7 +2521,15 @@ def __init__(self, *args):
RKFIntegrator_swigregister(RKFIntegrator)
class CVodeIntegrator(Integrator):
- """Proxy of C++ cmf::math::CVodeIntegrator class."""
+ """
+
+
+ A wrapper class for the CVODE integrator from the SUNDIALS library.
+
+ https://computation.llnl.gov/casc/sundials/main.html
+
+ C++ includes: cvodeintegrator.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -1583,12 +2543,29 @@ class CVodeIntegrator(Integrator):
max_step = _swig_property(_cmf_core.CVodeIntegrator_max_step_get, _cmf_core.CVodeIntegrator_max_step_set)
def initialize(self, *args, **kwargs):
- """initialize(CVodeIntegrator self)"""
+ """
+ initialize(CVodeIntegrator self)
+
+ void
+ initialize()
+
+ Initializes the solver. Do not add or remove state variables after
+ initialization. The solver is automatically intialized when
+ integrating.
+ """
return _cmf_core.CVodeIntegrator_initialize(self, *args, **kwargs)
def release(self, *args, **kwargs):
- """release(CVodeIntegrator self)"""
+ """
+ release(CVodeIntegrator self)
+
+ void
+ release()
+
+ Releases the internal solver. Call release before you add state
+ variables or to change properties.
+ """
return _cmf_core.CVodeIntegrator_release(self, *args, **kwargs)
@@ -1597,26 +2574,59 @@ def __init__(self, *args):
__init__(cmf::math::CVodeIntegrator self, real epsilon=1e-9, char _preconditioner) -> CVodeIntegrator
__init__(cmf::math::CVodeIntegrator self, StateVariableOwner states, real epsilon=1e-9, char _preconditioner) -> CVodeIntegrator
__init__(cmf::math::CVodeIntegrator self, CVodeIntegrator templ) -> CVodeIntegrator
+
+ CVodeIntegrator(const CVodeIntegrator &templ)
+
+ copy constructor, creates a new CVODE integrator similiar to the
+ given, but without statevariables
"""
_cmf_core.CVodeIntegrator_swiginit(self, _cmf_core.new_CVodeIntegrator(*args))
def get_error(self, *args, **kwargs):
- """get_error(CVodeIntegrator self) -> cmf::math::num_array"""
+ """
+ get_error(CVodeIntegrator self) -> cmf::math::num_array
+
+ cmf::math::num_array get_error() const
+
+ Error vector of the integrator.
+ """
return _cmf_core.CVodeIntegrator_get_error(self, *args, **kwargs)
def get_nonlinear_iterations(self, *args, **kwargs):
- """get_nonlinear_iterations(CVodeIntegrator self) -> int"""
+ """
+ get_nonlinear_iterations(CVodeIntegrator self) -> int
+
+ int
+ get_nonlinear_iterations() const
+
+ Returns the number of non-linear iterations performed. Calls
+ CVodeGetNumNonlinSolvIters.
+ """
return _cmf_core.CVodeIntegrator_get_nonlinear_iterations(self, *args, **kwargs)
def get_rhsevals(self, *args, **kwargs):
- """get_rhsevals(CVodeIntegrator self) -> int"""
+ """
+ get_rhsevals(CVodeIntegrator self) -> int
+
+ int
+ get_rhsevals() const
+
+ Returns the number of evaluations of the right hand side of the ODE.
+ Calls CVodeGetNumRhsEvals.
+ """
return _cmf_core.CVodeIntegrator_get_rhsevals(self, *args, **kwargs)
def copy(self, *args, **kwargs):
- """copy(CVodeIntegrator self) -> CVodeIntegrator"""
+ """
+ copy(CVodeIntegrator self) -> CVodeIntegrator
+
+ CVodeIntegrator* copy() const
+
+ Polymorphic copy constructor.
+ """
return _cmf_core.CVodeIntegrator_copy(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_CVodeIntegrator
@@ -1631,23 +2641,60 @@ def copy(self, *args, **kwargs):
CVodeIntegrator_swigregister(CVodeIntegrator)
class MultiIntegrator(Integrator):
- """Proxy of C++ cmf::math::MultiIntegrator class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def copy(self, *args, **kwargs):
- """copy(MultiIntegrator self) -> MultiIntegrator"""
+ """
+ copy(MultiIntegrator self) -> MultiIntegrator
+
+ virtual
+ cmf::math::MultiIntegrator* copy() const
+
+ Polymorphic copy constructor.
+ """
return _cmf_core.MultiIntegrator_copy(self, *args, **kwargs)
def add_states_to_integrator(self, *args, **kwargs):
- """add_states_to_integrator(MultiIntegrator self, StateVariableOwner stateOwner, int integrator_position)"""
+ """
+ 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.
+ """
return _cmf_core.MultiIntegrator_add_states_to_integrator(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
- """__init__(cmf::math::MultiIntegrator self, Integrator template_integrator, int count) -> MultiIntegrator"""
+ """
+ __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
+ """
_cmf_core.MultiIntegrator_swiginit(self, _cmf_core.new_MultiIntegrator(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_MultiIntegrator
MultiIntegrator.copy = new_instancemethod(_cmf_core.MultiIntegrator_copy, None, MultiIntegrator)
@@ -1656,7 +2703,15 @@ def __init__(self, *args, **kwargs):
MultiIntegrator_swigregister(MultiIntegrator)
class Adsorption(object):
- """Proxy of C++ cmf::water::Adsorption class."""
+ """
+
+
+ Abstract class to use adsorption process for tracers on surfaces.
+
+ Use the derived classes to use a certain isotherm
+
+ C++ includes: adsorption.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -1665,17 +2720,62 @@ def __init__(self, *args, **kwargs):
__repr__ = _swig_repr
def freesolute(self, *args, **kwargs):
- """freesolute(Adsorption self, real xt, real V) -> real"""
+ """
+ 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
+ """
return _cmf_core.Adsorption_freesolute(self, *args, **kwargs)
def totalsolute(self, *args, **kwargs):
- """totalsolute(Adsorption self, real xf, real V) -> real"""
+ """
+ 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
+ """
return _cmf_core.Adsorption_totalsolute(self, *args, **kwargs)
def copy(self, *args, **kwargs):
- """copy(Adsorption self, real m=-1) -> Adsorption"""
+ """
+ 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.
+ """
return _cmf_core.Adsorption_copy(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_Adsorption
@@ -1686,13 +2786,31 @@ def copy(self, *args, **kwargs):
Adsorption_swigregister(Adsorption)
class NullAdsorption(Adsorption):
- """Proxy of C++ cmf::water::NullAdsorption class."""
+ """
+
+
+ A class for tracers without interaction with the storage container.
+ freesolute returns xt.
+
+ C++ includes: adsorption.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def copy(self, *args, **kwargs):
- """copy(NullAdsorption self, real m=-1) -> NullAdsorption"""
+ """
+ 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.
+ """
return _cmf_core.NullAdsorption_copy(self, *args, **kwargs)
@@ -1705,7 +2823,43 @@ def __init__(self, *args, **kwargs):
NullAdsorption_swigregister(NullAdsorption)
class LinearAdsorption(Adsorption):
- """Proxy of C++ cmf::water::LinearAdsorption class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -1716,11 +2870,23 @@ 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)
"""
_cmf_core.LinearAdsorption_swiginit(self, _cmf_core.new_LinearAdsorption(*args))
def copy(self, *args, **kwargs):
- """copy(LinearAdsorption self, real m=-1) -> LinearAdsorption"""
+ """
+ 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.
+ """
return _cmf_core.LinearAdsorption_copy(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_LinearAdsorption
@@ -1729,7 +2895,44 @@ def copy(self, *args, **kwargs):
LinearAdsorption_swigregister(LinearAdsorption)
class FreundlichAdsorbtion(Adsorption):
- """Proxy of C++ cmf::water::FreundlichAdsorbtion class."""
+ """
+
+
+ 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. 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -1743,11 +2946,23 @@ 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)
"""
_cmf_core.FreundlichAdsorbtion_swiginit(self, _cmf_core.new_FreundlichAdsorbtion(*args))
def copy(self, *args, **kwargs):
- """copy(FreundlichAdsorbtion self, real m=-1) -> FreundlichAdsorbtion"""
+ """
+ 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.
+ """
return _cmf_core.FreundlichAdsorbtion_copy(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_FreundlichAdsorbtion
@@ -1756,7 +2971,42 @@ def copy(self, *args, **kwargs):
FreundlichAdsorbtion_swigregister(FreundlichAdsorbtion)
class LangmuirAdsorption(Adsorption):
- """Proxy of C++ cmf::water::LangmuirAdsorption class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -1767,11 +3017,23 @@ 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)
"""
_cmf_core.LangmuirAdsorption_swiginit(self, _cmf_core.new_LangmuirAdsorption(*args))
def copy(self, *args, **kwargs):
- """copy(LangmuirAdsorption self, real m=-1) -> LangmuirAdsorption"""
+ """
+ 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.
+ """
return _cmf_core.LangmuirAdsorption_copy(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_LangmuirAdsorption
@@ -1780,12 +3042,23 @@ def copy(self, *args, **kwargs):
LangmuirAdsorption_swigregister(LangmuirAdsorption)
class solute(object):
- """Proxy of C++ cmf::water::solute class."""
+ """
+
+
+ A structure to identify a solute.
+
+ C++ includes: Solute.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
- """__init__(cmf::water::solute self, solute copy) -> solute"""
+ """
+ __init__(cmf::water::solute self, solute copy) -> solute
+
+ solute(const
+ solute ©)
+ """
_cmf_core.solute_swiginit(self, _cmf_core.new_solute(*args, **kwargs))
def __eq__(self, *args, **kwargs):
@@ -1838,22 +3111,44 @@ def __repr__(self, *args, **kwargs):
solute_swigregister(solute)
class solute_vector(object):
- """Proxy of C++ cmf::water::solute_vector class."""
+ """
+
+
+ Manages the solutes of the model.
+
+ C++ includes: Solute.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def size(self, *args, **kwargs):
- """size(solute_vector self) -> size_t"""
+ """
+ size(solute_vector self) -> size_t
+
+ size_t size()
+ const
+ """
return _cmf_core.solute_vector_size(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
- """__init__(cmf::water::solute_vector self, std::string str) -> solute_vector"""
+ """
+ __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")
+ """
_cmf_core.solute_vector_swiginit(self, _cmf_core.new_solute_vector(*args, **kwargs))
def get_solute(self, *args, **kwargs):
- """get_solute(solute_vector self, int position) -> solute"""
+ """
+ get_solute(solute_vector self, int position) -> solute
+
+ cmf::water::solute* get_solute(int position)
+ """
return _cmf_core.solute_vector_get_solute(self, *args, **kwargs)
@@ -1882,18 +3177,36 @@ def __repr__(self):
solute_vector_swigregister(solute_vector)
class SoluteTimeseries(object):
- """Proxy of C++ cmf::water::SoluteTimeseries class."""
+ """
+
+
+ A map of concentration time series for solutes.
+
+ C++ includes: Solute.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def conc(self, *args, **kwargs):
- """conc(SoluteTimeseries self, Time t, solute _Solute) -> real"""
+ """
+ conc(SoluteTimeseries self, Time t, solute _Solute) -> real
+
+ real
+ conc(cmf::math::Time t, const cmf::water::solute &_Solute) const
+ """
return _cmf_core.SoluteTimeseries_conc(self, *args, **kwargs)
def size(self, *args, **kwargs):
- """size(SoluteTimeseries self) -> size_t"""
+ """
+ size(SoluteTimeseries self) -> size_t
+
+ size_t
+ size() const
+
+ Returns the number of solutes in the solution.
+ """
return _cmf_core.SoluteTimeseries_size(self, *args, **kwargs)
@@ -1902,6 +3215,8 @@ def __init__(self, *args):
__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)
"""
_cmf_core.SoluteTimeseries_swiginit(self, _cmf_core.new_SoluteTimeseries(*args))
@@ -1929,7 +3244,34 @@ def __len__(self, *args, **kwargs):
SoluteTimeseries_swigregister(SoluteTimeseries)
class SoluteStorage(StateVariable):
- """Proxy of C++ cmf::water::SoluteStorage class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -1938,7 +3280,11 @@ def __init__(self, *args, **kwargs):
__repr__ = _swig_repr
def set_adsorption(self, *args, **kwargs):
- """set_adsorption(SoluteStorage self, Adsorption newadsorption, real m=-1)"""
+ """
+ set_adsorption(SoluteStorage self, Adsorption newadsorption, real m=-1)
+
+ void set_adsorption(const Adsorption &newadsorption, real m=-1)
+ """
return _cmf_core.SoluteStorage_set_adsorption(self, *args, **kwargs)
decay = _swig_property(_cmf_core.SoluteStorage_decay_get, _cmf_core.SoluteStorage_decay_set)
@@ -1946,13 +3292,29 @@ def set_adsorption(self, *args, **kwargs):
Solute = _swig_property(_cmf_core.SoluteStorage_Solute_get)
def conc(self, *args, **kwargs):
- """conc(SoluteStorage self) -> real"""
+ """
+ conc(SoluteStorage self) -> real
+
+ real conc()
+ const
+
+ Returns the concentration of the solute.
+ """
return _cmf_core.SoluteStorage_conc(self, *args, **kwargs)
def set_conc(self, *args, **kwargs):
- """set_conc(SoluteStorage self, real NewConcentration)"""
- return _cmf_core.SoluteStorage_set_conc(self, *args, **kwargs)
+ """
+ set_conc(SoluteStorage self, real NewConcentration)
+
+ void
+ set_conc(real NewConcentration)
+
+ set a new concentration of dissolved tracers.
+
+ In case of adsorption functions, the isotherm is used
+ """
+ return _cmf_core.SoluteStorage_set_conc(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_SoluteStorage
SoluteStorage.set_adsorption = new_instancemethod(_cmf_core.SoluteStorage_set_adsorption, None, SoluteStorage)
@@ -1962,20 +3324,43 @@ def set_conc(self, *args, **kwargs):
SoluteStorage_swigregister(SoluteStorage)
class flux_node(object):
- """Proxy of C++ cmf::water::flux_node class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
node_id = _swig_property(_cmf_core.flux_node_node_id_get)
def is_storage(self, *args, **kwargs):
- """is_storage(flux_node self) -> bool"""
+ """
+ is_storage(flux_node self) -> bool
+
+ virtual
+ bool is_storage() const
+
+ true, if this is a waterstorage
+ """
return _cmf_core.flux_node_is_storage(self, *args, **kwargs)
Name = _swig_property(_cmf_core.flux_node_Name_get, _cmf_core.flux_node_Name_set)
def to_string(self, *args, **kwargs):
- """to_string(flux_node self) -> std::string"""
+ """
+ to_string(flux_node self) -> std::string
+
+ virtual
+ std::string to_string() const
+ """
return _cmf_core.flux_node_to_string(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_flux_node
@@ -1986,37 +3371,99 @@ def __eq__(self, *args, **kwargs):
def RecalcFluxes(self, *args, **kwargs):
- """RecalcFluxes(flux_node self, Time t) -> bool"""
+ """
+ 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
+ """
return _cmf_core.flux_node_RecalcFluxes(self, *args, **kwargs)
def connection_to(self, *args, **kwargs):
- """connection_to(flux_node self, flux_node target) -> flux_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.
+ """
return _cmf_core.flux_node_connection_to(self, *args, **kwargs)
def remove_connection(self, *args, **kwargs):
- """remove_connection(flux_node self, cmf::water::flux_node::ptr To) -> bool"""
+ """
+ remove_connection(flux_node self, cmf::water::flux_node::ptr To) -> bool
+
+ bool
+ remove_connection(cmf::water::flux_node::ptr To)
+
+ Remove the connection.
+ """
return _cmf_core.flux_node_remove_connection(self, *args, **kwargs)
def flux_to(self, *args, **kwargs):
- """flux_to(flux_node self, flux_node target, Time t) -> real"""
+ """
+ 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")
+ """
return _cmf_core.flux_node_flux_to(self, *args, **kwargs)
def flux3d_to(self, *args, **kwargs):
- """flux3d_to(flux_node self, flux_node target, Time t) -> point"""
+ """
+ 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)
+ """
return _cmf_core.flux_node_flux3d_to(self, *args, **kwargs)
def get_3d_flux(self, *args, **kwargs):
- """get_3d_flux(flux_node self, Time t) -> point"""
+ """
+ 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.
+ """
return _cmf_core.flux_node_get_3d_flux(self, *args, **kwargs)
def waterbalance(self, *args, **kwargs):
- """waterbalance(flux_node self, Time t, flux_connection Without=None) -> real"""
+ """
+ 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)
+ """
return _cmf_core.flux_node_waterbalance(self, *args, **kwargs)
@@ -2026,18 +3473,38 @@ def __call__(self, *args, **kwargs):
def conc(self, *args, **kwargs):
- """conc(flux_node self, Time t, solute Solute) -> real"""
+ """
+ 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.
+ """
return _cmf_core.flux_node_conc(self, *args, **kwargs)
position = _swig_property(_cmf_core.flux_node_position_get, _cmf_core.flux_node_position_set)
def is_empty(self, *args, **kwargs):
- """is_empty(flux_node self) -> double"""
+ """
+ is_empty(flux_node self) -> double
+
+ virtual
+ double is_empty() const
+
+ Returns true if the node has no water.
+ """
return _cmf_core.flux_node_is_empty(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
- """__init__(cmf::water::flux_node self, project _project, point location) -> flux_node"""
+ """
+ __init__(cmf::water::flux_node self, project _project, point location) -> flux_node
+
+ flux_node(cmf::project &_project, cmf::geometry::point
+ location=cmf::geometry::point())
+ """
_cmf_core.flux_node_swiginit(self, _cmf_core.new_flux_node(*args, **kwargs))
project = _swig_property(_cmf_core.flux_node_project_get)
potential = _swig_property(_cmf_core.flux_node_potential_get, _cmf_core.flux_node_potential_set)
@@ -2068,44 +3535,98 @@ def connected_nodes(self):
def count_node_references(*args, **kwargs):
- """count_node_references(cmf::water::flux_node::ptr node) -> int"""
+ """
+ count_node_references(cmf::water::flux_node::ptr node) -> int
+
+ int
+ cmf::water::count_node_references(flux_node::ptr node)
+ """
return _cmf_core.count_node_references(*args, **kwargs)
def get_higher_node(*args, **kwargs):
- """get_higher_node(cmf::water::flux_node::ptr node1, cmf::water::flux_node::ptr node2) -> cmf::water::flux_node::ptr"""
+ """
+ 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)
+ """
return _cmf_core.get_higher_node(*args, **kwargs)
def get_lower_node(*args, **kwargs):
- """get_lower_node(cmf::water::flux_node::ptr node1, cmf::water::flux_node::ptr node2) -> cmf::water::flux_node::ptr"""
+ """
+ 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)
+
+ """
return _cmf_core.get_lower_node(*args, **kwargs)
class waterbalance_integrator(integratable):
- """Proxy of C++ cmf::water::waterbalance_integrator class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def integration_t(self, *args, **kwargs):
- """integration_t(waterbalance_integrator self) -> Time"""
+ """
+ integration_t(waterbalance_integrator self) -> Time
+
+ cmf::math::Time
+ integration_t() const
+
+ Returns the duration of the integration.
+ """
return _cmf_core.waterbalance_integrator_integration_t(self, *args, **kwargs)
def t0(self, *args, **kwargs):
- """t0(waterbalance_integrator self) -> Time"""
+ """
+ t0(waterbalance_integrator self) -> Time
+
+ cmf::math::Time t0() const
+
+ Returns the start time of the integration.
+ """
return _cmf_core.waterbalance_integrator_t0(self, *args, **kwargs)
def __get_node(self, *args, **kwargs):
- """__get_node(waterbalance_integrator self) -> cmf::water::flux_node::ptr"""
+ """
+ __get_node(waterbalance_integrator self) -> cmf::water::flux_node::ptr
+
+ flux_node::ptr get_node() const
+
+ Returns the node of this integrator.
+ """
return _cmf_core.waterbalance_integrator___get_node(self, *args, **kwargs)
def __set_node(self, *args, **kwargs):
- """__set_node(waterbalance_integrator self, cmf::water::flux_node::ptr node)"""
+ """
+ __set_node(waterbalance_integrator self, cmf::water::flux_node::ptr node)
+
+ void set_node(cmf::water::flux_node::ptr node)
+ """
return _cmf_core.waterbalance_integrator___set_node(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
- """__init__(cmf::water::waterbalance_integrator self, cmf::water::flux_node::ptr node) -> waterbalance_integrator"""
+ """
+ __init__(cmf::water::waterbalance_integrator self, cmf::water::flux_node::ptr node) -> waterbalance_integrator
+
+ waterbalance_integrator(cmf::water::flux_node::ptr node)
+ """
_cmf_core.waterbalance_integrator_swiginit(self, _cmf_core.new_waterbalance_integrator(*args, **kwargs))
node = _swig_property(_cmf_core.waterbalance_integrator___get_node,
@@ -2120,7 +3641,17 @@ def __init__(self, *args, **kwargs):
waterbalance_integrator_swigregister(waterbalance_integrator)
class flux_connection(object):
- """Proxy of C++ cmf::water::flux_connection class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -2129,22 +3660,49 @@ def __init__(self, *args, **kwargs):
__repr__ = _swig_repr
def left_node(self, *args, **kwargs):
- """left_node(flux_connection self) -> cmf::water::flux_node::ptr"""
+ """
+ left_node(flux_connection self) -> cmf::water::flux_node::ptr
+
+ flux_node::ptr left_node() const
+
+ Returns the left node of this connection.
+ """
return _cmf_core.flux_connection_left_node(self, *args, **kwargs)
def right_node(self, *args, **kwargs):
- """right_node(flux_connection self) -> cmf::water::flux_node::ptr"""
+ """
+ right_node(flux_connection self) -> cmf::water::flux_node::ptr
+
+ flux_node::ptr right_node() const
+
+ returns the right node of this connection
+ """
return _cmf_core.flux_connection_right_node(self, *args, **kwargs)
def kill_me(self, *args, **kwargs):
- """kill_me(flux_connection self) -> bool"""
+ """
+ kill_me(flux_connection self) -> bool
+
+ bool
+ kill_me()
+
+ Deregisters this connection from its nodes. Returns true if only one
+ reference is left.
+ """
return _cmf_core.flux_connection_kill_me(self, *args, **kwargs)
def refresh(self, *args, **kwargs):
- """refresh(flux_connection self, Time t)"""
+ """
+ refresh(flux_connection self, Time t)
+
+ void
+ refresh(cmf::math::Time t)
+
+ Performes a new calculation of the flux.
+ """
return _cmf_core.flux_connection_refresh(self, *args, **kwargs)
connection_id = _swig_property(_cmf_core.flux_connection_connection_id_get)
@@ -2158,22 +3716,50 @@ 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.
"""
return _cmf_core.flux_connection_get_target(self, *args)
def exchange_target(self, *args, **kwargs):
- """exchange_target(flux_connection self, cmf::water::flux_node::ptr oldtarget, cmf::water::flux_node::ptr newTarget)"""
+ """
+ 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 _cmf_core.flux_connection_exchange_target(self, *args, **kwargs)
def q(self, *args, **kwargs):
- """q(flux_connection self, flux_node inquirer, Time t) -> real"""
+ """
+ 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.
+ """
return _cmf_core.flux_connection_q(self, *args, **kwargs)
def conc(self, *args, **kwargs):
- """conc(flux_connection self, Time t, solute _Solute) -> real"""
+ """
+ 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)
+ """
return _cmf_core.flux_connection_conc(self, *args, **kwargs)
type = _swig_property(_cmf_core.flux_connection_type_get)
@@ -2182,6 +3768,11 @@ 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.
+
"""
return _cmf_core.flux_connection_get_tracer_filter(self, *args)
@@ -2190,17 +3781,27 @@ 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)
"""
return _cmf_core.flux_connection_set_tracer_filter(self, *args)
def to_string(self, *args, **kwargs):
- """to_string(flux_connection self) -> std::string"""
+ """
+ to_string(flux_connection self) -> std::string
+
+ virtual std::string to_string() const
+ """
return _cmf_core.flux_connection_to_string(self, *args, **kwargs)
def short_string(self, *args, **kwargs):
- """short_string(flux_connection self) -> std::string"""
+ """
+ short_string(flux_connection self) -> std::string
+
+ virtual std::string short_string() const
+ """
return _cmf_core.flux_connection_short_string(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_flux_connection
@@ -2233,46 +3834,92 @@ def __contains__(self,cmp):
def replace_node(*args, **kwargs):
- """replace_node(cmf::water::flux_node::ptr oldnode, cmf::water::flux_node::ptr newnode) -> int"""
+ """
+ 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)
+ """
return _cmf_core.replace_node(*args, **kwargs)
class connection_list(object):
- """Proxy of C++ cmf::water::connection_list class."""
+ """
+
+
+ A self sorting list of connections.
+
+ C++ includes: flux_connection.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def append(self, *args, **kwargs):
- """append(connection_list self, cmf::water::flux_connection::ptr connection) -> bool"""
+ """
+ append(connection_list self, cmf::water::flux_connection::ptr connection) -> bool
+
+ bool
+ append(cmf::water::flux_connection::ptr connection)
+ """
return _cmf_core.connection_list_append(self, *args, **kwargs)
def extend(self, *args, **kwargs):
- """extend(connection_list self, connection_list connections)"""
+ """
+ extend(connection_list self, connection_list connections)
+
+ void
+ extend(const connection_list &connections)
+ """
return _cmf_core.connection_list_extend(self, *args, **kwargs)
def contains(self, *args, **kwargs):
- """contains(connection_list self, cmf::water::flux_connection::ptr connection) -> bool"""
+ """
+ contains(connection_list self, cmf::water::flux_connection::ptr connection) -> bool
+
+ bool
+ contains(cmf::water::flux_connection::ptr connection) const
+ """
return _cmf_core.connection_list_contains(self, *args, **kwargs)
def remove(self, *args, **kwargs):
- """remove(connection_list self, cmf::water::flux_connection::ptr connection) -> bool"""
+ """
+ remove(connection_list self, cmf::water::flux_connection::ptr connection) -> bool
+
+ bool
+ remove(cmf::water::flux_connection::ptr connection)
+ """
return _cmf_core.connection_list_remove(self, *args, **kwargs)
def do_action(self, *args, **kwargs):
- """do_action(connection_list self, Time t, bool use_OpenMP=True)"""
+ """
+ do_action(connection_list self, Time t, bool use_OpenMP=True)
+
+ void
+ do_action(cmf::math::Time t, bool use_OpenMP=true)
+ """
return _cmf_core.connection_list_do_action(self, *args, **kwargs)
def size(self, *args, **kwargs):
- """size(connection_list self) -> size_t"""
+ """
+ size(connection_list self) -> size_t
+
+ size_t
+ size() const
+ """
return _cmf_core.connection_list_size(self, *args, **kwargs)
def at(self, *args, **kwargs):
- """at(connection_list self, size_t pos) -> cmf::water::flux_connection::ptr"""
+ """
+ at(connection_list self, size_t pos) -> cmf::water::flux_connection::ptr
+
+ cmf::water::flux_connection::ptr at(size_t pos) const
+ """
return _cmf_core.connection_list_at(self, *args, **kwargs)
@@ -2280,6 +3927,8 @@ 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
"""
return _cmf_core.connection_list_begin(self, *args)
@@ -2288,6 +3937,8 @@ 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
"""
return _cmf_core.connection_list_end(self, *args)
@@ -2330,24 +3981,52 @@ def __init__(self, *args, **kwargs):
connection_list_swigregister(connection_list)
class flux_integrator(integratable):
- """Proxy of C++ cmf::water::flux_integrator class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def integration_t(self, *args, **kwargs):
- """integration_t(flux_integrator self) -> Time"""
+ """
+ integration_t(flux_integrator self) -> Time
+
+ cmf::math::Time integration_t() const
+
+ Returns the duration of the integration.
+ """
return _cmf_core.flux_integrator_integration_t(self, *args, **kwargs)
def t0(self, *args, **kwargs):
- """t0(flux_integrator self) -> Time"""
+ """
+ t0(flux_integrator self) -> Time
+
+ cmf::math::Time t0() const
+
+ Returns the start time of the integration.
+ """
return _cmf_core.flux_integrator_t0(self, *args, **kwargs)
invert = _swig_property(_cmf_core.flux_integrator_invert_get, _cmf_core.flux_integrator_invert_set)
def connection(self, *args, **kwargs):
- """connection(flux_integrator self) -> cmf::water::flux_connection::ptr"""
+ """
+ connection(flux_integrator self) -> cmf::water::flux_connection::ptr
+
+ flux_connection::ptr connection() const
+
+ Returns the flux_connection.
+ """
return _cmf_core.flux_integrator_connection(self, *args, **kwargs)
@@ -2355,6 +4034,12 @@ def __init__(self, *args):
"""
__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.
"""
_cmf_core.flux_integrator_swiginit(self, _cmf_core.new_flux_integrator(*args))
__swig_destroy__ = _cmf_core.delete_flux_integrator
@@ -2365,7 +4050,13 @@ def __init__(self, *args):
flux_integrator_swigregister(flux_integrator)
class linear_scale(object):
- """Proxy of C++ cmf::water::linear_scale class."""
+ """
+
+
+ A linear scaling functor, with slope and displacement.
+
+ C++ includes: boundary_condition.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -2378,7 +4069,13 @@ def __call__(self, *args, **kwargs):
def __init__(self, *args, **kwargs):
- """__init__(cmf::water::linear_scale self, real _slope=1, real _displacement=0) -> linear_scale"""
+ """
+ __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`)
+ """
_cmf_core.linear_scale_swiginit(self, _cmf_core.new_linear_scale(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_linear_scale
linear_scale.__call__ = new_instancemethod(_cmf_core.linear_scale___call__, None, linear_scale)
@@ -2386,24 +4083,56 @@ def __init__(self, *args, **kwargs):
linear_scale_swigregister(linear_scale)
class DirichletBoundary(flux_node):
- """Proxy of C++ cmf::water::DirichletBoundary class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def set_conc(self, *args, **kwargs):
- """set_conc(DirichletBoundary self, solute _Solute, double value)"""
+ """
+ set_conc(DirichletBoundary self, solute _Solute, double value)
+
+ virtual void set_conc(const cmf::water::solute &_Solute, double value)
+
+ """
return _cmf_core.DirichletBoundary_set_conc(self, *args, **kwargs)
is_source = _swig_property(_cmf_core.DirichletBoundary_is_source_get, _cmf_core.DirichletBoundary_is_source_set)
def RecalcFluxes(self, *args, **kwargs):
- """RecalcFluxes(DirichletBoundary self, Time t) -> bool"""
+ """
+ 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
+ """
return _cmf_core.DirichletBoundary_RecalcFluxes(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
- """__init__(cmf::water::DirichletBoundary self, project _p, real potential, point Location) -> DirichletBoundary"""
+ """
+ __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())
+ """
_cmf_core.DirichletBoundary_swiginit(self, _cmf_core.new_DirichletBoundary(*args, **kwargs))
def __repr__(self):
@@ -2416,13 +4145,29 @@ def __repr__(self):
DirichletBoundary_swigregister(DirichletBoundary)
class NeumannBoundary(flux_node):
- """Proxy of C++ cmf::water::NeumannBoundary class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def get_flux(self, *args, **kwargs):
- """get_flux(NeumannBoundary self) -> timeseries"""
+ """
+ get_flux(NeumannBoundary self) -> timeseries
+
+ cmf::math::timeseries get_flux()
+
+ The timeseries of the boundary flux.
+ """
return _cmf_core.NeumannBoundary_get_flux(self, *args, **kwargs)
@@ -2430,6 +4175,11 @@ 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.
"""
return _cmf_core.NeumannBoundary_set_flux(self, *args)
@@ -2442,7 +4192,12 @@ def __call__(self, *args, **kwargs):
def connect_to(self, *args, **kwargs):
- """connect_to(NeumannBoundary self, cmf::water::flux_node::ptr target)"""
+ """
+ connect_to(NeumannBoundary self, cmf::water::flux_node::ptr target)
+
+ void
+ connect_to(cmf::water::flux_node::ptr target)
+ """
return _cmf_core.NeumannBoundary_connect_to(self, *args, **kwargs)
@@ -2450,6 +4205,9 @@ 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())
"""
_cmf_core.NeumannBoundary_swiginit(self, _cmf_core.new_NeumannBoundary(*args))
@@ -2478,38 +4236,92 @@ def NeumannBoundary_create(*args, **kwargs):
return _cmf_core.NeumannBoundary_create(*args, **kwargs)
class NeumannFlux(flux_connection):
- """Proxy of C++ cmf::water::NeumannFlux class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
- """__init__(cmf::water::NeumannFlux self, std::shared_ptr< cmf::water::NeumannBoundary > left, cmf::water::flux_node::ptr right) -> NeumannFlux"""
+ """
+ __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)
+ """
_cmf_core.NeumannFlux_swiginit(self, _cmf_core.new_NeumannFlux(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_NeumannFlux
NeumannFlux_swigregister = _cmf_core.NeumannFlux_swigregister
NeumannFlux_swigregister(NeumannFlux)
class WaterStorage(StateVariable, StateVariableOwner, flux_node):
- """Proxy of C++ cmf::water::WaterStorage class."""
+ """
- thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
- __repr__ = _swig_repr
- def __init__(self, *args, **kwargs):
- """__init__(cmf::water::WaterStorage self, project project, std::string const & Name, double InitialState=0) -> WaterStorage"""
- _cmf_core.WaterStorage_swiginit(self, _cmf_core.new_WaterStorage(*args, **kwargs))
+ A state variable for the storage of water.
- def from_node(*args, **kwargs):
- """from_node(cmf::water::flux_node::ptr node) -> std::shared_ptr< cmf::water::WaterStorage >"""
- return _cmf_core.WaterStorage_from_node(*args, **kwargs)
+ 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:
- from_node = staticmethod(from_node)
- def Solute(self, *args):
- """
- Solute(WaterStorage self, solute _Solute) -> SoluteStorage
+ .. 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
+ """
+
+ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+
+ 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)
+
+ 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
+ """
+ _cmf_core.WaterStorage_swiginit(self, _cmf_core.new_WaterStorage(*args, **kwargs))
+
+ def from_node(*args, **kwargs):
+ """from_node(cmf::water::flux_node::ptr node) -> std::shared_ptr< cmf::water::WaterStorage >"""
+ return _cmf_core.WaterStorage_from_node(*args, **kwargs)
+
+ from_node = staticmethod(from_node)
+
+ 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
"""
return _cmf_core.WaterStorage_Solute(self, *args)
@@ -2519,6 +4331,11 @@ 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.
"""
return _cmf_core.WaterStorage_conc(self, *args)
@@ -2530,7 +4347,7 @@ def cast(*args, **kwargs):
cast = staticmethod(cast)
def create(*args, **kwargs):
- """create(project _project, real initial_state=0.0) -> std::shared_ptr< cmf::water::WaterStorage >"""
+ """create(project _project, real initial_state=0.0, real scale=1.0) -> std::shared_ptr< cmf::water::WaterStorage >"""
return _cmf_core.WaterStorage_create(*args, **kwargs)
create = staticmethod(create)
@@ -2555,31 +4372,69 @@ def WaterStorage_cast(*args, **kwargs):
return _cmf_core.WaterStorage_cast(*args, **kwargs)
def WaterStorage_create(*args, **kwargs):
- """WaterStorage_create(project _project, real initial_state=0.0) -> std::shared_ptr< cmf::water::WaterStorage >"""
+ """WaterStorage_create(project _project, real initial_state=0.0, real scale=1.0) -> std::shared_ptr< cmf::water::WaterStorage >"""
return _cmf_core.WaterStorage_create(*args, **kwargs)
class waterbalance_connection(flux_connection):
- """Proxy of C++ cmf::water::waterbalance_connection class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
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"""
+ """
+ __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)
+
+ """
_cmf_core.waterbalance_connection_swiginit(self, _cmf_core.new_waterbalance_connection(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_waterbalance_connection
waterbalance_connection_swigregister = _cmf_core.waterbalance_connection_swigregister
waterbalance_connection_swigregister(waterbalance_connection)
class external_control_connection(flux_connection):
- """Proxy of C++ cmf::water::external_control_connection class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
flux = _swig_property(_cmf_core.external_control_connection_flux_get, _cmf_core.external_control_connection_flux_set)
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"""
+ """
+ __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)
+ """
_cmf_core.external_control_connection_swiginit(self, _cmf_core.new_external_control_connection(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_external_control_connection
external_control_connection_swigregister = _cmf_core.external_control_connection_swigregister
@@ -2587,14 +4442,61 @@ def __init__(self, *args, **kwargs):
def set_flux(*args, **kwargs):
- """set_flux(cmf::water::flux_node::ptr source, cmf::water::flux_node::ptr target, real flux_value)"""
+ """
+ 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.
+ """
return _cmf_core.set_flux(*args, **kwargs)
def can_set_flux(*args, **kwargs):
- """can_set_flux(cmf::water::flux_node::ptr source, cmf::water::flux_node::ptr target) -> bool"""
+ """
+ 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
+ """
return _cmf_core.can_set_flux(*args, **kwargs)
class kinematic_wave(flux_connection):
- """Proxy of C++ cmf::water::kinematic_wave class."""
+ """
+
+
+ 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
+
+ C++ includes: simple_connections.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -2604,14 +4506,69 @@ class kinematic_wave(flux_connection):
V0 = _swig_property(_cmf_core.kinematic_wave_V0_get, _cmf_core.kinematic_wave_V0_set)
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"""
+ """
+ __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
+ """
_cmf_core.kinematic_wave_swiginit(self, _cmf_core.new_kinematic_wave(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_kinematic_wave
kinematic_wave_swigregister = _cmf_core.kinematic_wave_swigregister
kinematic_wave_swigregister(kinematic_wave)
class LinearStorageConnection(flux_connection):
- """Proxy of C++ cmf::water::LinearStorageConnection class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -2619,14 +4576,70 @@ class LinearStorageConnection(flux_connection):
residual = _swig_property(_cmf_core.LinearStorageConnection_residual_get, _cmf_core.LinearStorageConnection_residual_set)
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"""
+ """
+ __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)
+ """
_cmf_core.LinearStorageConnection_swiginit(self, _cmf_core.new_LinearStorageConnection(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_LinearStorageConnection
LinearStorageConnection_swigregister = _cmf_core.LinearStorageConnection_swigregister
LinearStorageConnection_swigregister(LinearStorageConnection)
class PowerLawConnection(flux_connection):
- """Proxy of C++ cmf::water::PowerLawConnection class."""
+ """
+
+
+ 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`.
+
+ C++ includes: simple_connections.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -2636,14 +4649,79 @@ class PowerLawConnection(flux_connection):
V0 = _swig_property(_cmf_core.PowerLawConnection_V0_get, _cmf_core.PowerLawConnection_V0_set)
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"""
+ """
+ __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 kinematic wave connection.
+
+
+
+ .. math::
+
+ q(V) = \\frac Q_0 {\\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
+
+ 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)
+ """
_cmf_core.PowerLawConnection_swiginit(self, _cmf_core.new_PowerLawConnection(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_PowerLawConnection
PowerLawConnection_swigregister = _cmf_core.PowerLawConnection_swigregister
PowerLawConnection_swigregister(PowerLawConnection)
class bidirectional_kinematic_exchange(flux_connection):
- """Proxy of C++ cmf::water::bidirectional_kinematic_exchange class."""
+ """
+
+
+ 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!
+
+ .. 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -2655,14 +4733,74 @@ class bidirectional_kinematic_exchange(flux_connection):
beta_spill = _swig_property(_cmf_core.bidirectional_kinematic_exchange_beta_spill_get, _cmf_core.bidirectional_kinematic_exchange_beta_spill_set)
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"""
+ """
+ __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
+ """
_cmf_core.bidirectional_kinematic_exchange_swiginit(self, _cmf_core.new_bidirectional_kinematic_exchange(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_bidirectional_kinematic_exchange
bidirectional_kinematic_exchange_swigregister = _cmf_core.bidirectional_kinematic_exchange_swigregister
bidirectional_kinematic_exchange_swigregister(bidirectional_kinematic_exchange)
class constraint_kinematic_wave(flux_connection):
- """Proxy of C++ cmf::water::constraint_kinematic_wave class."""
+ """
+
+
+ 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.
+
+
+
+ .. 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -2674,14 +4812,72 @@ class constraint_kinematic_wave(flux_connection):
gamma = _swig_property(_cmf_core.constraint_kinematic_wave_gamma_get, _cmf_core.constraint_kinematic_wave_gamma_set)
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"""
+ """
+ __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
+ """
_cmf_core.constraint_kinematic_wave_swiginit(self, _cmf_core.new_constraint_kinematic_wave(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_constraint_kinematic_wave
constraint_kinematic_wave_swigregister = _cmf_core.constraint_kinematic_wave_swigregister
constraint_kinematic_wave_swigregister(constraint_kinematic_wave)
class TechnicalFlux(flux_connection):
- """Proxy of C++ cmf::water::TechnicalFlux class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -2690,14 +4886,63 @@ class TechnicalFlux(flux_connection):
FluxDecreaseTime = _swig_property(_cmf_core.TechnicalFlux_FluxDecreaseTime_get, _cmf_core.TechnicalFlux_FluxDecreaseTime_set)
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"""
+ """
+ __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)
+ """
_cmf_core.TechnicalFlux_swiginit(self, _cmf_core.new_TechnicalFlux(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_TechnicalFlux
TechnicalFlux_swigregister = _cmf_core.TechnicalFlux_swigregister
TechnicalFlux_swigregister(TechnicalFlux)
class generic_gradient_connection(flux_connection):
- """Proxy of C++ cmf::water::generic_gradient_connection class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -2706,14 +4951,57 @@ class generic_gradient_connection(flux_connection):
d = _swig_property(_cmf_core.generic_gradient_connection_d_get, _cmf_core.generic_gradient_connection_d_set)
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"""
+ """
+ __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
+ """
_cmf_core.generic_gradient_connection_swiginit(self, _cmf_core.new_generic_gradient_connection(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_generic_gradient_connection
generic_gradient_connection_swigregister = _cmf_core.generic_gradient_connection_swigregister
generic_gradient_connection_swigregister(generic_gradient_connection)
class statecontrol_connection(flux_connection):
- """Proxy of C++ cmf::water::statecontrol_connection class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -2721,20 +5009,61 @@ class statecontrol_connection(flux_connection):
target_state = _swig_property(_cmf_core.statecontrol_connection_target_state_get, _cmf_core.statecontrol_connection_target_state_set)
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"""
+ """
+ __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`)
+ """
_cmf_core.statecontrol_connection_swiginit(self, _cmf_core.new_statecontrol_connection(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_statecontrol_connection
statecontrol_connection_swigregister = _cmf_core.statecontrol_connection_swigregister
statecontrol_connection_swigregister(statecontrol_connection)
class node_list(StateVariableOwner):
- """Proxy of C++ cmf::water::node_list class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def size(self, *args, **kwargs):
- """size(node_list self) -> size_t"""
+ """
+ size(node_list self) -> size_t
+
+ size_t size()
+ const
+
+ The number of nodes.
+ """
return _cmf_core.node_list_size(self, *args, **kwargs)
@@ -2742,6 +5071,10 @@ 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.
"""
_cmf_core.node_list_swiginit(self, _cmf_core.new_node_list(*args))
@@ -2756,62 +5089,174 @@ def __add__(self, *args, **kwargs):
def __get(self, *args, **kwargs):
- """__get(node_list self, ptrdiff_t index) -> cmf::water::flux_node::ptr"""
+ """
+ __get(node_list self, ptrdiff_t index) -> cmf::water::flux_node::ptr
+
+ flux_node::ptr
+ get(ptrdiff_t index) const
+
+ Returns a node in the node_list.
+ """
return _cmf_core.node_list___get(self, *args, **kwargs)
def __getslice(self, *args, **kwargs):
- """__getslice(node_list self, ptrdiff_t begin, ptrdiff_t end, ptrdiff_t step=1) -> node_list"""
+ """
+ __getslice(node_list self, ptrdiff_t begin, ptrdiff_t end, ptrdiff_t step=1) -> node_list
+
+ node_list
+ getslice(ptrdiff_t begin, ptrdiff_t end, ptrdiff_t step=1) const
+
+ Returns a slice of the node_list.
+ """
return _cmf_core.node_list___getslice(self, *args, **kwargs)
def append(self, *args, **kwargs):
- """append(node_list self, cmf::water::flux_node::ptr node)"""
+ """
+ append(node_list self, cmf::water::flux_node::ptr node)
+
+ void
+ append(flux_node::ptr node)
+
+ Adds a flux node to the list.
+ """
return _cmf_core.node_list_append(self, *args, **kwargs)
def remove(self, *args, **kwargs):
- """remove(node_list self, cmf::water::flux_node::ptr node) -> bool"""
+ """
+ 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.
+ """
return _cmf_core.node_list_remove(self, *args, **kwargs)
def global_water_balance(self, *args, **kwargs):
- """global_water_balance(node_list self, Time t) -> real"""
+ """
+ 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:
+ """
return _cmf_core.node_list_global_water_balance(self, *args, **kwargs)
def water_balance(self, *args, **kwargs):
- """water_balance(node_list self, Time t) -> cmf::math::num_array"""
+ """
+ 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:
+ """
return _cmf_core.node_list_water_balance(self, *args, **kwargs)
def conc(self, *args, **kwargs):
- """conc(node_list self, Time t, solute _Solute) -> cmf::math::num_array"""
+ """
+ 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.
+ """
return _cmf_core.node_list_conc(self, *args, **kwargs)
def set_solute_source(self, *args, **kwargs):
- """set_solute_source(node_list self, solute _Solute, cmf::math::num_array source_fluxes) -> ptrdiff_t"""
+ """
+ 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)
+ """
return _cmf_core.node_list_set_solute_source(self, *args, **kwargs)
def get_fluxes_to(self, *args, **kwargs):
- """get_fluxes_to(node_list self, node_list targets, Time t) -> cmf::math::num_array"""
+ """
+ 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:
+ """
return _cmf_core.node_list_get_fluxes_to(self, *args, **kwargs)
def get_fluxes3d_to(self, *args, **kwargs):
- """get_fluxes3d_to(node_list self, node_list targets, Time t) -> point_vector"""
+ """
+ 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.
+ """
return _cmf_core.node_list_get_fluxes3d_to(self, *args, **kwargs)
def get_fluxes3d(self, *args, **kwargs):
- """get_fluxes3d(node_list self, Time t) -> point_vector"""
+ """
+ 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.
+ """
return _cmf_core.node_list_get_fluxes3d(self, *args, **kwargs)
def get_positions(self, *args, **kwargs):
- """get_positions(node_list self) -> point_vector"""
+ """
+ get_positions(node_list self) -> point_vector
+
+ cmf::geometry::point_vector get_positions() const
+
+ Returns the positions of the nodes.
+ """
return _cmf_core.node_list_get_positions(self, *args, **kwargs)
potentials = _swig_property(_cmf_core.node_list_potentials_get, _cmf_core.node_list_potentials_set)
@@ -2865,28 +5310,77 @@ def from_sequence(sequence):
node_list_swigregister(node_list)
class NeumannBoundary_list(object):
- """Proxy of C++ cmf::water::NeumannBoundary_list class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def get(self, *args, **kwargs):
- """get(NeumannBoundary_list self, ptrdiff_t index) -> cmf::water::NeumannBoundary::ptr"""
+ """
+ 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 []
+ """
return _cmf_core.NeumannBoundary_list_get(self, *args, **kwargs)
def get_fluxes(self, *args, **kwargs):
- """get_fluxes(NeumannBoundary_list self, Time t) -> cmf::math::num_array"""
+ """
+ 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
+
+ """
return _cmf_core.NeumannBoundary_list_get_fluxes(self, *args, **kwargs)
def append(self, *args, **kwargs):
- """append(NeumannBoundary_list self, cmf::water::NeumannBoundary::ptr nbc)"""
+ """
+ append(NeumannBoundary_list self, cmf::water::NeumannBoundary::ptr nbc)
+
+ void
+ append(NeumannBoundary::ptr nbc)
+
+ Appends a neumann boundary to this list.
+ """
return _cmf_core.NeumannBoundary_list_append(self, *args, **kwargs)
def size(self, *args, **kwargs):
- """size(NeumannBoundary_list self) -> size_t"""
+ """
+ size(NeumannBoundary_list self) -> size_t
+
+ size_t
+ size() const
+
+ returns the number of stored boundary conditions
+ """
return _cmf_core.NeumannBoundary_list_size(self, *args, **kwargs)
@@ -2895,21 +5389,61 @@ 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 ©)
"""
_cmf_core.NeumannBoundary_list_swiginit(self, _cmf_core.new_NeumannBoundary_list(*args))
def to_node_list(self, *args, **kwargs):
- """to_node_list(NeumannBoundary_list self) -> node_list"""
+ """
+ to_node_list(NeumannBoundary_list self) -> node_list
+
+ cmf::water::node_list to_node_list() const
+
+ Creates a node_list from this NeumannBoundary_list.
+ """
return _cmf_core.NeumannBoundary_list_to_node_list(self, *args, **kwargs)
def global_water_balance(self, *args, **kwargs):
- """global_water_balance(NeumannBoundary_list self, Time t) -> real"""
+ """
+ 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:
+ """
return _cmf_core.NeumannBoundary_list_global_water_balance(self, *args, **kwargs)
def water_balance(self, *args, **kwargs):
- """water_balance(NeumannBoundary_list self, Time t) -> cmf::math::num_array"""
+ """
+ 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:
+ """
return _cmf_core.NeumannBoundary_list_water_balance(self, *args, **kwargs)
fluxes = _swig_property(_cmf_core.NeumannBoundary_list_fluxes_get, _cmf_core.NeumannBoundary_list_fluxes_set)
@@ -2944,7 +5478,33 @@ def from_sequence(sequence):
NeumannBoundary_list_swigregister(NeumannBoundary_list)
class SystemBridge(flux_node):
- """Proxy of C++ cmf::water::SystemBridge class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -2953,22 +5513,44 @@ def __init__(self, *args, **kwargs):
__repr__ = _swig_repr
def get_upper_node(self, *args, **kwargs):
- """get_upper_node(SystemBridge self) -> cmf::water::flux_node::ptr"""
+ """
+ get_upper_node(SystemBridge self) -> cmf::water::flux_node::ptr
+
+ flux_node::ptr get_upper_node() const
+
+ Returns the upper node.
+ """
return _cmf_core.SystemBridge_get_upper_node(self, *args, **kwargs)
def get_lower_node(self, *args, **kwargs):
- """get_lower_node(SystemBridge self) -> cmf::water::flux_node::ptr"""
+ """
+ get_lower_node(SystemBridge self) -> cmf::water::flux_node::ptr
+
+ flux_node::ptr get_lower_node() const
+
+ Returns the lower node.
+ """
return _cmf_core.SystemBridge_get_lower_node(self, *args, **kwargs)
def get_down_flux(self, *args, **kwargs):
- """get_down_flux(SystemBridge self) -> double"""
+ """
+ get_down_flux(SystemBridge self) -> double
+
+ double get_down_flux() const
+
+ Returns the currently integrated flux to the lower node.
+ """
return _cmf_core.SystemBridge_get_down_flux(self, *args, **kwargs)
def down_flux_integrator(self, *args, **kwargs):
- """down_flux_integrator(SystemBridge self) -> cmf::water::flux_integrator::ptr"""
+ """
+ down_flux_integrator(SystemBridge self) -> cmf::water::flux_integrator::ptr
+
+ flux_integrator::ptr down_flux_integrator() const
+ """
return _cmf_core.SystemBridge_down_flux_integrator(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_SystemBridge
@@ -2980,7 +5562,14 @@ def down_flux_integrator(self, *args, **kwargs):
SystemBridge_swigregister(SystemBridge)
class SystemBridgeConnection(flux_connection):
- """Proxy of C++ cmf::water::SystemBridgeConnection class."""
+ """
+
+
+ Connects a system bridge with its lower node. Is created automatically
+ when creating a SystemBridge.
+
+ C++ includes: system_bridge.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -2993,7 +5582,30 @@ def __init__(self, *args, **kwargs):
def system_bridge(*args, **kwargs):
- """system_bridge(project p, cmf::water::flux_node::ptr upper, cmf::water::flux_node::ptr lower) -> cmf::water::SystemBridge::ptr"""
+ """
+ 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.
+ """
return _cmf_core.system_bridge(*args, **kwargs)
def integrate_over(item,solver=None):
@@ -3022,26 +5634,189 @@ def integrate_over(item,solver=None):
def vapour_pressure(*args, **kwargs):
- """vapour_pressure(double T) -> double"""
+ """
+ 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
+ """
return _cmf_core.vapour_pressure(*args, **kwargs)
def vpd_from_rH(*args, **kwargs):
- """vpd_from_rH(double T, double rH) -> double"""
+ """
+ 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)
+
+ """
return _cmf_core.vpd_from_rH(*args, **kwargs)
def rH_from_vpd(*args, **kwargs):
- """rH_from_vpd(double T, double vpd) -> double"""
+ """
+ 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)
+
+ """
return _cmf_core.rH_from_vpd(*args, **kwargs)
def global_radiation(*args, **kwargs):
- """global_radiation(Time t, double height, double sunshine_fraction, double longitude=8, double latitude=51, double time_zone=1, bool daily=False) -> double"""
+ """
+ global_radiation(Time t, double height, double sunshine_fraction, double longitude=8, double latitude=51, double time_zone=1, bool daily=False) -> 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 \\\\
+
+
+ """
return _cmf_core.global_radiation(*args, **kwargs)
def Pressure(*args, **kwargs):
- """Pressure(double height) -> double"""
+ """
+ Pressure(double height) -> double
+
+ double
+ cmf::atmosphere::Pressure(double height)
+
+ Returns the average air pressure for a height (m a.s.l.)
+ """
return _cmf_core.Pressure(*args, **kwargs)
class Weather(object):
- """Proxy of C++ cmf::atmosphere::Weather class."""
+ """
+
+
+ A structure holding meteorological information, excluding
+ precipitation
+
+ C++ includes: Weather.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -3058,16 +5833,85 @@ class Weather(object):
instrument_height = _swig_property(_cmf_core.Weather_instrument_height_get, _cmf_core.Weather_instrument_height_set)
def Rn(self, *args, **kwargs):
- """Rn(Weather self, double albedo, bool daily=False) -> double"""
+ """
+ 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
+ """
return _cmf_core.Weather_Rn(self, *args, **kwargs)
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 daylength=12) -> Weather"""
+ """
+ __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 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
+ """
_cmf_core.Weather_swiginit(self, _cmf_core.new_Weather(*args, **kwargs))
def to_string(self, *args, **kwargs):
- """to_string(Weather self) -> std::string"""
+ """
+ to_string(Weather self) -> std::string
+
+ std::string to_string() const
+
+ Returns a string representation.
+ """
return _cmf_core.Weather_to_string(self, *args, **kwargs)
@@ -3127,7 +5971,14 @@ def Weather_get_snow_threshold(*args):
return _cmf_core.Weather_get_snow_threshold(*args)
class Meteorology(object):
- """Proxy of C++ cmf::atmosphere::Meteorology class."""
+ """
+
+
+ An abstract class, for objects generating Weather records at a
+ specific time.
+
+ C++ includes: meteorology.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -3141,17 +5992,40 @@ def __call__(self, *args, **kwargs):
def get_weather(self, *args, **kwargs):
- """get_weather(Meteorology self, Time t) -> Weather"""
+ """
+ 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.
+ """
return _cmf_core.Meteorology_get_weather(self, *args, **kwargs)
def copy(self, *args, **kwargs):
- """copy(Meteorology self) -> Meteorology"""
+ """
+ copy(Meteorology self) -> Meteorology
+
+ virtual
+ Meteorology* copy() const =0
+
+ Returns a copy of the meteorology object. Pure virtual function, needs
+ to be implemented.
+ """
return _cmf_core.Meteorology_copy(self, *args, **kwargs)
def get_instrument_height(self, *args, **kwargs):
- """get_instrument_height(Meteorology self) -> real"""
+ """
+ get_instrument_height(Meteorology self) -> real
+
+ virtual real
+ get_instrument_height() const =0
+
+ Returns the height of the instruments above canopy.
+ """
return _cmf_core.Meteorology_get_instrument_height(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_Meteorology
@@ -3163,7 +6037,15 @@ def get_instrument_height(self, *args, **kwargs):
Meteorology_swigregister(Meteorology)
class ConstantMeteorology(Meteorology):
- """Proxy of C++ cmf::atmosphere::ConstantMeteorology class."""
+ """
+
+
+ A primitive implementation of the Meteorology interface.
+
+ Holds a Weather record and returns it for any date
+
+ C++ includes: meteorology.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -3174,11 +6056,22 @@ 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.
"""
_cmf_core.ConstantMeteorology_swiginit(self, _cmf_core.new_ConstantMeteorology(*args))
def copy(self, *args, **kwargs):
- """copy(ConstantMeteorology self) -> ConstantMeteorology"""
+ """
+ copy(ConstantMeteorology self) -> ConstantMeteorology
+
+ ConstantMeteorology* copy() const
+
+ Creates a new instannce of the ConstantMeteorology with the same
+ weather.
+ """
return _cmf_core.ConstantMeteorology_copy(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_ConstantMeteorology
@@ -3187,7 +6080,31 @@ def copy(self, *args, **kwargs):
ConstantMeteorology_swigregister(ConstantMeteorology)
class MeteoStation(object):
- """Proxy of C++ cmf::atmosphere::MeteoStation class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -3200,28 +6117,76 @@ class MeteoStation(object):
Name = _swig_property(_cmf_core.MeteoStation_Name_get, _cmf_core.MeteoStation_Name_set)
def get_position(self, *args, **kwargs):
- """get_position(MeteoStation self) -> point"""
+ """
+ get_position(MeteoStation self) -> point
+
+ cmf::geometry::point get_position() const
+ """
return _cmf_core.MeteoStation_get_position(self, *args, **kwargs)
daily = _swig_property(_cmf_core.MeteoStation_daily_get, _cmf_core.MeteoStation_daily_set)
InstrumentHeight = _swig_property(_cmf_core.MeteoStation_InstrumentHeight_get, _cmf_core.MeteoStation_InstrumentHeight_set)
def __init__(self, *args, **kwargs):
- """__init__(cmf::atmosphere::MeteoStation self, MeteoStation other) -> MeteoStation"""
+ """
+ __init__(cmf::atmosphere::MeteoStation self, MeteoStation other) -> MeteoStation
+
+ MeteoStation(const cmf::atmosphere::MeteoStation &other)
+
+ Copy c'tor.
+ """
_cmf_core.MeteoStation_swiginit(self, _cmf_core.new_MeteoStation(*args, **kwargs))
def get_data(self, *args, **kwargs):
- """get_data(MeteoStation self, Time t, double height) -> Weather"""
+ """
+ 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.
+ """
return _cmf_core.MeteoStation_get_data(self, *args, **kwargs)
def use_for_cell(self, *args, **kwargs):
- """use_for_cell(MeteoStation self, Cell c)"""
+ """
+ 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.
+ """
return _cmf_core.MeteoStation_use_for_cell(self, *args, **kwargs)
def SetSunshineFraction(self, *args, **kwargs):
- """SetSunshineFraction(MeteoStation self, timeseries sunshine_duration)"""
+ """
+ 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
+
+
+ """
return _cmf_core.MeteoStation_SetSunshineFraction(self, *args, **kwargs)
T = _swig_property(_cmf_core.MeteoStation_T_get, _cmf_core.MeteoStation_T_set)
@@ -3260,18 +6225,39 @@ def __repr__(self):
MeteoStation_swigregister(MeteoStation)
class MeteoStationReference(Meteorology):
- """Proxy of C++ cmf::atmosphere::MeteoStationReference class."""
+ """
+
+
+ A reference to a meteorological station.
+
+ Returns the weather at a given time for its place using
+ MeteoStation::T_lapse
+
+ C++ includes: meteorology.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def get_station(self, *args, **kwargs):
- """get_station(MeteoStationReference self) -> cmf::atmosphere::MeteoStation::ptr"""
+ """
+ get_station(MeteoStationReference self) -> cmf::atmosphere::MeteoStation::ptr
+
+ MeteoStation::ptr get_station() const
+
+ Returns the station referenced.
+ """
return _cmf_core.MeteoStationReference_get_station(self, *args, **kwargs)
def get_position(self, *args, **kwargs):
- """get_position(MeteoStationReference self) -> point"""
+ """
+ get_position(MeteoStationReference self) -> point
+
+ cmf::geometry::point get_position() const
+
+ Returns the position of the reference.
+ """
return _cmf_core.MeteoStationReference_get_position(self, *args, **kwargs)
@@ -3279,11 +6265,20 @@ 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 ©)
"""
_cmf_core.MeteoStationReference_swiginit(self, _cmf_core.new_MeteoStationReference(*args))
def copy(self, *args, **kwargs):
- """copy(MeteoStationReference self) -> MeteoStationReference"""
+ """
+ copy(MeteoStationReference self) -> MeteoStationReference
+
+ MeteoStationReference* copy() const
+
+ Returns a copy of the meteorology object. Pure virtual function, needs
+ to be implemented.
+ """
return _cmf_core.MeteoStationReference_copy(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_MeteoStationReference
@@ -3294,13 +6289,28 @@ def copy(self, *args, **kwargs):
MeteoStationReference_swigregister(MeteoStationReference)
class MeteoStationList(object):
- """Proxy of C++ cmf::atmosphere::MeteoStationList class."""
+ """
+
+
+ A list of meteorological stations.
+
+ Can find the nearest station for a position and calculate the
+ temperature lapse
+
+ C++ includes: meteorology.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __len__(self, *args, **kwargs):
- """__len__(MeteoStationList self) -> size_t"""
+ """
+ __len__(MeteoStationList self) -> size_t
+
+ size_t size() const
+
+ Returns the number of stations.
+ """
return _cmf_core.MeteoStationList___len__(self, *args, **kwargs)
@@ -3312,18 +6322,66 @@ def __getitem__(self, *args):
return _cmf_core.MeteoStationList___getitem__(self, *args)
- def calculate_Temp_lapse(self, *args, **kwargs):
- """calculate_Temp_lapse(MeteoStationList self, Time begin, Time step, Time end) -> double"""
- return _cmf_core.MeteoStationList_calculate_Temp_lapse(self, *args, **kwargs)
+ 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.
+ """
+ return _cmf_core.MeteoStationList_calculate_Temp_lapse(self, *args, **kwargs)
+
+
+ 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)
- 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"""
+ timestep: Frequency of climatic data (may be changed for each time
+ series later)
+ """
return _cmf_core.MeteoStationList_add_station(self, *args, **kwargs)
def remove_station(self, *args, **kwargs):
- """remove_station(MeteoStationList self, ptrdiff_t index) -> ptrdiff_t"""
+ """
+ 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.
+ """
return _cmf_core.MeteoStationList_remove_station(self, *args, **kwargs)
@@ -3331,11 +6389,35 @@ def __init__(self, *args):
"""
__init__(cmf::atmosphere::MeteoStationList self) -> MeteoStationList
__init__(cmf::atmosphere::MeteoStationList self, MeteoStationList copy) -> MeteoStationList
+
+ MeteoStationList(const MeteoStationList ©)
+
+ Copy c'tor.
"""
_cmf_core.MeteoStationList_swiginit(self, _cmf_core.new_MeteoStationList(*args))
def reference_to_nearest(self, *args, **kwargs):
- """reference_to_nearest(MeteoStationList self, point position, double z_weight=0) -> MeteoStationReference"""
+ """
+ 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`
+ """
return _cmf_core.MeteoStationList_reference_to_nearest(self, *args, **kwargs)
@@ -3356,7 +6438,16 @@ def __repr__(self):
MeteoStationList_swigregister(MeteoStationList)
class IDW_Meteorology(Meteorology):
- """Proxy of C++ cmf::atmosphere::IDW_Meteorology class."""
+ """
+
+
+ Regionalizes meteorological measurements using a simple inverse
+ distance weighted (IDW) method.
+
+ See: IDW
+
+ C++ includes: meteorology.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -3365,11 +6456,22 @@ 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.
"""
_cmf_core.IDW_Meteorology_swiginit(self, _cmf_core.new_IDW_Meteorology(*args))
def copy(self, *args, **kwargs):
- """copy(IDW_Meteorology self) -> IDW_Meteorology"""
+ """
+ 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.
+ """
return _cmf_core.IDW_Meteorology_copy(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_IDW_Meteorology
@@ -3378,7 +6480,14 @@ def copy(self, *args, **kwargs):
IDW_Meteorology_swigregister(IDW_Meteorology)
class aerodynamic_resistance(object):
- """Proxy of C++ cmf::atmosphere::aerodynamic_resistance class."""
+ """
+
+
+ Abstract class. Child classes can be used to calculate aerodynamic
+ resistances against turbulent heat fluxes.
+
+ C++ includes: meteorology.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -3387,7 +6496,15 @@ def __init__(self, *args, **kwargs):
__repr__ = _swig_repr
def get_aerodynamic_resistance(self, *args, **kwargs):
- """get_aerodynamic_resistance(aerodynamic_resistance self, double & r_ag, double & r_ac, Time t)"""
+ """
+ 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)
+ """
return _cmf_core.aerodynamic_resistance_get_aerodynamic_resistance(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_aerodynamic_resistance
@@ -3396,7 +6513,13 @@ def get_aerodynamic_resistance(self, *args, **kwargs):
aerodynamic_resistance_swigregister(aerodynamic_resistance)
class RainSource(flux_node):
- """Proxy of C++ cmf::atmosphere::RainSource class."""
+ """
+
+
+ An abstract class for different types of rainfall sources.
+
+ C++ includes: precipitation.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -3410,7 +6533,13 @@ def __call__(self, *args, **kwargs):
def get_intensity(self, *args, **kwargs):
- """get_intensity(RainSource self, Time t) -> real"""
+ """
+ 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.
+ """
return _cmf_core.RainSource_get_intensity(self, *args, **kwargs)
@@ -3424,18 +6553,51 @@ def __repr__(self):
RainSource_swigregister(RainSource)
class ConstantRainSource(RainSource):
- """Proxy of C++ cmf::atmosphere::ConstantRainSource class."""
+ """
+
+
+ A simple implementation of RainSource.
+
+ Returns intensity for any time step.
+
+ C++ includes: precipitation.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
intensity = _swig_property(_cmf_core.ConstantRainSource_intensity_get, _cmf_core.ConstantRainSource_intensity_set)
def __init__(self, *args, **kwargs):
- """__init__(cmf::atmosphere::ConstantRainSource self, project _project, point location, real _intensity) -> ConstantRainSource"""
+ """
+ __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
+ """
_cmf_core.ConstantRainSource_swiginit(self, _cmf_core.new_ConstantRainSource(*args, **kwargs))
def set_conc(self, *args, **kwargs):
- """set_conc(ConstantRainSource self, solute Solute, real value)"""
+ """
+ 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.
+ """
return _cmf_core.ConstantRainSource_set_conc(self, *args, **kwargs)
@@ -3448,7 +6610,16 @@ def __repr__(self):
ConstantRainSource_swigregister(ConstantRainSource)
class TimeseriesRainSource(RainSource):
- """Proxy of C++ cmf::atmosphere::TimeseriesRainSource class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -3462,7 +6633,17 @@ def __init__(self, *args, **kwargs):
TimeseriesRainSource_swigregister(TimeseriesRainSource)
class RainfallStation(object):
- """Proxy of C++ cmf::atmosphere::RainfallStation class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
Location = _swig_property(_cmf_core.RainfallStation_Location_get, _cmf_core.RainfallStation_Location_set)
@@ -3477,18 +6658,36 @@ def create(*args, **kwargs):
data = _swig_property(_cmf_core.RainfallStation_data_get, _cmf_core.RainfallStation_data_set)
def __repr__(self, *args, **kwargs):
- """__repr__(RainfallStation self) -> std::string"""
+ """
+ __repr__(RainfallStation self) -> std::string
+
+ std::string tostring() const
+
+ Returns the name and the mean yearly rainfall.
+ """
return _cmf_core.RainfallStation___repr__(self, *args, **kwargs)
concentration = _swig_property(_cmf_core.RainfallStation_concentration_get, _cmf_core.RainfallStation_concentration_set)
def use_for_cell(self, *args, **kwargs):
- """use_for_cell(RainfallStation self, Cell c)"""
+ """
+ use_for_cell(RainfallStation self, Cell c)
+
+ void use_for_cell(cmf::upslope::Cell &c)
+
+ Connects a cell with this rainfall station.
+ """
return _cmf_core.RainfallStation_use_for_cell(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
- """__init__(cmf::atmosphere::RainfallStation self, RainfallStation copy) -> RainfallStation"""
+ """
+ __init__(cmf::atmosphere::RainfallStation self, RainfallStation copy) -> RainfallStation
+
+ RainfallStation(const RainfallStation ©)
+
+ copy c'tor
+ """
_cmf_core.RainfallStation_swiginit(self, _cmf_core.new_RainfallStation(*args, **kwargs))
def __call__(self, *args, **kwargs):
@@ -3507,13 +6706,25 @@ def RainfallStation_create(*args, **kwargs):
return _cmf_core.RainfallStation_create(*args, **kwargs)
class RainfallStationList(object):
- """Proxy of C++ cmf::atmosphere::RainfallStationList class."""
+ """
+
+
+ A list of rainfall stations.
+
+ C++ includes: precipitation.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __len__(self, *args, **kwargs):
- """__len__(RainfallStationList self) -> size_t"""
+ """
+ __len__(RainfallStationList self) -> size_t
+
+ size_t size() const
+
+ Returns the number of rainfall stations.
+ """
return _cmf_core.RainfallStationList___len__(self, *args, **kwargs)
@@ -3526,12 +6737,37 @@ def __getitem__(self, *args):
def add(self, *args, **kwargs):
- """add(RainfallStationList self, std::string Name, timeseries Data, point Position) -> cmf::atmosphere::RainfallStation::ptr"""
+ """
+ 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
+ """
return _cmf_core.RainfallStationList_add(self, *args, **kwargs)
def remove(self, *args, **kwargs):
- """remove(RainfallStationList self, ptrdiff_t index)"""
+ """
+ remove(RainfallStationList self, ptrdiff_t index)
+
+ void remove(ptrdiff_t index)
+
+ Removes the station at index from this list.
+ """
return _cmf_core.RainfallStationList_remove(self, *args, **kwargs)
@@ -3554,7 +6790,14 @@ def __init__(self, *args, **kwargs):
RainfallStationList_swigregister(RainfallStationList)
class RainfallStationReference(RainSource):
- """Proxy of C++ cmf::atmosphere::RainfallStationReference class."""
+ """
+
+
+ References a single RainfallStation to provide rainfall intensity
+ data.
+
+ C++ includes: precipitation.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -3590,7 +6833,16 @@ def RainfallStationReference_from_station_id(*args, **kwargs):
return _cmf_core.RainfallStationReference_from_station_id(*args, **kwargs)
class IDWRainfall(RainSource):
- """Proxy of C++ cmf::atmosphere::IDWRainfall class."""
+ """
+
+
+ A RainSource using a spatially interpolated rainfall intensity from
+ all stations.
+
+ Interpolation method is inverse distance weighted (IDW)
+
+ C++ includes: precipitation.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -3616,7 +6868,14 @@ def IDWRainfall_create(*args, **kwargs):
return _cmf_core.IDWRainfall_create(*args, **kwargs)
class Vegetation(object):
- """Proxy of C++ cmf::upslope::vegetation::Vegetation class."""
+ """
+
+
+ Holds the vegetation parameters for the calculation of ET and
+ fractionating rainfall. Not every ET method uses all parameters.
+
+ C++ includes: StructVegetation.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
LAI = _swig_property(_cmf_core.Vegetation_LAI_get, _cmf_core.Vegetation_LAI_set)
@@ -3633,7 +6892,14 @@ class Vegetation(object):
LeafWidth = _swig_property(_cmf_core.Vegetation_LeafWidth_get, _cmf_core.Vegetation_LeafWidth_set)
def RootLength(self, *args, **kwargs):
- """RootLength(Vegetation self) -> double"""
+ """
+ RootLength(Vegetation self) -> double
+
+ double RootLength()
+ const
+
+ Returns the average root length in m/m2.
+ """
return _cmf_core.Vegetation_RootLength(self, *args, **kwargs)
@@ -3641,12 +6907,23 @@ 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
"""
return _cmf_core.Vegetation_RootFraction(self, *args)
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"""
+ """
+ __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)
+
+ """
_cmf_core.Vegetation_swiginit(self, _cmf_core.new_Vegetation(*args, **kwargs))
def __repr__(self, *args, **kwargs):
@@ -3661,13 +6938,24 @@ def __repr__(self, *args, **kwargs):
Vegetation_swigregister(Vegetation)
class CellConnector(object):
- """Proxy of C++ cmf::upslope::CellConnector class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::CellConnector self, cmf::upslope::connectorfunction connector) -> CellConnector"""
+ """
+ __init__(cmf::upslope::CellConnector self, cmf::upslope::connectorfunction connector) -> CellConnector
+
+ CellConnector(connectorfunction connector)
+ """
_cmf_core.CellConnector_swiginit(self, _cmf_core.new_CellConnector(*args, **kwargs))
def __call__(self, *args, **kwargs):
@@ -3676,7 +6964,13 @@ def __call__(self, *args, **kwargs):
def connect(self, *args, **kwargs):
- """connect(CellConnector self, Cell cell1, Cell cell2, ptrdiff_t start_at_layer=0)"""
+ """
+ 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
+ """
return _cmf_core.CellConnector_connect(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_CellConnector
@@ -3686,7 +6980,17 @@ def connect(self, *args, **kwargs):
CellConnector_swigregister(CellConnector)
class Cell(StateVariableOwner):
- """Proxy of C++ cmf::upslope::Cell class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -3695,78 +6999,184 @@ class Cell(StateVariableOwner):
z = _swig_property(_cmf_core.Cell_z_get, _cmf_core.Cell_z_set)
def get_position(self, *args, **kwargs):
- """get_position(Cell self) -> point"""
+ """
+ get_position(Cell self) -> point
+
+ cmf::geometry::point get_position() const
+
+ Returns the location of the cell.
+ """
return _cmf_core.Cell_get_position(self, *args, **kwargs)
def m3_to_mm(self, *args, **kwargs):
- """m3_to_mm(Cell self, double volume) -> double"""
+ """
+ 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.
+ """
return _cmf_core.Cell_m3_to_mm(self, *args, **kwargs)
def mm_to_m3(self, *args, **kwargs):
- """mm_to_m3(Cell self, double depth) -> double"""
+ """
+ mm_to_m3(Cell self, double depth) -> double
+
+ double
+ mm_to_m3(double depth) const
+ """
return _cmf_core.Cell_mm_to_m3(self, *args, **kwargs)
def InvalidateSatDepth(self, *args, **kwargs):
- """InvalidateSatDepth(Cell self)"""
+ """
+ InvalidateSatDepth(Cell self)
+
+ void
+ InvalidateSatDepth() const
+
+ Marks the saturated depth as unvalid. This is done automatically, when
+ the state of a layer changes.
+ """
return _cmf_core.Cell_InvalidateSatDepth(self, *args, **kwargs)
vegetation = _swig_property(_cmf_core.Cell_vegetation_get, _cmf_core.Cell_vegetation_set)
def set_aerodynamic_resistance(self, *args, **kwargs):
- """set_aerodynamic_resistance(Cell self, cmf::atmosphere::aerodynamic_resistance::ptr Ra)"""
+ """
+ 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.
+ """
return _cmf_core.Cell_set_aerodynamic_resistance(self, *args, **kwargs)
def set_weather(self, *args, **kwargs):
- """set_weather(Cell self, Weather weather)"""
+ """
+ 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.
+ """
return _cmf_core.Cell_set_weather(self, *args, **kwargs)
def set_rainfall(self, *args, **kwargs):
- """set_rainfall(Cell self, double rainfall)"""
+ """
+ set_rainfall(Cell self, double rainfall)
+
+ void
+ set_rainfall(double rainfall)
+
+ Exchanges a timeseries of rainfall with a constant flux.
+ """
return _cmf_core.Cell_set_rainfall(self, *args, **kwargs)
def get_rainfall(self, *args, **kwargs):
- """get_rainfall(Cell self, Time t) -> double"""
+ """
+ get_rainfall(Cell self, Time t) -> double
+
+ double
+ get_rainfall(cmf::math::Time t) const
+
+ Returns the current rainfall flux in m3/day.
+ """
return _cmf_core.Cell_get_rainfall(self, *args, **kwargs)
def __set_rain_source(self, *args, **kwargs):
- """__set_rain_source(Cell self, cmf::atmosphere::RainSource::ptr new_source)"""
+ """
+ __set_rain_source(Cell self, cmf::atmosphere::RainSource::ptr new_source)
+
+ void
+ set_rain_source(cmf::atmosphere::RainSource::ptr new_source)
+
+ Changes the current source of rainfall.
+ """
return _cmf_core.Cell___set_rain_source(self, *args, **kwargs)
def __get_rain_source(self, *args, **kwargs):
- """__get_rain_source(Cell self) -> cmf::atmosphere::RainSource::ptr"""
+ """
+ __get_rain_source(Cell self) -> cmf::atmosphere::RainSource::ptr
+
+ cmf::atmosphere::RainSource::ptr get_rain_source()
+
+ Returns the current source for rainfall.
+ """
return _cmf_core.Cell___get_rain_source(self, *args, **kwargs)
def set_uptakestress(self, *args, **kwargs):
- """set_uptakestress(Cell self, RootUptakeStessFunction stressfunction)"""
+ """
+ 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.
+ """
return _cmf_core.Cell_set_uptakestress(self, *args, **kwargs)
def __get_evaporation(self, *args, **kwargs):
- """__get_evaporation(Cell self) -> cmf::water::flux_node::ptr"""
+ """
+ __get_evaporation(Cell self) -> cmf::water::flux_node::ptr
+
+ cmf::water::flux_node::ptr get_evaporation()
+
+ Returns the end point of all evaporation of this cell (a
+ cmf::water::flux_node)
+ """
return _cmf_core.Cell___get_evaporation(self, *args, **kwargs)
def __get_transpiration(self, *args, **kwargs):
- """__get_transpiration(Cell self) -> cmf::water::flux_node::ptr"""
+ """
+ __get_transpiration(Cell self) -> cmf::water::flux_node::ptr
+
+ cmf::water::flux_node::ptr get_transpiration()
+
+ Returns the end point of all transpiration of this cell (a
+ cmf::water::flux_node)
+ """
return _cmf_core.Cell___get_transpiration(self, *args, **kwargs)
def get_surfacewater(self, *args, **kwargs):
- """get_surfacewater(Cell self) -> cmf::water::flux_node::ptr"""
+ """
+ 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
+ """
return _cmf_core.Cell_get_surfacewater(self, *args, **kwargs)
def surfacewater_as_storage(self, *args, **kwargs):
- """surfacewater_as_storage(Cell self)"""
+ """
+ surfacewater_as_storage(Cell self)
+
+ void surfacewater_as_storage()
+
+ Makes the surfacewater of this cell a cmf::upslope::SurfaceWater
+ storage.
+ """
return _cmf_core.Cell_surfacewater_as_storage(self, *args, **kwargs)
@@ -3774,75 +7184,177 @@ def add_storage(self, *args):
"""
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.
"""
return _cmf_core.Cell_add_storage(self, *args)
def remove_storage(self, *args, **kwargs):
- """remove_storage(Cell self, cmf::water::WaterStorage::ptr storage)"""
+ """
+ remove_storage(Cell self, cmf::water::WaterStorage::ptr storage)
+
+ void
+ remove_storage(cmf::water::WaterStorage::ptr storage)
+ """
return _cmf_core.Cell_remove_storage(self, *args, **kwargs)
def storage_count(self, *args, **kwargs):
- """storage_count(Cell self) -> size_t"""
+ """
+ storage_count(Cell self) -> size_t
+
+ size_t
+ storage_count() const
+ """
return _cmf_core.Cell_storage_count(self, *args, **kwargs)
def get_storage(self, *args, **kwargs):
- """get_storage(Cell self, ptrdiff_t index) -> cmf::water::WaterStorage::ptr"""
+ """
+ get_storage(Cell self, ptrdiff_t index) -> cmf::water::WaterStorage::ptr
+
+ cmf::water::WaterStorage::ptr get_storage(ptrdiff_t index) const
+ """
return _cmf_core.Cell_get_storage(self, *args, **kwargs)
def get_canopy(self, *args, **kwargs):
- """get_canopy(Cell self) -> cmf::water::WaterStorage::ptr"""
+ """
+ get_canopy(Cell self) -> cmf::water::WaterStorage::ptr
+
+ cmf::water::WaterStorage::ptr get_canopy() const
+ """
return _cmf_core.Cell_get_canopy(self, *args, **kwargs)
def get_snow(self, *args, **kwargs):
- """get_snow(Cell self) -> cmf::water::WaterStorage::ptr"""
+ """
+ get_snow(Cell self) -> cmf::water::WaterStorage::ptr
+
+ cmf::water::WaterStorage::ptr get_snow() const
+ """
return _cmf_core.Cell_get_snow(self, *args, **kwargs)
def snow_coverage(self, *args, **kwargs):
- """snow_coverage(Cell self) -> real"""
+ """
+ snow_coverage(Cell self) -> real
+
+ real
+ snow_coverage() const
+ """
return _cmf_core.Cell_snow_coverage(self, *args, **kwargs)
def albedo(self, *args, **kwargs):
- """albedo(Cell self) -> real"""
+ """
+ albedo(Cell self) -> real
+
+ real albedo()
+ const
+ """
return _cmf_core.Cell_albedo(self, *args, **kwargs)
surface_amplitude = _swig_property(_cmf_core.Cell_surface_amplitude_get, _cmf_core.Cell_surface_amplitude_set)
def surface_water_coverage(self, *args, **kwargs):
- """surface_water_coverage(Cell self) -> real"""
+ """
+ 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
+ """
return _cmf_core.Cell_surface_water_coverage(self, *args, **kwargs)
def heat_flux(self, *args, **kwargs):
- """heat_flux(Cell self, Time t) -> real"""
+ """
+ heat_flux(Cell self, Time t) -> real
+
+ real
+ heat_flux(cmf::math::Time t) const
+
+ Calculates the surface heat balance.
+
+ Parameters:
+ -----------
+
+ t: Time step
+ """
return _cmf_core.Cell_heat_flux(self, *args, **kwargs)
Tground = _swig_property(_cmf_core.Cell_Tground_get, _cmf_core.Cell_Tground_set)
def leave_wetness(self, *args, **kwargs):
- """leave_wetness(Cell self) -> real"""
+ """
+ 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.
+ """
return _cmf_core.Cell_leave_wetness(self, *args, **kwargs)
Id = _swig_property(_cmf_core.Cell_Id_get, _cmf_core.Cell_Id_set)
def get_weather(self, *args, **kwargs):
- """get_weather(Cell self, Time t) -> Weather"""
+ """
+ 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.
+
+ """
return _cmf_core.Cell_get_weather(self, *args, **kwargs)
def layer_count(self, *args, **kwargs):
- """layer_count(Cell self) -> size_t"""
+ """
+ layer_count(Cell self) -> size_t
+
+ size_t
+ layer_count() const
+
+ Returns the number of layers of the cell.
+ """
return _cmf_core.Cell_layer_count(self, *args, **kwargs)
def get_layer(self, *args, **kwargs):
- """get_layer(Cell self, ptrdiff_t ndx) -> cmf::upslope::SoilLayer::ptr"""
+ """
+ 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:
+ """
return _cmf_core.Cell_get_layer(self, *args, **kwargs)
@@ -3850,27 +7362,56 @@ def add_layer(self, *args):
"""
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.
"""
return _cmf_core.Cell_add_layer(self, *args)
def remove_last_layer(self, *args, **kwargs):
- """remove_last_layer(Cell self)"""
+ """
+ remove_last_layer(Cell self)
+
+ void
+ remove_last_layer()
+
+ Remove the lowest layer from this cell.
+ """
return _cmf_core.Cell_remove_last_layer(self, *args, **kwargs)
def remove_layers(self, *args, **kwargs):
- """remove_layers(Cell self)"""
+ """
+ remove_layers(Cell self)
+
+ void
+ remove_layers()
+
+ Removes all layers from this cell.
+ """
return _cmf_core.Cell_remove_layers(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_Cell
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::Cell self, double x, double y, double z, double area, project _project) -> Cell"""
+ """
+ __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)
+ """
_cmf_core.Cell_swiginit(self, _cmf_core.new_Cell(*args, **kwargs))
def to_string(self, *args, **kwargs):
- """to_string(Cell self) -> std::string"""
+ """
+ to_string(Cell self) -> std::string
+
+ std::string
+ to_string() const
+ """
return _cmf_core.Cell_to_string(self, *args, **kwargs)
topology = _swig_property(_cmf_core.Cell_topology_get)
@@ -3984,7 +7525,13 @@ def __repr__(self):
Cell_swigregister(Cell)
class Topology(object):
- """Proxy of C++ cmf::upslope::Topology class."""
+ """
+
+
+ represents the connectivity of cells to each other
+
+ C++ includes: Topology.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -3997,7 +7544,13 @@ def __init__(self, *args, **kwargs):
z = _swig_property(_cmf_core.Topology_z_get, _cmf_core.Topology_z_set)
def get_position(self, *args, **kwargs):
- """get_position(Topology self) -> point"""
+ """
+ get_position(Topology self) -> point
+
+ cmf::geometry::point get_position() const
+
+ Returns the center of the cell.
+ """
return _cmf_core.Topology_get_position(self, *args, **kwargs)
@@ -4005,6 +7558,9 @@ def flowwidth(self, *args):
"""
flowwidth(Topology self, Cell target) -> double
flowwidth(Topology self, Topology target) -> double
+
+ double
+ flowwidth(Topology &target)
"""
return _cmf_core.Topology_flowwidth(self, *args)
@@ -4013,27 +7569,57 @@ def AddNeighbor(self, *args):
"""
AddNeighbor(Topology self, Cell target, double flowwidth)
AddNeighbor(Topology self, Topology target, double flowwidth)
+
+ void
+ AddNeighbor(Topology &target, double flowwidth)
"""
return _cmf_core.Topology_AddNeighbor(self, *args)
def RemoveNeighbor(self, *args, **kwargs):
- """RemoveNeighbor(Topology self, Topology target)"""
+ """
+ RemoveNeighbor(Topology self, Topology target)
+
+ void
+ RemoveNeighbor(Topology &target)
+
+ Removes the topological relation to the given cell.
+ """
return _cmf_core.Topology_RemoveNeighbor(self, *args, **kwargs)
def neighbor_count(self, *args, **kwargs):
- """neighbor_count(Topology self) -> size_t"""
+ """
+ neighbor_count(Topology self) -> size_t
+
+ size_t
+ neighbor_count() const
+
+ Returns the number of neighbors.
+ """
return _cmf_core.Topology_neighbor_count(self, *args, **kwargs)
def MainOutlet(self, *args, **kwargs):
- """MainOutlet(Topology self, bool forceRecalc=False) -> Cell"""
+ """
+ MainOutlet(Topology self, bool forceRecalc=False) -> Cell
+
+ Cell*
+ MainOutlet(bool forceRecalc=false)
+
+ Returns the mainoutlet (steepest lower neighbor)
+ """
return _cmf_core.Topology_MainOutlet(self, *args, **kwargs)
def ContributingArea(self, *args, **kwargs):
- """ContributingArea(Topology self) -> double"""
+ """
+ ContributingArea(Topology self) -> double
+
+ double ContributingArea() const
+
+ Get the contributing area (steepest path upwards)
+ """
return _cmf_core.Topology_ContributingArea(self, *args, **kwargs)
@@ -4064,32 +7650,63 @@ def Topology_calculate_contributing_area(*args, **kwargs):
return _cmf_core.Topology_calculate_contributing_area(*args, **kwargs)
class neighbor_iterator(object):
- """Proxy of C++ cmf::upslope::neighbor_iterator class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::neighbor_iterator self, Cell cell) -> neighbor_iterator"""
+ """
+ __init__(cmf::upslope::neighbor_iterator self, Cell cell) -> neighbor_iterator
+
+ neighbor_iterator(cmf::upslope::Cell *cell)
+ """
_cmf_core.neighbor_iterator_swiginit(self, _cmf_core.new_neighbor_iterator(*args, **kwargs))
def cell(self, *args, **kwargs):
- """cell(neighbor_iterator self) -> Cell"""
+ """
+ cell(neighbor_iterator self) -> Cell
+
+ Cell&
+ cell()
+ """
return _cmf_core.neighbor_iterator_cell(self, *args, **kwargs)
def flowwidth(self, *args, **kwargs):
- """flowwidth(neighbor_iterator self) -> double"""
+ """
+ flowwidth(neighbor_iterator self) -> double
+
+ double flowwidth()
+ """
return _cmf_core.neighbor_iterator_flowwidth(self, *args, **kwargs)
def valid(self, *args, **kwargs):
- """valid(neighbor_iterator self) -> bool"""
+ """
+ valid(neighbor_iterator self) -> bool
+
+ bool
+ valid() const
+ """
return _cmf_core.neighbor_iterator_valid(self, *args, **kwargs)
def next(self, *args, **kwargs):
- """next(neighbor_iterator self) -> neighbor_iterator"""
+ """
+ next(neighbor_iterator self) -> neighbor_iterator
+
+ neighbor_iterator& next()
+
+ Points the iterator to the next neighbor.
+ """
return _cmf_core.neighbor_iterator_next(self, *args, **kwargs)
@@ -4113,7 +7730,13 @@ def __neq__(self, *args, **kwargs):
neighbor_iterator_swigregister(neighbor_iterator)
class cell_vector(StateVariableOwner):
- """Proxy of C++ cmf::upslope::cell_vector class."""
+ """
+
+
+ A cell vector holds a bunch of cells.
+
+ C++ includes: cell_vector.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -4122,6 +7745,8 @@ 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)
"""
_cmf_core.cell_vector_swiginit(self, _cmf_core.new_cell_vector(*args))
@@ -4134,7 +7759,12 @@ def __getitem__(self, *args):
def append(self, *args, **kwargs):
- """append(cell_vector self, Cell cell)"""
+ """
+ append(cell_vector self, Cell cell)
+
+ void
+ append(cmf::upslope::Cell &cell)
+ """
return _cmf_core.cell_vector_append(self, *args, **kwargs)
@@ -4142,32 +7772,63 @@ def remove(self, *args):
"""
remove(cell_vector self, ptrdiff_t index)
remove(cell_vector self, Cell cell)
+
+ void
+ remove(const cmf::upslope::Cell &cell)
"""
return _cmf_core.cell_vector_remove(self, *args)
def pop(self, *args, **kwargs):
- """pop(cell_vector self) -> Cell"""
+ """
+ pop(cell_vector self) -> Cell
+
+ Cell& pop()
+
+ Returns and removes the last cell.
+ """
return _cmf_core.cell_vector_pop(self, *args, **kwargs)
def __len__(self, *args, **kwargs):
- """__len__(cell_vector self) -> size_t"""
+ """
+ __len__(cell_vector self) -> size_t
+
+ size_t size()
+ const
+ """
return _cmf_core.cell_vector___len__(self, *args, **kwargs)
def __getslice__(self, *args, **kwargs):
- """__getslice__(cell_vector self, ptrdiff_t start, ptrdiff_t end, ptrdiff_t step=1) -> cell_vector"""
+ """
+ __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)
+ """
return _cmf_core.cell_vector___getslice__(self, *args, **kwargs)
def get_area(self, *args, **kwargs):
- """get_area(cell_vector self) -> double"""
+ """
+ get_area(cell_vector self) -> double
+
+ double
+ get_area() const
+
+ Returns sum of the area of the cells.
+ """
return _cmf_core.cell_vector_get_area(self, *args, **kwargs)
def __contains__(self, *args, **kwargs):
- """__contains__(cell_vector self, Cell cell) -> bool"""
+ """
+ __contains__(cell_vector self, Cell cell) -> bool
+
+ bool
+ contains(const cmf::upslope::Cell &cell) const
+ """
return _cmf_core.cell_vector___contains__(self, *args, **kwargs)
lowest = _swig_property(_cmf_core.cell_vector_lowest_get)
@@ -4239,7 +7900,13 @@ def cell_distance(*args, **kwargs):
"""cell_distance(Cell c1, Cell c2) -> double"""
return _cmf_core.cell_distance(*args, **kwargs)
class subcatchment(object):
- """Proxy of C++ cmf::upslope::subcatchment class."""
+ """
+
+
+ A class to structure cells in a project using their main outlets.
+
+ C++ includes: algorithm.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -4248,7 +7915,23 @@ class subcatchment(object):
cells = _swig_property(_cmf_core.subcatchment_cells_get, _cmf_core.subcatchment_cells_set)
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::subcatchment self, Cell pourpoint, double area_threshold=1e308) -> subcatchment"""
+ """
+ __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.
+ """
_cmf_core.subcatchment_swiginit(self, _cmf_core.new_subcatchment(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_subcatchment
subcatchment_swigregister = _cmf_core.subcatchment_swigregister
@@ -4271,7 +7954,17 @@ def waterhead_to_pF(*args, **kwargs):
"""waterhead_to_pF(double waterhead) -> double"""
return _cmf_core.waterhead_to_pF(*args, **kwargs)
class RetentionCurve(object):
- """Proxy of C++ cmf::upslope::RetentionCurve class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -4283,27 +7976,63 @@ 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
"""
return _cmf_core.RetentionCurve_K(self, *args)
def Wetness_eff(self, *args, **kwargs):
- """Wetness_eff(RetentionCurve self, real wetness, real pF_r=4.2) -> real"""
+ """
+ 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)}
+
+ .
+
+ """
return _cmf_core.RetentionCurve_Wetness_eff(self, *args, **kwargs)
def Porosity(self, *args, **kwargs):
- """Porosity(RetentionCurve self, real depth=0.0) -> real"""
+ """
+ Porosity(RetentionCurve self, real depth=0.0) -> real
+
+ virtual real Porosity(real depth=0.0) const =0
+
+ Returns the porosity at a certain depth.
+ """
return _cmf_core.RetentionCurve_Porosity(self, *args, **kwargs)
def VoidVolume(self, *args, **kwargs):
- """VoidVolume(RetentionCurve self, real upperDepth, real lowerDepth, real Area) -> real"""
+ """
+ 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.
+ """
return _cmf_core.RetentionCurve_VoidVolume(self, *args, **kwargs)
def FillHeight(self, *args, **kwargs):
- """FillHeight(RetentionCurve self, real lowerDepth, real Area, real Volume) -> real"""
+ """
+ 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.
+ """
return _cmf_core.RetentionCurve_FillHeight(self, *args, **kwargs)
@@ -4311,6 +8040,8 @@ 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)
"""
return _cmf_core.RetentionCurve_Diffusivity(self, *args)
@@ -4319,6 +8050,9 @@ 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
"""
return _cmf_core.RetentionCurve_Wetness(self, *args)
@@ -4327,6 +8061,9 @@ 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
+
"""
return _cmf_core.RetentionCurve_theta(self, *args)
@@ -4335,6 +8072,9 @@ 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
"""
return _cmf_core.RetentionCurve_dPsiM_dW(self, *args)
@@ -4343,6 +8083,9 @@ 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
+
"""
return _cmf_core.RetentionCurve_Wetness_pF(self, *args)
@@ -4351,12 +8094,20 @@ 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
"""
return _cmf_core.RetentionCurve_MatricPotential(self, *args)
def copy(self, *args, **kwargs):
- """copy(RetentionCurve self) -> RetentionCurve"""
+ """
+ copy(RetentionCurve self) -> RetentionCurve
+
+ virtual
+ RetentionCurve* copy() const =0
+ """
return _cmf_core.RetentionCurve_copy(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_RetentionCurve
@@ -4377,19 +8128,68 @@ def copy(self, *args, **kwargs):
rho_wg = cvar.rho_wg
class BrooksCoreyRetentionCurve(RetentionCurve):
- """Proxy of C++ cmf::upslope::BrooksCoreyRetentionCurve class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
Ksat = _swig_property(_cmf_core.BrooksCoreyRetentionCurve_Ksat_get, _cmf_core.BrooksCoreyRetentionCurve_Ksat_set)
def SetPorosity(self, *args, **kwargs):
- """SetPorosity(BrooksCoreyRetentionCurve self, real porosity, real porosity_decay=0)"""
+ """
+ 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.
+ """
return _cmf_core.BrooksCoreyRetentionCurve_SetPorosity(self, *args, **kwargs)
def Transmissivity(self, *args, **kwargs):
- """Transmissivity(BrooksCoreyRetentionCurve self, real upperDepth, real lowerDepth, real theta) -> real"""
+ """
+ Transmissivity(BrooksCoreyRetentionCurve self, real upperDepth, real lowerDepth, real theta) -> real
+
+ real
+ Transmissivity(real upperDepth, real lowerDepth, real theta) const
+ """
return _cmf_core.BrooksCoreyRetentionCurve_Transmissivity(self, *args, **kwargs)
wetness_X = _swig_property(_cmf_core.BrooksCoreyRetentionCurve_wetness_X_get, _cmf_core.BrooksCoreyRetentionCurve_wetness_X_set)
@@ -4397,7 +8197,34 @@ def Transmissivity(self, *args, **kwargs):
residual_theta = _swig_property(_cmf_core.BrooksCoreyRetentionCurve_residual_theta_get, _cmf_core.BrooksCoreyRetentionCurve_residual_theta_set)
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"""
+ """
+ __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
+ """
_cmf_core.BrooksCoreyRetentionCurve_swiginit(self, _cmf_core.new_BrooksCoreyRetentionCurve(*args, **kwargs))
def CreateFrom2Points(*args, **kwargs):
@@ -4407,7 +8234,11 @@ def CreateFrom2Points(*args, **kwargs):
CreateFrom2Points = staticmethod(CreateFrom2Points)
def copy(self, *args, **kwargs):
- """copy(BrooksCoreyRetentionCurve self) -> BrooksCoreyRetentionCurve"""
+ """
+ copy(BrooksCoreyRetentionCurve self) -> BrooksCoreyRetentionCurve
+
+ virtual BrooksCoreyRetentionCurve* copy() const
+ """
return _cmf_core.BrooksCoreyRetentionCurve_copy(self, *args, **kwargs)
b = _swig_property(_cmf_core.BrooksCoreyRetentionCurve_b_get, _cmf_core.BrooksCoreyRetentionCurve_b_set)
@@ -4429,7 +8260,39 @@ def BrooksCoreyRetentionCurve_CreateFrom2Points(*args, **kwargs):
return _cmf_core.BrooksCoreyRetentionCurve_CreateFrom2Points(*args, **kwargs)
class VanGenuchtenMualem(RetentionCurve):
- """Proxy of C++ cmf::upslope::VanGenuchtenMualem class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -4443,22 +8306,69 @@ class VanGenuchtenMualem(RetentionCurve):
w0 = _swig_property(_cmf_core.VanGenuchtenMualem_w0_get, _cmf_core.VanGenuchtenMualem_w0_set)
def Transmissivity(self, *args, **kwargs):
- """Transmissivity(VanGenuchtenMualem self, real upperDepth, real lowerDepth, real wetness) -> real"""
+ """
+ Transmissivity(VanGenuchtenMualem self, real upperDepth, real lowerDepth, real wetness) -> real
+
+ virtual real
+ Transmissivity(real upperDepth, real lowerDepth, real wetness) const
+
+ """
return _cmf_core.VanGenuchtenMualem_Transmissivity(self, *args, **kwargs)
def fit_w0(self, *args, **kwargs):
- """fit_w0(VanGenuchtenMualem self, real w1=1.01, real Psi_p=1.0, real tolerance=0.05) -> real"""
+ """
+ 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:
+ """
return _cmf_core.VanGenuchtenMualem_fit_w0(self, *args, **kwargs)
def copy(self, *args, **kwargs):
- """copy(VanGenuchtenMualem self) -> VanGenuchtenMualem"""
+ """
+ copy(VanGenuchtenMualem self) -> VanGenuchtenMualem
+
+ VanGenuchtenMualem* copy() const
+ """
return _cmf_core.VanGenuchtenMualem_copy(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::VanGenuchtenMualem self, real Ksat=15, real phi=0.5, real alpha=0.2178, real n=1.211, real m=-1) -> VanGenuchtenMualem"""
+ """
+ __init__(cmf::upslope::VanGenuchtenMualem self, real Ksat=15, real phi=0.5, real alpha=0.2178, real n=1.211, real m=-1) -> VanGenuchtenMualem
+
+ VanGenuchtenMualem(real Ksat=15, real phi=0.5, real alpha=0.2178, real
+ n=1.211, real m=-1)
+
+ 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`
+ """
_cmf_core.VanGenuchtenMualem_swiginit(self, _cmf_core.new_VanGenuchtenMualem(*args, **kwargs))
def __repr__(self):
@@ -4474,7 +8384,30 @@ def __str__(self):
VanGenuchtenMualem_swigregister(VanGenuchtenMualem)
class LinearRetention(RetentionCurve):
- """Proxy of C++ cmf::upslope::LinearRetention class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -4486,17 +8419,31 @@ class LinearRetention(RetentionCurve):
beta = _swig_property(_cmf_core.LinearRetention_beta_get, _cmf_core.LinearRetention_beta_set)
def Transmissivity(self, *args, **kwargs):
- """Transmissivity(LinearRetention self, real upperDepth, real lowerDepth, real wetness) -> real"""
+ """
+ Transmissivity(LinearRetention self, real upperDepth, real lowerDepth, real wetness) -> real
+
+ virtual real Transmissivity(real upperDepth, real lowerDepth, real
+ wetness) const
+ """
return _cmf_core.LinearRetention_Transmissivity(self, *args, **kwargs)
def copy(self, *args, **kwargs):
- """copy(LinearRetention self) -> LinearRetention"""
+ """
+ copy(LinearRetention self) -> LinearRetention
+
+ LinearRetention* copy() const
+ """
return _cmf_core.LinearRetention_copy(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::LinearRetention self, real ksat, real phi, real thickness, real residual_wetness=0.1) -> LinearRetention"""
+ """
+ __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)
+ """
_cmf_core.LinearRetention_swiginit(self, _cmf_core.new_LinearRetention(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_LinearRetention
LinearRetention.Transmissivity = new_instancemethod(_cmf_core.LinearRetention_Transmissivity, None, LinearRetention)
@@ -4505,7 +8452,13 @@ def __init__(self, *args, **kwargs):
LinearRetention_swigregister(LinearRetention)
class SoilLayer(WaterStorage):
- """Proxy of C++ cmf::upslope::SoilLayer class."""
+ """
+
+
+ A representation of a SoilLayer.
+
+ C++ includes: SoilLayer.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -4516,43 +8469,114 @@ def __init__(self, *args, **kwargs):
cell = _swig_property(_cmf_core.SoilLayer_cell_get)
def __get_upper(self, *args, **kwargs):
- """__get_upper(SoilLayer self) -> cmf::upslope::SoilLayer::ptr"""
+ """
+ __get_upper(SoilLayer self) -> cmf::upslope::SoilLayer::ptr
+
+ ptr
+ get_upper() const
+ """
return _cmf_core.SoilLayer___get_upper(self, *args, **kwargs)
def __get_lower(self, *args, **kwargs):
- """__get_lower(SoilLayer self) -> cmf::upslope::SoilLayer::ptr"""
+ """
+ __get_lower(SoilLayer self) -> cmf::upslope::SoilLayer::ptr
+
+ ptr
+ get_lower() const
+ """
return _cmf_core.SoilLayer___get_lower(self, *args, **kwargs)
def get_soil(self, *args, **kwargs):
- """get_soil(SoilLayer self) -> RetentionCurve"""
+ """
+ get_soil(SoilLayer self) -> RetentionCurve
+
+ virtual
+ cmf::upslope::RetentionCurve& get_soil() const
+
+ Returns the soil properties of the water storage.
+ """
return _cmf_core.SoilLayer_get_soil(self, *args, **kwargs)
def set_soil(self, *args, **kwargs):
- """set_soil(SoilLayer self, RetentionCurve r_curve)"""
+ """
+ set_soil(SoilLayer self, RetentionCurve r_curve)
+
+ virtual
+ void set_soil(const cmf::upslope::RetentionCurve &r_curve)
+ """
return _cmf_core.SoilLayer_set_soil(self, *args, **kwargs)
def get_K(self, *args, **kwargs):
- """get_K(SoilLayer self, point direction) -> real"""
+ """
+ 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`.
+ """
return _cmf_core.SoilLayer_get_K(self, *args, **kwargs)
anisotropic_kf = _swig_property(_cmf_core.SoilLayer_anisotropic_kf_get, _cmf_core.SoilLayer_anisotropic_kf_set)
def get_capacity(self, *args, **kwargs):
- """get_capacity(SoilLayer self) -> real"""
+ """
+ get_capacity(SoilLayer self) -> real
+
+ virtual
+ real get_capacity() const
+
+ Returns the capacity of the water storage in m3.
+ """
return _cmf_core.SoilLayer_get_capacity(self, *args, **kwargs)
def get_saturated_depth(self, *args, **kwargs):
- """get_saturated_depth(SoilLayer self) -> real"""
+ """
+ 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.
+
+ .
+ """
return _cmf_core.SoilLayer_get_saturated_depth(self, *args, **kwargs)
def get_flow_crosssection(self, *args, **kwargs):
- """get_flow_crosssection(SoilLayer self, SoilLayer target, bool HorizontalLayers=False) -> real"""
+ """
+ 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
+ """
return _cmf_core.SoilLayer_get_flow_crosssection(self, *args, **kwargs)
@@ -4605,7 +8629,14 @@ def SoilLayer_cast(*args, **kwargs):
return _cmf_core.SoilLayer_cast(*args, **kwargs)
class layer_list(object):
- """Proxy of C++ cmf::upslope::layer_list class."""
+ """
+
+
+ A vector of layers, with array access to the properties of the layers,
+ for fast data exchange.
+
+ C++ includes: layer_list.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -4615,16 +8646,34 @@ 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.
"""
_cmf_core.layer_list_swiginit(self, _cmf_core.new_layer_list(*args))
def pop(self, *args, **kwargs):
- """pop(layer_list self) -> cmf::upslope::SoilLayer::ptr"""
+ """
+ pop(layer_list self) -> cmf::upslope::SoilLayer::ptr
+
+ SoilLayer::ptr
+ pop()
+
+ Deletes the last layer from the list and returns it.
+ """
return _cmf_core.layer_list_pop(self, *args, **kwargs)
def append(self, *args, **kwargs):
- """append(layer_list self, cmf::upslope::SoilLayer::ptr l) -> layer_list"""
+ """
+ append(layer_list self, cmf::upslope::SoilLayer::ptr l) -> layer_list
+
+ layer_list&
+ append(SoilLayer::ptr l)
+
+ Appends a soil layer to the list.
+ """
return _cmf_core.layer_list_append(self, *args, **kwargs)
@@ -4632,57 +8681,129 @@ 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.
"""
return _cmf_core.layer_list_extend(self, *args)
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"""
+ """
+ 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)
+ """
return _cmf_core.layer_list_get_slice(self, *args, **kwargs)
def clear(self, *args, **kwargs):
- """clear(layer_list self)"""
+ """
+ clear(layer_list self)
+
+ void clear()
+
+ Clears the list.
+ """
return _cmf_core.layer_list_clear(self, *args, **kwargs)
def size(self, *args, **kwargs):
- """size(layer_list self) -> size_t"""
+ """
+ size(layer_list self) -> size_t
+
+ size_t size()
+ const
+
+ Number of layers in the list.
+ """
return _cmf_core.layer_list_size(self, *args, **kwargs)
def set_wetness(self, *args, **kwargs):
- """set_wetness(layer_list self, cmf::math::num_array const & Value, size_t offset=0)"""
+ """
+ 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].
+ """
return _cmf_core.layer_list_set_wetness(self, *args, **kwargs)
def set_potential(self, *args, **kwargs):
- """set_potential(layer_list self, cmf::math::num_array const & Value, size_t offset=0)"""
+ """
+ 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].
+ """
return _cmf_core.layer_list_set_potential(self, *args, **kwargs)
def set_volume(self, *args, **kwargs):
- """set_volume(layer_list self, cmf::math::num_array const & Value, size_t offset=0)"""
+ """
+ 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].
+ """
return _cmf_core.layer_list_set_volume(self, *args, **kwargs)
def get_percolation(self, *args, **kwargs):
- """get_percolation(layer_list self, Time t) -> cmf::math::num_array"""
+ """
+ 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.
+ """
return _cmf_core.layer_list_get_percolation(self, *args, **kwargs)
def set_theta(self, *args, **kwargs):
- """set_theta(layer_list self, cmf::math::num_array const & Value, size_t offset=0)"""
+ """
+ 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.
+ """
return _cmf_core.layer_list_set_theta(self, *args, **kwargs)
def set_ice_fraction(self, *args, **kwargs):
- """set_ice_fraction(layer_list self, cmf::math::num_array const & Value, size_t offset=0)"""
+ """
+ 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.
+ """
return _cmf_core.layer_list_set_ice_fraction(self, *args, **kwargs)
def set_rootfraction(self, *args, **kwargs):
- """set_rootfraction(layer_list self, cmf::math::num_array const & Value, size_t offset=0)"""
+ """
+ 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.
+ """
return _cmf_core.layer_list_set_rootfraction(self, *args, **kwargs)
gravitational_potential = _swig_property(_cmf_core.layer_list_gravitational_potential_get)
@@ -4746,7 +8867,27 @@ def __getitem__(self,index):
layer_list_swigregister(layer_list)
class MacroPore(WaterStorage):
- """Proxy of C++ cmf::upslope::MacroPore class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -4757,12 +8898,26 @@ def __init__(self, *args, **kwargs):
porefraction_max = _swig_property(_cmf_core.MacroPore_porefraction_max_get, _cmf_core.MacroPore_porefraction_max_set)
def __get_layer(self, *args, **kwargs):
- """__get_layer(MacroPore self) -> cmf::upslope::SoilLayer::ptr"""
+ """
+ __get_layer(MacroPore self) -> cmf::upslope::SoilLayer::ptr
+
+ SoilLayer::ptr get_layer() const
+
+ Gets the soil layer (matrix water storage) for this macropore storage.
+
+ """
return _cmf_core.MacroPore___get_layer(self, *args, **kwargs)
def get_porefraction(self, *args, **kwargs):
- """get_porefraction(MacroPore self) -> real"""
+ """
+ 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.
+ """
return _cmf_core.MacroPore_get_porefraction(self, *args, **kwargs)
density = _swig_property(_cmf_core.MacroPore_density_get, _cmf_core.MacroPore_density_set)
@@ -4770,17 +8925,80 @@ def get_porefraction(self, *args, **kwargs):
crack_wetness = _swig_property(_cmf_core.MacroPore_crack_wetness_get, _cmf_core.MacroPore_crack_wetness_set)
def get_K(self, *args, **kwargs):
- """get_K(MacroPore self, point direction) -> real"""
+ """
+ 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`.
+ """
return _cmf_core.MacroPore_get_K(self, *args, **kwargs)
def get_crackwidth(self, *args, **kwargs):
- """get_crackwidth(MacroPore self) -> real"""
+ """
+ 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}
+
+
+
+ """
return _cmf_core.MacroPore_get_crackwidth(self, *args, **kwargs)
def get_flowwidth(self, *args, **kwargs):
- """get_flowwidth(MacroPore self) -> real"""
+ """
+ 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
+ """
return _cmf_core.MacroPore_get_flowwidth(self, *args, **kwargs)
K_shape = _swig_property(_cmf_core.MacroPore_K_shape_get, _cmf_core.MacroPore_K_shape_set)
@@ -4837,33 +9055,132 @@ def __init__(self, *args, **kwargs):
BaseMacroFlow_swigregister(BaseMacroFlow)
class GradientMacroFlow(BaseMacroFlow):
- """Proxy of C++ cmf::upslope::connections::GradientMacroFlow class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::connections::GradientMacroFlow self, cmf::upslope::MacroPore::ptr left, cmf::water::flux_node::ptr right) -> GradientMacroFlow"""
+ """
+ __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)
+ """
_cmf_core.GradientMacroFlow_swiginit(self, _cmf_core.new_GradientMacroFlow(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_GradientMacroFlow
GradientMacroFlow_swigregister = _cmf_core.GradientMacroFlow_swigregister
GradientMacroFlow_swigregister(GradientMacroFlow)
class KinematicMacroFlow(BaseMacroFlow):
- """Proxy of C++ cmf::upslope::connections::KinematicMacroFlow class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
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"""
+ """
+ __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
+ """
_cmf_core.KinematicMacroFlow_swiginit(self, _cmf_core.new_KinematicMacroFlow(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_KinematicMacroFlow
KinematicMacroFlow_swigregister = _cmf_core.KinematicMacroFlow_swigregister
KinematicMacroFlow_swigregister(KinematicMacroFlow)
class JarvisMacroFlow(BaseMacroFlow):
- """Proxy of C++ cmf::upslope::connections::JarvisMacroFlow class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -4871,27 +9188,110 @@ class JarvisMacroFlow(BaseMacroFlow):
porefraction_r = _swig_property(_cmf_core.JarvisMacroFlow_porefraction_r_get, _cmf_core.JarvisMacroFlow_porefraction_r_set)
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"""
+ """
+ __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
+ """
_cmf_core.JarvisMacroFlow_swiginit(self, _cmf_core.new_JarvisMacroFlow(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_JarvisMacroFlow
JarvisMacroFlow_swigregister = _cmf_core.JarvisMacroFlow_swigregister
JarvisMacroFlow_swigregister(JarvisMacroFlow)
class GradientMacroMicroExchange(flux_connection):
- """Proxy of C++ cmf::upslope::connections::GradientMacroMicroExchange class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::connections::GradientMacroMicroExchange self, cmf::upslope::SoilLayer::ptr left, cmf::upslope::MacroPore::ptr right) -> GradientMacroMicroExchange"""
+ """
+ __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)
+ """
_cmf_core.GradientMacroMicroExchange_swiginit(self, _cmf_core.new_GradientMacroMicroExchange(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_GradientMacroMicroExchange
GradientMacroMicroExchange_swigregister = _cmf_core.GradientMacroMicroExchange_swigregister
GradientMacroMicroExchange_swigregister(GradientMacroMicroExchange)
class DiffusiveMacroMicroExchange(flux_connection):
- """Proxy of C++ cmf::upslope::connections::DiffusiveMacroMicroExchange class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -4899,14 +9299,59 @@ class DiffusiveMacroMicroExchange(flux_connection):
pFrmi = _swig_property(_cmf_core.DiffusiveMacroMicroExchange_pFrmi_get, _cmf_core.DiffusiveMacroMicroExchange_pFrmi_set)
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"""
+ """
+ __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)
+ """
_cmf_core.DiffusiveMacroMicroExchange_swiginit(self, _cmf_core.new_DiffusiveMacroMicroExchange(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_DiffusiveMacroMicroExchange
DiffusiveMacroMicroExchange_swigregister = _cmf_core.DiffusiveMacroMicroExchange_swigregister
DiffusiveMacroMicroExchange_swigregister(DiffusiveMacroMicroExchange)
class MACROlikeMacroMicroExchange(flux_connection):
- """Proxy of C++ cmf::upslope::connections::MACROlikeMacroMicroExchange class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -4914,14 +9359,28 @@ class MACROlikeMacroMicroExchange(flux_connection):
gamma_w = _swig_property(_cmf_core.MACROlikeMacroMicroExchange_gamma_w_get, _cmf_core.MACROlikeMacroMicroExchange_gamma_w_set)
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"""
+ """
+ __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)
+ """
_cmf_core.MACROlikeMacroMicroExchange_swiginit(self, _cmf_core.new_MACROlikeMacroMicroExchange(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_MACROlikeMacroMicroExchange
MACROlikeMacroMicroExchange_swigregister = _cmf_core.MACROlikeMacroMicroExchange_swigregister
MACROlikeMacroMicroExchange_swigregister(MACROlikeMacroMicroExchange)
class IVolumeHeightFunction(object):
- """Proxy of C++ cmf::river::IVolumeHeightFunction class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -4930,27 +9389,55 @@ def __init__(self, *args, **kwargs):
__repr__ = _swig_repr
def h(self, *args, **kwargs):
- """h(IVolumeHeightFunction self, double V) -> double"""
+ """
+ h(IVolumeHeightFunction self, double V) -> double
+
+ virtual
+ double h(double V) const =0
+
+ Returns the depth of a given volume.
+ """
return _cmf_core.IVolumeHeightFunction_h(self, *args, **kwargs)
def A(self, *args, **kwargs):
- """A(IVolumeHeightFunction self, double V) -> double"""
+ """
+ A(IVolumeHeightFunction self, double V) -> double
+
+ virtual
+ double A(double V) const =0
+
+ Returns the area of the surface for a given volume.
+ """
return _cmf_core.IVolumeHeightFunction_A(self, *args, **kwargs)
def V(self, *args, **kwargs):
- """V(IVolumeHeightFunction self, double h) -> double"""
+ """
+ V(IVolumeHeightFunction self, double h) -> double
+
+ virtual
+ double V(double h) const =0
+ """
return _cmf_core.IVolumeHeightFunction_V(self, *args, **kwargs)
def copy(self, *args, **kwargs):
- """copy(IVolumeHeightFunction self) -> IVolumeHeightFunction"""
+ """
+ copy(IVolumeHeightFunction self) -> IVolumeHeightFunction
+
+ virtual IVolumeHeightFunction* copy() const =0
+ """
return _cmf_core.IVolumeHeightFunction_copy(self, *args, **kwargs)
def q(self, *args, **kwargs):
- """q(IVolumeHeightFunction self, double h, double slope) -> double"""
+ """
+ q(IVolumeHeightFunction self, double h, double slope) -> double
+
+ virtual
+ double q(double h, double slope) const
+ """
return _cmf_core.IVolumeHeightFunction_q(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_IVolumeHeightFunction
@@ -4963,7 +9450,13 @@ def q(self, *args, **kwargs):
IVolumeHeightFunction_swigregister(IVolumeHeightFunction)
class Prism(IVolumeHeightFunction):
- """Proxy of C++ cmf::river::Prism class."""
+ """
+
+
+ the height of a volume in a Prism with a defined base area
+
+ C++ includes: ReachType.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -4971,11 +9464,21 @@ class Prism(IVolumeHeightFunction):
RoughThickness = _swig_property(_cmf_core.Prism_RoughThickness_get, _cmf_core.Prism_RoughThickness_set)
def __init__(self, *args, **kwargs):
- """__init__(cmf::river::Prism self, double base_area, double thickness_of_rough_ground=0.01) -> Prism"""
+ """
+ __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)
+ """
_cmf_core.Prism_swiginit(self, _cmf_core.new_Prism(*args, **kwargs))
def copy(self, *args, **kwargs):
- """copy(Prism self) -> Prism"""
+ """
+ copy(Prism self) -> Prism
+
+ Prism* copy() const
+
+ """
return _cmf_core.Prism_copy(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_Prism
@@ -4984,7 +9487,13 @@ def copy(self, *args, **kwargs):
Prism_swigregister(Prism)
class volume_height_function(IVolumeHeightFunction):
- """Proxy of C++ cmf::river::volume_height_function class."""
+ """
+
+
+ A wrapper class for volume / height functional relations.
+
+ C++ includes: ReachType.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -4993,11 +9502,19 @@ 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.
"""
_cmf_core.volume_height_function_swiginit(self, _cmf_core.new_volume_height_function(*args))
def copy(self, *args, **kwargs):
- """copy(volume_height_function self) -> volume_height_function"""
+ """
+ copy(volume_height_function self) -> volume_height_function
+
+ volume_height_function* copy() const
+ """
return _cmf_core.volume_height_function_copy(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_volume_height_function
@@ -5006,7 +9523,14 @@ def copy(self, *args, **kwargs):
volume_height_function_swigregister(volume_height_function)
class IChannel(IVolumeHeightFunction):
- """Proxy of C++ cmf::river::IChannel class."""
+ """
+
+
+ Structure for the description of structural parameters of a reach
+ Abstract base class for different IChannel geometries.
+
+ C++ includes: ReachType.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -5015,52 +9539,154 @@ def __init__(self, *args, **kwargs):
__repr__ = _swig_repr
def get_nManning(self, *args, **kwargs):
- """get_nManning(IChannel self) -> double"""
+ """
+ get_nManning(IChannel self) -> double
+
+ virtual
+ double get_nManning() const =0
+ """
return _cmf_core.IChannel_get_nManning(self, *args, **kwargs)
def set_nManning(self, *args, **kwargs):
- """set_nManning(IChannel self, double val)"""
+ """
+ set_nManning(IChannel self, double val)
+
+ virtual
+ void set_nManning(double val)=0
+ """
return _cmf_core.IChannel_set_nManning(self, *args, **kwargs)
def get_length(self, *args, **kwargs):
- """get_length(IChannel self) -> double"""
+ """
+ get_length(IChannel self) -> double
+
+ virtual
+ double get_length() const =0
+
+ Length of the reach.
+ """
return _cmf_core.IChannel_get_length(self, *args, **kwargs)
def typecode(self, *args, **kwargs):
- """typecode(IChannel self) -> char"""
+ """
+ typecode(IChannel self) -> char
+
+ virtual char
+ typecode() const =0
+ """
return _cmf_core.IChannel_typecode(self, *args, **kwargs)
def get_channel_width(self, *args, **kwargs):
- """get_channel_width(IChannel self, double depth) -> double"""
+ """
+ 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.
+ """
return _cmf_core.IChannel_get_channel_width(self, *args, **kwargs)
def get_wetted_perimeter(self, *args, **kwargs):
- """get_wetted_perimeter(IChannel self, double depth) -> double"""
+ """
+ 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.
+ """
return _cmf_core.IChannel_get_wetted_perimeter(self, *args, **kwargs)
def get_depth(self, *args, **kwargs):
- """get_depth(IChannel self, double area) -> double"""
+ """
+ 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
+ """
return _cmf_core.IChannel_get_depth(self, *args, **kwargs)
def get_flux_crossection(self, *args, **kwargs):
- """get_flux_crossection(IChannel self, double depth) -> double"""
+ """
+ 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]
+ """
return _cmf_core.IChannel_get_flux_crossection(self, *args, **kwargs)
def copy(self, *args, **kwargs):
- """copy(IChannel self) -> IChannel"""
+ """
+ copy(IChannel self) -> IChannel
+
+ virtual IChannel*
+ copy() const =0
+ """
return _cmf_core.IChannel_copy(self, *args, **kwargs)
def qManning(self, *args, **kwargs):
- """qManning(IChannel self, double A, double slope) -> double"""
+ """
+ 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]
+ """
return _cmf_core.IChannel_qManning(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_IChannel
@@ -5078,7 +9704,19 @@ def qManning(self, *args, **kwargs):
IChannel_swigregister(IChannel)
class SWATReachType(IChannel):
- """Proxy of C++ cmf::river::SWATReachType class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -5092,11 +9730,28 @@ def __init__(self, *args):
__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]
"""
_cmf_core.SWATReachType_swiginit(self, _cmf_core.new_SWATReachType(*args))
def copy(self, *args, **kwargs):
- """copy(SWATReachType self) -> SWATReachType"""
+ """
+ copy(SWATReachType self) -> SWATReachType
+
+ SWATReachType* copy() const
+ """
return _cmf_core.SWATReachType_copy(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_SWATReachType
@@ -5105,7 +9760,18 @@ def copy(self, *args, **kwargs):
SWATReachType_swigregister(SWATReachType)
class TriangularReach(IChannel):
- """Proxy of C++ cmf::river::TriangularReach class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -5115,11 +9781,17 @@ 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 ©)
"""
_cmf_core.TriangularReach_swiginit(self, _cmf_core.new_TriangularReach(*args))
def copy(self, *args, **kwargs):
- """copy(TriangularReach self) -> TriangularReach"""
+ """
+ copy(TriangularReach self) -> TriangularReach
+
+ TriangularReach* copy() const
+ """
return _cmf_core.TriangularReach_copy(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_TriangularReach
@@ -5128,7 +9800,13 @@ def copy(self, *args, **kwargs):
TriangularReach_swigregister(TriangularReach)
class RectangularReach(IChannel):
- """Proxy of C++ cmf::river::RectangularReach class."""
+ """
+
+
+ Describes a IChannel with a rectangular crosssection.
+
+ C++ includes: ReachType.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -5137,11 +9815,17 @@ def __init__(self, *args):
"""
__init__(cmf::river::RectangularReach self, double l, double width) -> RectangularReach
__init__(cmf::river::RectangularReach self, RectangularReach copy) -> RectangularReach
+
+ RectangularReach(const RectangularReach ©)
"""
_cmf_core.RectangularReach_swiginit(self, _cmf_core.new_RectangularReach(*args))
def copy(self, *args, **kwargs):
- """copy(RectangularReach self) -> RectangularReach"""
+ """
+ copy(RectangularReach self) -> RectangularReach
+
+ RectangularReach* copy() const
+ """
return _cmf_core.RectangularReach_copy(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_RectangularReach
@@ -5150,7 +9834,13 @@ def copy(self, *args, **kwargs):
RectangularReach_swigregister(RectangularReach)
class PipeReach(IChannel):
- """Proxy of C++ cmf::river::PipeReach class."""
+ """
+
+
+ Describes the geometry of a closed pipe.
+
+ C++ includes: ReachType.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -5160,11 +9850,18 @@ 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 ©)
"""
_cmf_core.PipeReach_swiginit(self, _cmf_core.new_PipeReach(*args))
def copy(self, *args, **kwargs):
- """copy(PipeReach self) -> PipeReach"""
+ """
+ copy(PipeReach self) -> PipeReach
+
+ PipeReach* copy()
+ const
+ """
return _cmf_core.PipeReach_copy(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_PipeReach
@@ -5173,7 +9870,13 @@ def copy(self, *args, **kwargs):
PipeReach_swigregister(PipeReach)
class Channel(IChannel):
- """Proxy of C++ cmf::river::Channel class."""
+ """
+
+
+ A wrapper for channel geometries.
+
+ C++ includes: ReachType.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -5186,11 +9889,43 @@ def __init__(self, *args):
__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')
"""
_cmf_core.Channel_swiginit(self, _cmf_core.new_Channel(*args))
def copy(self, *args, **kwargs):
- """copy(Channel self) -> Channel"""
+ """
+ copy(Channel self) -> Channel
+
+ Channel* copy()
+ const
+ """
return _cmf_core.Channel_copy(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_Channel
@@ -5199,7 +9934,13 @@ def copy(self, *args, **kwargs):
Channel_swigregister(Channel)
class MeanChannel(IChannel):
- """Proxy of C++ cmf::river::MeanChannel class."""
+ """
+
+
+ A combination of two channel geometries.
+
+ C++ includes: ReachType.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -5208,11 +9949,18 @@ 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)
"""
_cmf_core.MeanChannel_swiginit(self, _cmf_core.new_MeanChannel(*args))
def copy(self, *args, **kwargs):
- """copy(MeanChannel self) -> MeanChannel"""
+ """
+ copy(MeanChannel self) -> MeanChannel
+
+ MeanChannel*
+ copy() const
+ """
return _cmf_core.MeanChannel_copy(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_MeanChannel
@@ -5221,7 +9969,16 @@ def copy(self, *args, **kwargs):
MeanChannel_swigregister(MeanChannel)
class OpenWaterStorage(WaterStorage):
- """Proxy of C++ cmf::river::OpenWaterStorage class."""
+ """
+
+
+ An open water body.
+
+ The potential is calculated from the stored water using a water table
+ function
+
+ C++ includes: OpenWaterStorage.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -5230,17 +9987,36 @@ def __init__(self, *args, **kwargs):
__repr__ = _swig_repr
def get_height_function(self, *args, **kwargs):
- """get_height_function(OpenWaterStorage self) -> IVolumeHeightFunction"""
+ """
+ get_height_function(OpenWaterStorage self) -> IVolumeHeightFunction
+
+ virtual const
+ IVolumeHeightFunction& get_height_function() const
+
+ The functional relation between volume, depth and exposed area.
+ """
return _cmf_core.OpenWaterStorage_get_height_function(self, *args, **kwargs)
def set_height_function(self, *args, **kwargs):
- """set_height_function(OpenWaterStorage self, IVolumeHeightFunction val)"""
+ """
+ set_height_function(OpenWaterStorage self, IVolumeHeightFunction val)
+
+ virtual void
+ set_height_function(const IVolumeHeightFunction &val)
+ """
return _cmf_core.OpenWaterStorage_set_height_function(self, *args, **kwargs)
def wet_area(self, *args, **kwargs):
- """wet_area(OpenWaterStorage self) -> real"""
+ """
+ wet_area(OpenWaterStorage self) -> real
+
+ real
+ wet_area() const
+
+ Returns the exposed surface area in m2.
+ """
return _cmf_core.OpenWaterStorage_wet_area(self, *args, **kwargs)
@@ -5282,7 +10058,17 @@ def OpenWaterStorage_cast(*args, **kwargs):
return _cmf_core.OpenWaterStorage_cast(*args, **kwargs)
class Reach(OpenWaterStorage):
- """Proxy of C++ cmf::river::Reach class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -5291,52 +10077,135 @@ def __init__(self, *args, **kwargs):
__repr__ = _swig_repr
def get_reachtype(self, *args, **kwargs):
- """get_reachtype(Reach self) -> Channel"""
+ """
+ get_reachtype(Reach self) -> Channel
+
+ Channel
+ get_reachtype() const
+
+ Returns the channel shape.
+ """
return _cmf_core.Reach_get_reachtype(self, *args, **kwargs)
def set_height_function(self, *args, **kwargs):
- """set_height_function(Reach self, IChannel val)"""
+ """
+ set_height_function(Reach self, IChannel val)
+
+ void
+ set_height_function(const IChannel &val)
+
+ Sets the channel shape.
+ """
return _cmf_core.Reach_set_height_function(self, *args, **kwargs)
def set_outlet(self, *args, **kwargs):
- """set_outlet(Reach self, cmf::water::flux_node::ptr outlet)"""
+ """
+ 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.
+ """
return _cmf_core.Reach_set_outlet(self, *args, **kwargs)
def set_dead_end(self, *args, **kwargs):
- """set_dead_end(Reach self)"""
+ """
+ set_dead_end(Reach self)
+
+ void
+ set_dead_end()
+
+ Deletes any downstream connection.
+ """
return _cmf_core.Reach_set_dead_end(self, *args, **kwargs)
def set_downstream(self, *args, **kwargs):
- """set_downstream(Reach self, cmf::river::Reach::ptr new_downstream, bool use_meanchannel=False)"""
+ """
+ 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.
+ """
return _cmf_core.Reach_set_downstream(self, *args, **kwargs)
def __get_downstream(self, *args, **kwargs):
- """__get_downstream(Reach self) -> cmf::water::flux_node::ptr"""
+ """
+ __get_downstream(Reach self) -> cmf::water::flux_node::ptr
+
+ cmf::water::flux_node::ptr get_downstream() const
+
+ Returns the reach downstream of this (or null if there is no reach
+ downstream)
+ """
return _cmf_core.Reach___get_downstream(self, *args, **kwargs)
def get_upstream(self, *args, **kwargs):
- """get_upstream(Reach self, int index) -> cmf::river::Reach::ptr"""
+ """
+ get_upstream(Reach self, int index) -> cmf::river::Reach::ptr
+
+ ptr
+ get_upstream(int index) const
+
+ Returns a reach upstream of this.
+ """
return _cmf_core.Reach_get_upstream(self, *args, **kwargs)
def connect_to_surfacewater(self, *args, **kwargs):
- """connect_to_surfacewater(Reach self, Cell cell, real width, bool diffusive)"""
+ """
+ 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
+ """
return _cmf_core.Reach_connect_to_surfacewater(self, *args, **kwargs)
def distance_to_cell(self, *args, **kwargs):
- """distance_to_cell(Reach self, Cell cell) -> double"""
+ """
+ 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
+ """
return _cmf_core.Reach_distance_to_cell(self, *args, **kwargs)
def __get_root(self, *args, **kwargs):
- """__get_root(Reach self) -> cmf::river::Reach::ptr"""
+ """
+ __get_root(Reach self) -> cmf::river::Reach::ptr
+
+ ptr get_root()
+
+ Returns the reach most downstream from this reach.
+ """
return _cmf_core.Reach___get_root(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_Reach
@@ -5409,27 +10278,63 @@ def Reach_create(*args, **kwargs):
return _cmf_core.Reach_create(*args, **kwargs)
class ReachIterator(object):
- """Proxy of C++ cmf::river::ReachIterator class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def next(self, *args, **kwargs):
- """next(ReachIterator self) -> cmf::river::Reach::ptr"""
+ """
+ next(ReachIterator self) -> cmf::river::Reach::ptr
+
+ Reach::ptr
+ next()
+
+ Returns the next reach in the upstream queue.
+ """
return _cmf_core.ReachIterator_next(self, *args, **kwargs)
def valid(self, *args, **kwargs):
- """valid(ReachIterator self) -> bool"""
+ """
+ valid(ReachIterator self) -> bool
+
+ bool valid()
+ const
+
+ Returns true, if reaches are left to iterate over.
+ """
return _cmf_core.ReachIterator_valid(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
- """__init__(cmf::river::ReachIterator self, cmf::river::Reach::ptr first) -> ReachIterator"""
+ """
+ __init__(cmf::river::ReachIterator self, cmf::river::Reach::ptr first) -> ReachIterator
+
+ ReachIterator(Reach::ptr first)
+
+ Creates a ReachIterator from a first reach.
+ """
_cmf_core.ReachIterator_swiginit(self, _cmf_core.new_ReachIterator(*args, **kwargs))
def __reach(self, *args, **kwargs):
- """__reach(ReachIterator self) -> cmf::river::Reach::ptr"""
+ """
+ __reach(ReachIterator self) -> cmf::river::Reach::ptr
+
+ Reach::ptr
+ reach() const
+
+ Returns the current reach.
+ """
return _cmf_core.ReachIterator___reach(self, *args, **kwargs)
position = _swig_property(_cmf_core.ReachIterator_position_get)
@@ -5451,10 +10356,29 @@ def __iter__(self):
def make_river_gap(*args, **kwargs):
- """make_river_gap(cmf::river::Reach::ptr root_reach) -> double"""
+ """
+ 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.
+ """
return _cmf_core.make_river_gap(*args, **kwargs)
class SurfaceWater(OpenWaterStorage):
- """Proxy of C++ cmf::upslope::SurfaceWater class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -5463,12 +10387,26 @@ def __init__(self, *args, **kwargs):
__repr__ = _swig_repr
def get_height_function(self, *args, **kwargs):
- """get_height_function(SurfaceWater self) -> Prism"""
+ """
+ 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.
+
+ """
return _cmf_core.SurfaceWater_get_height_function(self, *args, **kwargs)
def get_cell(self, *args, **kwargs):
- """get_cell(SurfaceWater self) -> Cell"""
+ """
+ get_cell(SurfaceWater self) -> Cell
+
+ Cell&
+ get_cell() const
+
+ Get the cell of the surface.
+ """
return _cmf_core.SurfaceWater_get_cell(self, *args, **kwargs)
@@ -5494,13 +10432,81 @@ def SurfaceWater_cast(*args, **kwargs):
return _cmf_core.SurfaceWater_cast(*args, **kwargs)
class KinematicSurfaceRunoff(flux_connection):
- """Proxy of C++ cmf::upslope::connections::KinematicSurfaceRunoff class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
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"""
+ """
+ __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
+ """
_cmf_core.KinematicSurfaceRunoff_swiginit(self, _cmf_core.new_KinematicSurfaceRunoff(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_KinematicSurfaceRunoff
KinematicSurfaceRunoff_swigregister = _cmf_core.KinematicSurfaceRunoff_swigregister
@@ -5508,7 +10514,70 @@ def __init__(self, *args, **kwargs):
KinematicSurfaceRunoff.cell_connector = _cmf_core.cvar.KinematicSurfaceRunoff_cell_connector
class DiffusiveSurfaceRunoff(flux_connection):
- """Proxy of C++ cmf::upslope::connections::DiffusiveSurfaceRunoff class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -5526,7 +10595,12 @@ def get_linear_slope(*args, **kwargs):
get_linear_slope = staticmethod(get_linear_slope)
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"""
+ """
+ __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)
+ """
_cmf_core.DiffusiveSurfaceRunoff_swiginit(self, _cmf_core.new_DiffusiveSurfaceRunoff(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_DiffusiveSurfaceRunoff
DiffusiveSurfaceRunoff_swigregister = _cmf_core.DiffusiveSurfaceRunoff_swigregister
@@ -5542,7 +10616,36 @@ def DiffusiveSurfaceRunoff_get_linear_slope(*args):
DiffusiveSurfaceRunoff.cell_connector = _cmf_core.cvar.DiffusiveSurfaceRunoff_cell_connector
class aquifer(WaterStorage):
- """Proxy of C++ cmf::upslope::aquifer class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -5552,12 +10655,33 @@ class aquifer(WaterStorage):
K = _swig_property(_cmf_core.aquifer_K_get, _cmf_core.aquifer_K_set)
def get_K(self, *args, **kwargs):
- """get_K(aquifer self, point direction) -> real"""
+ """
+ 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
+
+
+ """
return _cmf_core.aquifer_get_K(self, *args, **kwargs)
def get_abs_errtol(self, *args, **kwargs):
- """get_abs_errtol(aquifer self, real rel_errtol) -> real"""
+ """
+ get_abs_errtol(aquifer self, real rel_errtol) -> real
+
+ real
+ get_abs_errtol(real rel_errtol) const
+ """
return _cmf_core.aquifer_get_abs_errtol(self, *args, **kwargs)
@@ -5565,6 +10689,25 @@ 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
"""
_cmf_core.aquifer_swiginit(self, _cmf_core.new_aquifer(*args))
@@ -5590,21 +10733,64 @@ def aquifer_cast(*args, **kwargs):
return _cmf_core.aquifer_cast(*args, **kwargs)
class aquifer_Darcy(flux_connection):
- """Proxy of C++ cmf::upslope::aquifer_Darcy class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
flux_width = _swig_property(_cmf_core.aquifer_Darcy_flux_width_get, _cmf_core.aquifer_Darcy_flux_width_set)
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"""
+ """
+ __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
+ """
_cmf_core.aquifer_Darcy_swiginit(self, _cmf_core.new_aquifer_Darcy(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_aquifer_Darcy
aquifer_Darcy_swigregister = _cmf_core.aquifer_Darcy_swigregister
aquifer_Darcy_swigregister(aquifer_Darcy)
class lateral_sub_surface_flux(flux_connection):
- """Proxy of C++ cmf::upslope::connections::lateral_sub_surface_flux class."""
+ """
+
+
+ An abstract base class for lateral subsurface fluxes.
+
+ C++ includes: subsurfacefluxes.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -5616,13 +10802,42 @@ def __init__(self, *args, **kwargs):
lateral_sub_surface_flux_swigregister(lateral_sub_surface_flux)
class Darcy(lateral_sub_surface_flux):
- """Proxy of C++ cmf::upslope::connections::Darcy class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
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"""
+ """
+ __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)
+ """
_cmf_core.Darcy_swiginit(self, _cmf_core.new_Darcy(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_Darcy
Darcy_swigregister = _cmf_core.Darcy_swigregister
@@ -5630,13 +10845,56 @@ def __init__(self, *args, **kwargs):
Darcy.cell_connector = _cmf_core.cvar.Darcy_cell_connector
class TopographicGradientDarcy(lateral_sub_surface_flux):
- """Proxy of C++ cmf::upslope::connections::TopographicGradientDarcy class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
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"""
+ """
+ __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
+ """
_cmf_core.TopographicGradientDarcy_swiginit(self, _cmf_core.new_TopographicGradientDarcy(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_TopographicGradientDarcy
TopographicGradientDarcy_swigregister = _cmf_core.TopographicGradientDarcy_swigregister
@@ -5644,13 +10902,46 @@ def __init__(self, *args, **kwargs):
TopographicGradientDarcy.cell_connector = _cmf_core.cvar.TopographicGradientDarcy_cell_connector
class DarcyKinematic(lateral_sub_surface_flux):
- """Proxy of C++ cmf::upslope::connections::DarcyKinematic class."""
+ """
+
+
+ A simple kinemtic wave model for subsurface flux.
+
+
+
+ .. math::
+
+ q = \\frac{\\Delta z_{surface}}{d} K(\\theta)_{source}
+ A_{cross}
+
+ C++ includes: subsurfacefluxes.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
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"""
+ """
+ __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
+ """
_cmf_core.DarcyKinematic_swiginit(self, _cmf_core.new_DarcyKinematic(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_DarcyKinematic
DarcyKinematic_swigregister = _cmf_core.DarcyKinematic_swigregister
@@ -5658,7 +10949,31 @@ def __init__(self, *args, **kwargs):
DarcyKinematic.cell_connector = _cmf_core.cvar.DarcyKinematic_cell_connector
class Richards_lateral(lateral_sub_surface_flux):
- """Proxy of C++ cmf::upslope::connections::Richards_lateral class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -5666,7 +10981,27 @@ class Richards_lateral(lateral_sub_surface_flux):
wet_right_node = _swig_property(_cmf_core.Richards_lateral_wet_right_node_get, _cmf_core.Richards_lateral_wet_right_node_set)
def __init__(self, *args, **kwargs):
- """__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"""
+ """
+ __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
+ """
_cmf_core.Richards_lateral_swiginit(self, _cmf_core.new_Richards_lateral(*args, **kwargs))
def usebaseflow(*args, **kwargs):
@@ -5684,7 +11019,48 @@ def Richards_lateral_usebaseflow(*args, **kwargs):
Richards_lateral.cell_connector = _cmf_core.cvar.Richards_lateral_cell_connector
class TOPModelFlow(flux_connection):
- """Proxy of C++ cmf::upslope::connections::TOPModelFlow class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -5694,14 +11070,52 @@ class TOPModelFlow(flux_connection):
m = _swig_property(_cmf_core.TOPModelFlow_m_get, _cmf_core.TOPModelFlow_m_set)
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"""
+ """
+ __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)
+ """
_cmf_core.TOPModelFlow_swiginit(self, _cmf_core.new_TOPModelFlow(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_TOPModelFlow
TOPModelFlow_swigregister = _cmf_core.TOPModelFlow_swigregister
TOPModelFlow_swigregister(TOPModelFlow)
class Manning(flux_connection):
- """Proxy of C++ cmf::river::Manning class."""
+ """
+
+
+ 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::
+
+
+ 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}
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -5715,14 +11129,54 @@ def __init__(self, *args, **kwargs):
Manning_swigregister(Manning)
class Manning_Diffusive(Manning):
- """Proxy of C++ cmf::river::Manning_Diffusive class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
linear_slope_width = _swig_property(_cmf_core.Manning_Diffusive_linear_slope_width_get, _cmf_core.Manning_Diffusive_linear_slope_width_set)
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"""
+ """
+ __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
+ """
_cmf_core.Manning_Diffusive_swiginit(self, _cmf_core.new_Manning_Diffusive(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_Manning_Diffusive
Manning_Diffusive_swigregister = _cmf_core.Manning_Diffusive_swigregister
@@ -5730,13 +11184,51 @@ def __init__(self, *args, **kwargs):
Manning_Diffusive.cell_connector = _cmf_core.cvar.Manning_Diffusive_cell_connector
class Manning_Kinematic(Manning):
- """Proxy of C++ cmf::river::Manning_Kinematic class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
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"""
+ """
+ __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
+ """
_cmf_core.Manning_Kinematic_swiginit(self, _cmf_core.new_Manning_Kinematic(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_Manning_Kinematic
Manning_Kinematic_swigregister = _cmf_core.Manning_Kinematic_swigregister
@@ -5744,13 +11236,44 @@ def __init__(self, *args, **kwargs):
Manning_Kinematic.cell_connector = _cmf_core.cvar.Manning_Kinematic_cell_connector
class CanopyOverflow(flux_connection):
- """Proxy of C++ cmf::upslope::connections::CanopyOverflow class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
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"""
+ """
+ __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)
+ """
_cmf_core.CanopyOverflow_swiginit(self, _cmf_core.new_CanopyOverflow(*args, **kwargs))
def use_for_cell(*args, **kwargs):
@@ -5767,13 +11290,60 @@ def CanopyOverflow_use_for_cell(*args, **kwargs):
return _cmf_core.CanopyOverflow_use_for_cell(*args, **kwargs)
class RutterInterception(flux_connection):
- """Proxy of C++ cmf::upslope::connections::RutterInterception class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
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"""
+ """
+ __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)
+ """
_cmf_core.RutterInterception_swiginit(self, _cmf_core.new_RutterInterception(*args, **kwargs))
def use_for_cell(*args, **kwargs):
@@ -5790,14 +11360,47 @@ def RutterInterception_use_for_cell(*args, **kwargs):
return _cmf_core.RutterInterception_use_for_cell(*args, **kwargs)
class SimpleTindexSnowMelt(flux_connection):
- """Proxy of C++ cmf::upslope::connections::SimpleTindexSnowMelt class."""
+ """
+
+
+ Calculates snow melt using a simple degree day method.
+
+
+
+ .. math::
+
+ q_{melt} [mm/day] = (T-T_{thres}) * r
+
+ Usage:
+
+ C++ includes: surfacefluxes.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
SnowMeltRate = _swig_property(_cmf_core.SimpleTindexSnowMelt_SnowMeltRate_get, _cmf_core.SimpleTindexSnowMelt_SnowMeltRate_set)
def __init__(self, *args, **kwargs):
- """__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"""
+ """
+ __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
+ """
_cmf_core.SimpleTindexSnowMelt_swiginit(self, _cmf_core.new_SimpleTindexSnowMelt(*args, **kwargs))
def use_for_cell(*args, **kwargs):
@@ -5814,13 +11417,24 @@ def SimpleTindexSnowMelt_use_for_cell(*args, **kwargs):
return _cmf_core.SimpleTindexSnowMelt_use_for_cell(*args, **kwargs)
class EnergyBudgetSnowMelt(flux_connection):
- """Proxy of C++ cmf::upslope::connections::EnergyBudgetSnowMelt class."""
+ """
+
+
+ Calculates snow melt using the surface energy budget method.
+
+ C++ includes: surfacefluxes.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::connections::EnergyBudgetSnowMelt self, cmf::water::WaterStorage::ptr snow, cmf::water::flux_node::ptr surface_water, Cell cell) -> EnergyBudgetSnowMelt"""
+ """
+ __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)
+ """
_cmf_core.EnergyBudgetSnowMelt_swiginit(self, _cmf_core.new_EnergyBudgetSnowMelt(*args, **kwargs))
def use_for_cell(*args, **kwargs):
@@ -5838,10 +11452,28 @@ def EnergyBudgetSnowMelt_use_for_cell(*args, **kwargs):
def snowfraction(*args, **kwargs):
- """snowfraction(real T) -> real"""
+ """
+ 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
+ """
return _cmf_core.snowfraction(*args, **kwargs)
class Rainfall(flux_connection):
- """Proxy of C++ cmf::upslope::connections::Rainfall class."""
+ """
+
+
+ A connection routing rainfall to surface water and to an eventually
+ existing canopy storage.
+
+ C++ includes: AtmosphericFluxes.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -5849,33 +11481,100 @@ class Rainfall(flux_connection):
InterceptedRainfall = _swig_property(_cmf_core.Rainfall_InterceptedRainfall_get, _cmf_core.Rainfall_InterceptedRainfall_set)
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"""
+ """
+ __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.
+ """
_cmf_core.Rainfall_swiginit(self, _cmf_core.new_Rainfall(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_Rainfall
Rainfall_swigregister = _cmf_core.Rainfall_swigregister
Rainfall_swigregister(Rainfall)
class Snowfall(flux_connection):
- """Proxy of C++ cmf::upslope::connections::Snowfall class."""
+ """
+
+
+ A connection routing snowfall (precipitation below freezing Temp) to
+ the snow pack.
+
+ C++ includes: AtmosphericFluxes.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::connections::Snowfall self, cmf::water::flux_node::ptr target, Cell cell) -> Snowfall"""
+ """
+ __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)
+
+ """
_cmf_core.Snowfall_swiginit(self, _cmf_core.new_Snowfall(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_Snowfall
Snowfall_swigregister = _cmf_core.Snowfall_swigregister
Snowfall_swigregister(Snowfall)
class MatrixInfiltration(flux_connection):
- """Proxy of C++ cmf::upslope::connections::MatrixInfiltration class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::connections::MatrixInfiltration self, cmf::upslope::SoilLayer::ptr soilwater, cmf::water::flux_node::ptr surfacewater) -> MatrixInfiltration"""
+ """
+ __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)
+ """
_cmf_core.MatrixInfiltration_swiginit(self, _cmf_core.new_MatrixInfiltration(*args, **kwargs))
def use_for_cell(*args, **kwargs):
@@ -5892,13 +11591,89 @@ def MatrixInfiltration_use_for_cell(*args, **kwargs):
return _cmf_core.MatrixInfiltration_use_for_cell(*args, **kwargs)
class GreenAmptInfiltration(flux_connection):
- """Proxy of C++ cmf::upslope::connections::GreenAmptInfiltration class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::connections::GreenAmptInfiltration self, cmf::upslope::SoilLayer::ptr soilwater, cmf::water::flux_node::ptr surfacewater) -> GreenAmptInfiltration"""
+ """
+ __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)
+ """
_cmf_core.GreenAmptInfiltration_swiginit(self, _cmf_core.new_GreenAmptInfiltration(*args, **kwargs))
def use_for_cell(*args, **kwargs):
@@ -5915,14 +11690,61 @@ def GreenAmptInfiltration_use_for_cell(*args, **kwargs):
return _cmf_core.GreenAmptInfiltration_use_for_cell(*args, **kwargs)
class SimpleInfiltration(flux_connection):
- """Proxy of C++ cmf::upslope::connections::SimpleInfiltration class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
W0 = _swig_property(_cmf_core.SimpleInfiltration_W0_get, _cmf_core.SimpleInfiltration_W0_set)
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"""
+ """
+ __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
+ """
_cmf_core.SimpleInfiltration_swiginit(self, _cmf_core.new_SimpleInfiltration(*args, **kwargs))
def use_for_cell(*args, **kwargs):
@@ -5939,7 +11761,25 @@ def SimpleInfiltration_use_for_cell(*args, **kwargs):
return _cmf_core.SimpleInfiltration_use_for_cell(*args, **kwargs)
class SWATPercolation(flux_connection):
- """Proxy of C++ cmf::upslope::connections::SWATPercolation class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -5951,7 +11791,12 @@ def use_for_cell(*args, **kwargs):
use_for_cell = staticmethod(use_for_cell)
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::connections::SWATPercolation self, cmf::upslope::SoilLayer::ptr upperLayer, cmf::upslope::SoilLayer::ptr lowerLayer) -> SWATPercolation"""
+ """
+ __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)
+ """
_cmf_core.SWATPercolation_swiginit(self, _cmf_core.new_SWATPercolation(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_SWATPercolation
SWATPercolation_swigregister = _cmf_core.SWATPercolation_swigregister
@@ -5962,13 +11807,51 @@ def SWATPercolation_use_for_cell(*args, **kwargs):
return _cmf_core.SWATPercolation_use_for_cell(*args, **kwargs)
class Richards(flux_connection):
- """Proxy of C++ cmf::upslope::connections::Richards class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::connections::Richards self, cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right) -> Richards"""
+ """
+ __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.
+ """
_cmf_core.Richards_swiginit(self, _cmf_core.new_Richards(*args, **kwargs))
def use_for_cell(*args, **kwargs):
@@ -5985,13 +11868,39 @@ def Richards_use_for_cell(*args, **kwargs):
return _cmf_core.Richards_use_for_cell(*args, **kwargs)
class SimplRichards(flux_connection):
- """Proxy of C++ cmf::upslope::connections::SimplRichards class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::connections::SimplRichards self, cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right) -> SimplRichards"""
+ """
+ __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)
+ """
_cmf_core.SimplRichards_swiginit(self, _cmf_core.new_SimplRichards(*args, **kwargs))
def use_for_cell(*args, **kwargs):
@@ -6007,21 +11916,77 @@ def SimplRichards_use_for_cell(*args, **kwargs):
"""SimplRichards_use_for_cell(Cell cell, bool no_override=True)"""
return _cmf_core.SimplRichards_use_for_cell(*args, **kwargs)
-class FreeDrainagePercolation(flux_connection):
- """Proxy of C++ cmf::upslope::connections::FreeDrainagePercolation class."""
+class FreeDrainagePercolation(flux_connection):
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::connections::FreeDrainagePercolation self, cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right) -> FreeDrainagePercolation"""
+ """
+ __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)
+ """
_cmf_core.FreeDrainagePercolation_swiginit(self, _cmf_core.new_FreeDrainagePercolation(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_FreeDrainagePercolation
FreeDrainagePercolation_swigregister = _cmf_core.FreeDrainagePercolation_swigregister
FreeDrainagePercolation_swigregister(FreeDrainagePercolation)
class LayerBypass(flux_connection):
- """Proxy of C++ cmf::upslope::connections::LayerBypass class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -6030,12 +11995,45 @@ class LayerBypass(flux_connection):
beta = _swig_property(_cmf_core.LayerBypass_beta_get, _cmf_core.LayerBypass_beta_set)
def K(self, *args, **kwargs):
- """K(LayerBypass self, real w) -> real"""
+ """
+ K(LayerBypass self, real w) -> real
+
+ real K(real w)
+
+ the actual crack conductivity
+
+ Parameters:
+ -----------
+
+ w: the wetness of the target layer
+ """
return _cmf_core.LayerBypass_K(self, *args, **kwargs)
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"""
+ """
+ __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
+ """
_cmf_core.LayerBypass_swiginit(self, _cmf_core.new_LayerBypass(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_LayerBypass
LayerBypass.K = new_instancemethod(_cmf_core.LayerBypass_K, None, LayerBypass)
@@ -6043,7 +12041,17 @@ def __init__(self, *args, **kwargs):
LayerBypass_swigregister(LayerBypass)
class RootUptakeStessFunction(object):
- """Proxy of C++ cmf::upslope::ET::RootUptakeStessFunction class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -6052,17 +12060,43 @@ def __init__(self, *args, **kwargs):
__repr__ = _swig_repr
def Tact(self, *args, **kwargs):
- """Tact(RootUptakeStessFunction self, stressedET connection, real Tpot) -> real"""
+ """
+ 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
+ """
return _cmf_core.RootUptakeStessFunction_Tact(self, *args, **kwargs)
def copy(self, *args, **kwargs):
- """copy(RootUptakeStessFunction self) -> RootUptakeStessFunction"""
+ """
+ copy(RootUptakeStessFunction self) -> RootUptakeStessFunction
+
+ virtual cmf::upslope::ET::RootUptakeStessFunction* copy() const =0
+
+ Creates a new copy of this wetness.
+ """
return _cmf_core.RootUptakeStessFunction_copy(self, *args, **kwargs)
def to_string(self, *args, **kwargs):
- """to_string(RootUptakeStessFunction self) -> std::string"""
+ """
+ to_string(RootUptakeStessFunction self) -> std::string
+
+ virtual
+ std::string to_string() const =0
+ """
return _cmf_core.RootUptakeStessFunction_to_string(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_RootUptakeStessFunction
@@ -6073,7 +12107,31 @@ def to_string(self, *args, **kwargs):
RootUptakeStessFunction_swigregister(RootUptakeStessFunction)
class SuctionStress(RootUptakeStessFunction):
- """Proxy of C++ cmf::upslope::ET::SuctionStress class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -6086,11 +12144,19 @@ def __init__(self, *args):
"""
__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)
"""
_cmf_core.SuctionStress_swiginit(self, _cmf_core.new_SuctionStress(*args))
def copy(self, *args, **kwargs):
- """copy(SuctionStress self) -> SuctionStress"""
+ """
+ copy(SuctionStress self) -> SuctionStress
+
+ cmf::upslope::ET::SuctionStress* copy() const
+
+ Creates a new copy of this wetness.
+ """
return _cmf_core.SuctionStress_copy(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_SuctionStress
@@ -6099,7 +12165,29 @@ def copy(self, *args, **kwargs):
SuctionStress_swigregister(SuctionStress)
class ContentStress(RootUptakeStessFunction):
- """Proxy of C++ cmf::upslope::ET::ContentStress class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -6107,12 +12195,25 @@ class ContentStress(RootUptakeStessFunction):
theta_w = _swig_property(_cmf_core.ContentStress_theta_w_get, _cmf_core.ContentStress_theta_w_set)
def copy(self, *args, **kwargs):
- """copy(ContentStress self) -> ContentStress"""
+ """
+ copy(ContentStress self) -> ContentStress
+
+ cmf::upslope::ET::ContentStress* copy() const
+
+ Creates a new copy of this wetness.
+ """
return _cmf_core.ContentStress_copy(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::ET::ContentStress self, real theta_d=-1, real theta_w=-1) -> ContentStress"""
+ """
+ __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.
+ """
_cmf_core.ContentStress_swiginit(self, _cmf_core.new_ContentStress(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_ContentStress
ContentStress.copy = new_instancemethod(_cmf_core.ContentStress_copy, None, ContentStress)
@@ -6120,7 +12221,16 @@ def __init__(self, *args, **kwargs):
ContentStress_swigregister(ContentStress)
class VolumeStress(RootUptakeStessFunction):
- """Proxy of C++ cmf::upslope::ET::VolumeStress class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -6131,11 +12241,19 @@ 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)
"""
_cmf_core.VolumeStress_swiginit(self, _cmf_core.new_VolumeStress(*args))
def copy(self, *args, **kwargs):
- """copy(VolumeStress self) -> VolumeStress"""
+ """
+ copy(VolumeStress self) -> VolumeStress
+
+ cmf::upslope::ET::VolumeStress* copy() const
+
+ Creates a new copy of this wetness.
+ """
return _cmf_core.VolumeStress_copy(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_VolumeStress
@@ -6144,20 +12262,39 @@ def copy(self, *args, **kwargs):
VolumeStress_swigregister(VolumeStress)
class log_wind_profile(aerodynamic_resistance):
- """Proxy of C++ cmf::atmosphere::log_wind_profile class."""
+ """
+
+
+ , A logarithmic wind profile
+
+ Todo Cite literature for this windprofile and insert equation
+
+ C++ includes: ET.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
- """__init__(cmf::atmosphere::log_wind_profile self, Cell _cell) -> log_wind_profile"""
+ """
+ __init__(cmf::atmosphere::log_wind_profile self, Cell _cell) -> log_wind_profile
+
+ log_wind_profile(cmf::upslope::Cell &_cell)
+ """
_cmf_core.log_wind_profile_swiginit(self, _cmf_core.new_log_wind_profile(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_log_wind_profile
log_wind_profile_swigregister = _cmf_core.log_wind_profile_swigregister
log_wind_profile_swigregister(log_wind_profile)
class transpiration_method(object):
- """Proxy of C++ cmf::upslope::ET::transpiration_method class."""
+ """
+
+
+ Abstract class. Child classes are defining a method for transpiration
+ calculation.
+
+ C++ includes: ET.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -6166,7 +12303,15 @@ def __init__(self, *args, **kwargs):
__repr__ = _swig_repr
def transp_from_layer(self, *args, **kwargs):
- """transp_from_layer(transpiration_method self, cmf::upslope::SoilLayer::ptr arg2, Time t) -> double"""
+ """
+ transp_from_layer(transpiration_method self, cmf::upslope::SoilLayer::ptr arg2, Time t) -> double
+
+ virtual
+ double transp_from_layer(cmf::upslope::SoilLayer::ptr, cmf::math::Time
+ t)=0
+
+ returns the transpiration rate from one layer in m3/day
+ """
return _cmf_core.transpiration_method_transp_from_layer(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_transpiration_method
@@ -6175,7 +12320,14 @@ def transp_from_layer(self, *args, **kwargs):
transpiration_method_swigregister(transpiration_method)
class soil_evaporation_method(object):
- """Proxy of C++ cmf::upslope::ET::soil_evaporation_method class."""
+ """
+
+
+ Abstract class. Child classes are defining a method for soil
+ evaporation calculation.
+
+ C++ includes: ET.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -6184,7 +12336,15 @@ def __init__(self, *args, **kwargs):
__repr__ = _swig_repr
def evap_from_layer(self, *args, **kwargs):
- """evap_from_layer(soil_evaporation_method self, cmf::upslope::SoilLayer::ptr arg2, Time t) -> double"""
+ """
+ evap_from_layer(soil_evaporation_method self, cmf::upslope::SoilLayer::ptr arg2, Time t) -> double
+
+ virtual
+ double evap_from_layer(cmf::upslope::SoilLayer::ptr, cmf::math::Time
+ t)=0
+
+ returns the soil evaporation rate from one layer in m3/day
+ """
return _cmf_core.soil_evaporation_method_evap_from_layer(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_soil_evaporation_method
@@ -6193,7 +12353,14 @@ def evap_from_layer(self, *args, **kwargs):
soil_evaporation_method_swigregister(soil_evaporation_method)
class surface_water_evaporation_method(object):
- """Proxy of C++ cmf::upslope::ET::surface_water_evaporation_method class."""
+ """
+
+
+ Abstract class. Child classes are defining a method for surface water
+ evaporation calculation.
+
+ C++ includes: ET.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -6202,7 +12369,13 @@ def __init__(self, *args, **kwargs):
__repr__ = _swig_repr
def evap_from_openwater(self, *args, **kwargs):
- """evap_from_openwater(surface_water_evaporation_method self, cmf::river::OpenWaterStorage::ptr arg2, Time arg3) -> double"""
+ """
+ evap_from_openwater(surface_water_evaporation_method self, cmf::river::OpenWaterStorage::ptr arg2, Time arg3) -> double
+
+ virtual double
+ evap_from_openwater(cmf::river::OpenWaterStorage::ptr,
+ cmf::math::Time)=0
+ """
return _cmf_core.surface_water_evaporation_method_evap_from_openwater(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_surface_water_evaporation_method
@@ -6211,7 +12384,14 @@ def evap_from_openwater(self, *args, **kwargs):
surface_water_evaporation_method_swigregister(surface_water_evaporation_method)
class canopy_evaporation_method(object):
- """Proxy of C++ cmf::upslope::ET::canopy_evaporation_method class."""
+ """
+
+
+ Abstract class. Child classes are defining a method for intercepted
+ canopy water evaporation calculation.
+
+ C++ includes: ET.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -6220,7 +12400,12 @@ def __init__(self, *args, **kwargs):
__repr__ = _swig_repr
def evap_from_canopy(self, *args, **kwargs):
- """evap_from_canopy(canopy_evaporation_method self, cmf::water::WaterStorage::ptr arg2, Time arg3) -> double"""
+ """
+ evap_from_canopy(canopy_evaporation_method self, cmf::water::WaterStorage::ptr arg2, Time arg3) -> double
+
+ virtual double evap_from_canopy(cmf::water::WaterStorage::ptr,
+ cmf::math::Time)=0
+ """
return _cmf_core.canopy_evaporation_method_evap_from_canopy(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_canopy_evaporation_method
@@ -6229,7 +12414,14 @@ def evap_from_canopy(self, *args, **kwargs):
canopy_evaporation_method_swigregister(canopy_evaporation_method)
class snow_evaporation_method(object):
- """Proxy of C++ cmf::upslope::ET::snow_evaporation_method class."""
+ """
+
+
+ Abstract class. Child classes are defining a method for snow
+ evaporation calculation.
+
+ C++ includes: ET.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -6238,7 +12430,13 @@ def __init__(self, *args, **kwargs):
__repr__ = _swig_repr
def evap_from_snow(self, *args, **kwargs):
- """evap_from_snow(snow_evaporation_method self, cmf::water::WaterStorage::ptr snow, Time t) -> double"""
+ """
+ evap_from_snow(snow_evaporation_method self, cmf::water::WaterStorage::ptr snow, Time t) -> double
+
+ virtual
+ double evap_from_snow(cmf::water::WaterStorage::ptr snow,
+ cmf::math::Time t)=0
+ """
return _cmf_core.snow_evaporation_method_evap_from_snow(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_snow_evaporation_method
@@ -6247,65 +12445,126 @@ def evap_from_snow(self, *args, **kwargs):
snow_evaporation_method_swigregister(snow_evaporation_method)
class transpiration(flux_connection):
- """Proxy of C++ cmf::upslope::ET::transpiration class."""
+ """
+
+
+ Flux connection using a transpiration_method.
+
+ C++ includes: ET.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::ET::transpiration self, cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target, std::shared_ptr< cmf::upslope::ET::transpiration_method > _method, std::string method_name) -> transpiration"""
+ """
+ __init__(cmf::upslope::ET::transpiration self, cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target, std::shared_ptr< cmf::upslope::ET::transpiration_method > _method, std::string method_name) -> transpiration
+
+ transpiration(cmf::upslope::SoilLayer::ptr source,
+ cmf::water::flux_node::ptr ET_target, std::shared_ptr<
+ transpiration_method > _method, std::string method_name)
+ """
_cmf_core.transpiration_swiginit(self, _cmf_core.new_transpiration(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_transpiration
transpiration_swigregister = _cmf_core.transpiration_swigregister
transpiration_swigregister(transpiration)
class soil_evaporation(flux_connection):
- """Proxy of C++ cmf::upslope::ET::soil_evaporation class."""
+ """
+
+
+ Flux_connection using a soil_evaporation_method.
+
+ C++ includes: ET.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::ET::soil_evaporation self, cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target, std::shared_ptr< cmf::upslope::ET::soil_evaporation_method > _method, std::string method_name) -> soil_evaporation"""
+ """
+ __init__(cmf::upslope::ET::soil_evaporation self, cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target, std::shared_ptr< cmf::upslope::ET::soil_evaporation_method > _method, std::string method_name) -> soil_evaporation
+
+ soil_evaporation(cmf::upslope::SoilLayer::ptr source,
+ cmf::water::flux_node::ptr ET_target, std::shared_ptr<
+ soil_evaporation_method > _method, std::string method_name)
+ """
_cmf_core.soil_evaporation_swiginit(self, _cmf_core.new_soil_evaporation(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_soil_evaporation
soil_evaporation_swigregister = _cmf_core.soil_evaporation_swigregister
soil_evaporation_swigregister(soil_evaporation)
class canopy_evaporation(flux_connection):
- """Proxy of C++ cmf::upslope::ET::canopy_evaporation class."""
+ """
+
+
+ Flux connection using a canopy_evaporation_method.
+
+ C++ includes: ET.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::ET::canopy_evaporation self, cmf::water::WaterStorage::ptr source, cmf::water::flux_node::ptr ET_target, std::shared_ptr< cmf::upslope::ET::canopy_evaporation_method > _method, std::string method_name) -> canopy_evaporation"""
+ """
+ __init__(cmf::upslope::ET::canopy_evaporation self, cmf::water::WaterStorage::ptr source, cmf::water::flux_node::ptr ET_target, std::shared_ptr< cmf::upslope::ET::canopy_evaporation_method > _method, std::string method_name) -> canopy_evaporation
+
+ canopy_evaporation(cmf::water::WaterStorage::ptr source,
+ cmf::water::flux_node::ptr ET_target, std::shared_ptr<
+ canopy_evaporation_method > _method, std::string method_name)
+ """
_cmf_core.canopy_evaporation_swiginit(self, _cmf_core.new_canopy_evaporation(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_canopy_evaporation
canopy_evaporation_swigregister = _cmf_core.canopy_evaporation_swigregister
canopy_evaporation_swigregister(canopy_evaporation)
class snow_evaporation(flux_connection):
- """Proxy of C++ cmf::upslope::ET::snow_evaporation class."""
+ """
+
+
+ Flux connection using a snow_evaporation_method.
+
+ C++ includes: ET.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::ET::snow_evaporation self, cmf::water::WaterStorage::ptr source, cmf::water::flux_node::ptr ET_target, std::shared_ptr< cmf::upslope::ET::snow_evaporation_method > _method, std::string method_name) -> snow_evaporation"""
+ """
+ __init__(cmf::upslope::ET::snow_evaporation self, cmf::water::WaterStorage::ptr source, cmf::water::flux_node::ptr ET_target, std::shared_ptr< cmf::upslope::ET::snow_evaporation_method > _method, std::string method_name) -> snow_evaporation
+
+ snow_evaporation(cmf::water::WaterStorage::ptr source,
+ cmf::water::flux_node::ptr ET_target, std::shared_ptr<
+ snow_evaporation_method > _method, std::string method_name)
+ """
_cmf_core.snow_evaporation_swiginit(self, _cmf_core.new_snow_evaporation(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_snow_evaporation
snow_evaporation_swigregister = _cmf_core.snow_evaporation_swigregister
snow_evaporation_swigregister(snow_evaporation)
class surface_water_evaporation(flux_connection):
- """Proxy of C++ cmf::upslope::ET::surface_water_evaporation class."""
+ """
+
+
+ Flux connection using an surface_water_evaporation_method.
+
+ C++ includes: ET.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::ET::surface_water_evaporation self, cmf::river::OpenWaterStorage::ptr source, cmf::water::flux_node::ptr ET_target, std::shared_ptr< cmf::upslope::ET::surface_water_evaporation_method > _method, std::string method_name) -> surface_water_evaporation"""
+ """
+ __init__(cmf::upslope::ET::surface_water_evaporation self, cmf::river::OpenWaterStorage::ptr source, cmf::water::flux_node::ptr ET_target, std::shared_ptr< cmf::upslope::ET::surface_water_evaporation_method > _method, std::string method_name) -> surface_water_evaporation
+
+ surface_water_evaporation(cmf::river::OpenWaterStorage::ptr source,
+ cmf::water::flux_node::ptr ET_target, std::shared_ptr<
+ surface_water_evaporation_method > _method, std::string method_name)
+
+ """
_cmf_core.surface_water_evaporation_swiginit(self, _cmf_core.new_surface_water_evaporation(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_surface_water_evaporation
surface_water_evaporation_swigregister = _cmf_core.surface_water_evaporation_swigregister
@@ -6316,10 +12575,34 @@ def PenmanMonteith(*args):
"""
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)
"""
return _cmf_core.PenmanMonteith(*args)
class stressedET(flux_connection):
- """Proxy of C++ cmf::upslope::ET::stressedET class."""
+ """
+
+
+ An abstract base class for ET Methods with a WaterStressFunction.
+
+ C++ includes: ET.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -6328,17 +12611,33 @@ def __init__(self, *args, **kwargs):
__repr__ = _swig_repr
def set_stressfunction(self, *args, **kwargs):
- """set_stressfunction(stressedET self, RootUptakeStessFunction stressfunction)"""
+ """
+ set_stressfunction(stressedET self, RootUptakeStessFunction stressfunction)
+
+ void
+ set_stressfunction(const RootUptakeStessFunction &stressfunction)
+
+ Sets the stress function to limit water uptake.
+ """
return _cmf_core.stressedET_set_stressfunction(self, *args, **kwargs)
def get_layer(self, *args, **kwargs):
- """get_layer(stressedET self) -> cmf::upslope::SoilLayer::ptr"""
+ """
+ get_layer(stressedET self) -> cmf::upslope::SoilLayer::ptr
+
+ SoilLayer::ptr get_layer() const
+ """
return _cmf_core.stressedET_get_layer(self, *args, **kwargs)
def ETpot(self, *args, **kwargs):
- """ETpot(stressedET self, Time t) -> real"""
+ """
+ ETpot(stressedET self, Time t) -> real
+
+ virtual
+ real ETpot(cmf::math::Time t) const
+ """
return _cmf_core.stressedET_ETpot(self, *args, **kwargs)
__swig_destroy__ = _cmf_core.delete_stressedET
@@ -6349,19 +12648,39 @@ def ETpot(self, *args, **kwargs):
stressedET_swigregister(stressedET)
class constantETpot(stressedET):
- """Proxy of C++ cmf::upslope::ET::constantETpot class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
ETpot_value = _swig_property(_cmf_core.constantETpot_ETpot_value_get, _cmf_core.constantETpot_ETpot_value_set)
def GetETpot(self, *args, **kwargs):
- """GetETpot(constantETpot self, Time t) -> real"""
+ """
+ GetETpot(constantETpot self, Time t) -> real
+
+ real GetETpot(cmf::math::Time t) const
+ """
return _cmf_core.constantETpot_GetETpot(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::ET::constantETpot self, cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target, double constantETpot_value) -> constantETpot"""
+ """
+ __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)
+ """
_cmf_core.constantETpot_swiginit(self, _cmf_core.new_constantETpot(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_constantETpot
constantETpot.GetETpot = new_instancemethod(_cmf_core.constantETpot_GetETpot, None, constantETpot)
@@ -6369,28 +12688,96 @@ def __init__(self, *args, **kwargs):
constantETpot_swigregister(constantETpot)
class timeseriesETpot(stressedET):
- """Proxy of C++ cmf::upslope::ET::timeseriesETpot class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
ETpot_data = _swig_property(_cmf_core.timeseriesETpot_ETpot_data_get, _cmf_core.timeseriesETpot_ETpot_data_set)
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"""
+ """
+ __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)
+ """
_cmf_core.timeseriesETpot_swiginit(self, _cmf_core.new_timeseriesETpot(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_timeseriesETpot
timeseriesETpot_swigregister = _cmf_core.timeseriesETpot_swigregister
timeseriesETpot_swigregister(timeseriesETpot)
class PenmanMonteithET(stressedET):
- """Proxy of C++ cmf::upslope::ET::PenmanMonteithET class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
daily = _swig_property(_cmf_core.PenmanMonteithET_daily_get, _cmf_core.PenmanMonteithET_daily_set)
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::ET::PenmanMonteithET self, cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target) -> PenmanMonteithET"""
+ """
+ __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)
+ """
_cmf_core.PenmanMonteithET_swiginit(self, _cmf_core.new_PenmanMonteithET(*args, **kwargs))
def r_s(*args, **kwargs):
@@ -6426,8 +12813,35 @@ def PenmanMonteithET_use_for_cell(*args, **kwargs):
"""PenmanMonteithET_use_for_cell(Cell cell)"""
return _cmf_core.PenmanMonteithET_use_for_cell(*args, **kwargs)
-class PriestleyTaylorET(stressedET):
- """Proxy of C++ cmf::upslope::ET::PriestleyTaylorET class."""
+class PriestleyTaylorET(stressedET):
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -6435,7 +12849,12 @@ class PriestleyTaylorET(stressedET):
alpha = _swig_property(_cmf_core.PriestleyTaylorET_alpha_get, _cmf_core.PriestleyTaylorET_alpha_set)
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"""
+ """
+ __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)
+ """
_cmf_core.PriestleyTaylorET_swiginit(self, _cmf_core.new_PriestleyTaylorET(*args, **kwargs))
def use_for_cell(*args, **kwargs):
@@ -6452,13 +12871,60 @@ def PriestleyTaylorET_use_for_cell(*args, **kwargs):
return _cmf_core.PriestleyTaylorET_use_for_cell(*args, **kwargs)
class HargreaveET(stressedET):
- """Proxy of C++ cmf::upslope::ET::HargreaveET class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
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"""
+ """
+ __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)
+ """
_cmf_core.HargreaveET_swiginit(self, _cmf_core.new_HargreaveET(*args, **kwargs))
lat = _swig_property(_cmf_core.HargreaveET_lat_get, _cmf_core.HargreaveET_lat_set)
@@ -6476,13 +12942,28 @@ def HargreaveET_use_for_cell(*args, **kwargs):
return _cmf_core.HargreaveET_use_for_cell(*args, **kwargs)
class TurcET(stressedET):
- """Proxy of C++ cmf::upslope::ET::TurcET class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::ET::TurcET self, cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target) -> TurcET"""
+ """
+ __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)
+ """
_cmf_core.TurcET_swiginit(self, _cmf_core.new_TurcET(*args, **kwargs))
def use_for_cell(*args, **kwargs):
@@ -6499,33 +12980,98 @@ def TurcET_use_for_cell(*args, **kwargs):
return _cmf_core.TurcET_use_for_cell(*args, **kwargs)
class CanopyStorageEvaporation(flux_connection):
- """Proxy of C++ cmf::upslope::ET::CanopyStorageEvaporation class."""
+ """
+
+
+ Calculates the evaporation from a canopy storage.
+
+ C++ includes: ET.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
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"""
+ """
+ __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)
+ """
_cmf_core.CanopyStorageEvaporation_swiginit(self, _cmf_core.new_CanopyStorageEvaporation(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_CanopyStorageEvaporation
CanopyStorageEvaporation_swigregister = _cmf_core.CanopyStorageEvaporation_swigregister
CanopyStorageEvaporation_swigregister(CanopyStorageEvaporation)
class PenmanEvaporation(flux_connection):
- """Proxy of C++ cmf::upslope::ET::PenmanEvaporation class."""
+ """
+
+
+ Calculates evaporation from an open water body.
+
+ C++ includes: ET.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
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"""
+ """
+ __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)
+ """
_cmf_core.PenmanEvaporation_swiginit(self, _cmf_core.new_PenmanEvaporation(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_PenmanEvaporation
PenmanEvaporation_swigregister = _cmf_core.PenmanEvaporation_swigregister
PenmanEvaporation_swigregister(PenmanEvaporation)
class ShuttleworthWallace(transpiration_method, soil_evaporation_method, surface_water_evaporation_method, canopy_evaporation_method, snow_evaporation_method, aerodynamic_resistance):
- """Proxy of C++ cmf::upslope::ET::ShuttleworthWallace class."""
+ """
+
+
+ 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}}`
+
+ 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 in
+ the ground
+
+ :math:`R_{n_canopy} = R_n - R_{n,ground}`, the net radiation flux in the
+ canopy
+
+ :math:`\\lambda,c_p\\rho,\\gamma,C_R` constants lambda, c_p_rho,
+ gamma, C_R
+
+ :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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
@@ -6540,6 +13086,8 @@ def refresh(self, *args):
"""
refresh(ShuttleworthWallace self, Time t)
refresh(ShuttleworthWallace self)
+
+ void refresh()
"""
return _cmf_core.ShuttleworthWallace_refresh(self, *args)
@@ -6562,7 +13110,14 @@ def set_RSS_parameters(*args, **kwargs):
set_RSS_parameters = staticmethod(set_RSS_parameters)
def __init__(self, *args, **kwargs):
- """__init__(cmf::upslope::ET::ShuttleworthWallace self, Cell cell, bool allow_dew=True) -> ShuttleworthWallace"""
+ """
+ __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.
+ """
_cmf_core.ShuttleworthWallace_swiginit(self, _cmf_core.new_ShuttleworthWallace(*args, **kwargs))
def use_for_cell(*args, **kwargs):
@@ -6607,13 +13162,33 @@ def __repr__(self):
class project(StateVariableOwner):
- """Proxy of C++ cmf::project class."""
+ """
+
+
+ The study area, holding all cells, outlets and streams.
+
+ Todo Describe tracers
+
+ C++ includes: project.h
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def remove_node(self, *args, **kwargs):
- """remove_node(project self, cmf::water::flux_node::ptr node) -> size_t"""
+ """
+ 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.
+ """
return _cmf_core.project_remove_node(self, *args, **kwargs)
solutes = _swig_property(_cmf_core.project_solutes_get)
@@ -6621,92 +13196,428 @@ def remove_node(self, *args, **kwargs):
rainfall_stations = _swig_property(_cmf_core.project_rainfall_stations_get, _cmf_core.project_rainfall_stations_set)
def use_IDW_meteo(self, *args, **kwargs):
- """use_IDW_meteo(project self, double z_weight=0, double power=2)"""
+ """
+ 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
+ """
return _cmf_core.project_use_IDW_meteo(self, *args, **kwargs)
def use_nearest_meteo(self, *args, **kwargs):
- """use_nearest_meteo(project self, double z_weight=0)"""
+ """
+ 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
+ """
return _cmf_core.project_use_nearest_meteo(self, *args, **kwargs)
def use_IDW_rainfall(self, *args, **kwargs):
- """use_IDW_rainfall(project self, double z_weight=0, double power=2)"""
+ """
+ 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
+ """
return _cmf_core.project_use_IDW_rainfall(self, *args, **kwargs)
def use_nearest_rainfall(self, *args, **kwargs):
- """use_nearest_rainfall(project self, double z_weight=0)"""
+ """
+ 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
+ """
return _cmf_core.project_use_nearest_rainfall(self, *args, **kwargs)
def get_cell(self, *args, **kwargs):
- """get_cell(project self, ptrdiff_t index) -> Cell"""
+ """
+ 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.
+ """
return _cmf_core.project_get_cell(self, *args, **kwargs)
def size(self, *args, **kwargs):
- """size(project self) -> size_t"""
+ """
+ size(project self) -> size_t
+
+ size_t size() const
+
+ The number of cells in the project.
+ """
return _cmf_core.project_size(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
- """__init__(cmf::project self, std::string solute_names) -> project"""
+ """
+ __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.
+ """
_cmf_core.project_swiginit(self, _cmf_core.new_project(*args, **kwargs))
__swig_destroy__ = _cmf_core.delete_project
def NewCell(self, *args, **kwargs):
- """NewCell(project self, double x, double y, double z, double area, bool with_surfacewater=False) -> Cell"""
+ """
+ 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
+ """
return _cmf_core.project_NewCell(self, *args, **kwargs)
def NewOutlet(self, *args, **kwargs):
- """NewOutlet(project self, std::string name, double x=0, double y=0, double z=0) -> cmf::water::DirichletBoundary::ptr"""
+ """
+ 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
+
+ """
return _cmf_core.project_NewOutlet(self, *args, **kwargs)
def NewStorage(self, *args, **kwargs):
- """NewStorage(project self, std::string name, double x=0, double y=0, double z=0) -> cmf::water::WaterStorage::ptr"""
+ """
+ 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
+ """
return _cmf_core.project_NewStorage(self, *args, **kwargs)
def NewOpenStorage(self, *args, **kwargs):
- """NewOpenStorage(project self, std::string name, double x, double y, double z, double area) -> cmf::river::OpenWaterStorage::ptr"""
+ """
+ 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
+ """
return _cmf_core.project_NewOpenStorage(self, *args, **kwargs)
def NewNeumannBoundary(self, *args, **kwargs):
- """NewNeumannBoundary(project self, std::string name, cmf::water::WaterStorage::ptr target) -> cmf::water::NeumannBoundary::ptr"""
+ """
+ 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
+ """
return _cmf_core.project_NewNeumannBoundary(self, *args, **kwargs)
def NewReach(self, *args, **kwargs):
- """NewReach(project self, double x, double y, double z, IChannel shape, bool diffusive=False) -> cmf::river::Reach::ptr"""
+ """
+ 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
+ """
return _cmf_core.project_NewReach(self, *args, **kwargs)
def get_reach(self, *args, **kwargs):
- """get_reach(project self, ptrdiff_t index) -> cmf::river::Reach::ptr"""
+ """
+ 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.
+ """
return _cmf_core.project_get_reach(self, *args, **kwargs)
def reach_count(self, *args, **kwargs):
- """reach_count(project self) -> size_t"""
+ """
+ reach_count(project self) -> size_t
+
+ size_t
+ reach_count() const
+
+ Returns the number of reaches in this project.
+ """
return _cmf_core.project_reach_count(self, *args, **kwargs)
def get_node(self, *args, **kwargs):
- """get_node(project self, ptrdiff_t index) -> cmf::water::flux_node::ptr"""
+ """
+ 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.
+ """
return _cmf_core.project_get_node(self, *args, **kwargs)
def node_count(self, *args, **kwargs):
- """node_count(project self) -> size_t"""
+ """
+ node_count(project self) -> size_t
+
+ size_t node_count()
+ const
+
+ Returns the number of nodes saved with this project.
+ """
return _cmf_core.project_node_count(self, *args, **kwargs)
def get_storages(self, *args, **kwargs):
- """get_storages(project self) -> node_list"""
+ """
+ get_storages(project self) -> node_list
+
+ cmf::water::node_list get_storages()
+
+ Returns a list of all storages of this project.
+ """
return _cmf_core.project_get_storages(self, *args, **kwargs)
cells = _swig_property(_cmf_core.project_cells_get)
@@ -6754,13 +13665,29 @@ def nodes(self):
project_swigregister(project)
class SoluteWaterIntegrator(Integrator):
- """Proxy of C++ cmf::math::SoluteWaterIntegrator class."""
+ """
+
+
+ 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
+ """
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def copy(self, *args, **kwargs):
- """copy(SoluteWaterIntegrator self) -> SoluteWaterIntegrator"""
+ """
+ copy(SoluteWaterIntegrator self) -> SoluteWaterIntegrator
+
+ virtual cmf::math::SoluteWaterIntegrator* copy() const
+
+ Polymorphic copy constructor.
+ """
return _cmf_core.SoluteWaterIntegrator_copy(self, *args, **kwargs)
@@ -6768,12 +13695,35 @@ def __init__(self, *args):
"""
__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
"""
_cmf_core.SoluteWaterIntegrator_swiginit(self, _cmf_core.new_SoluteWaterIntegrator(*args))
__swig_destroy__ = _cmf_core.delete_SoluteWaterIntegrator
def to_string(self, *args, **kwargs):
- """to_string(SoluteWaterIntegrator self) -> std::string"""
+ """
+ to_string(SoluteWaterIntegrator self) -> std::string
+
+ std::string to_string() const
+ """
return _cmf_core.SoluteWaterIntegrator_to_string(self, *args, **kwargs)
SoluteWaterIntegrator.copy = new_instancemethod(_cmf_core.SoluteWaterIntegrator_copy, None, SoluteWaterIntegrator)
diff --git a/cmf/cmf_core_src/cmf.vcxproj b/cmf/cmf_core_src/cmf.vcxproj
index 9744e795..46218eed 100644
--- a/cmf/cmf_core_src/cmf.vcxproj
+++ b/cmf/cmf_core_src/cmf.vcxproj
@@ -138,7 +138,7 @@
Disabled
- $(SolutionDir)math\integrators\sundials_cvode\include;$(BOOSTDIR)\boost\tr1;$(BOOSTDIR);%(AdditionalIncludeDirectories)
+ $(SolutionDir)math\integrators\sundials_cvode\include;$(BOOSTDIR)\boost\tr1;$(BOOSTDIR);C:\Apps\WinPython-64bit-3.6.1.0Qt5\python-3.6.1.amd64\include;%(AdditionalIncludeDirectories)
WIN32;_DEBUG;_WINDOWS;CMF_EXPORTS;%(PreprocessorDefinitions)
true
EnableFastChecks
@@ -456,7 +456,6 @@
-
diff --git a/cmf/cmf_core_src/cmf_wrap.cpp b/cmf/cmf_core_src/cmf_wrap.cpp
index b656197d..9b5517fe 100644
--- a/cmf/cmf_core_src/cmf_wrap.cpp
+++ b/cmf/cmf_core_src/cmf_wrap.cpp
@@ -29359,20 +29359,24 @@ SWIGINTERN PyObject *_wrap_new_WaterStorage(PyObject *SWIGUNUSEDPARM(self), PyOb
std::string const &arg2_defvalue = "" ;
std::string *arg2 = (std::string *) &arg2_defvalue ;
double arg3 = (double) 0 ;
+ double arg4 = (double) 1 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 = SWIG_OLDOBJ ;
double val3 ;
int ecode3 = 0 ;
+ double val4 ;
+ int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
+ PyObject * obj3 = 0 ;
char * kwnames[] = {
- (char *) "project",(char *) "Name",(char *) "InitialState", NULL
+ (char *) "project",(char *) "Name",(char *) "InitialState",(char *) "scale", NULL
};
cmf::water::WaterStorage *result = 0 ;
- if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_WaterStorage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_WaterStorage",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cmf__project, 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WaterStorage" "', argument " "1"" of type '" "cmf::project &""'");
@@ -29401,9 +29405,16 @@ SWIGINTERN PyObject *_wrap_new_WaterStorage(PyObject *SWIGUNUSEDPARM(self), PyOb
}
arg3 = static_cast< double >(val3);
}
+ if (obj3) {
+ ecode4 = SWIG_AsVal_double(obj3, &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_WaterStorage" "', argument " "4"" of type '" "double""'");
+ }
+ arg4 = static_cast< double >(val4);
+ }
{
try {
- result = (cmf::water::WaterStorage *)new cmf::water::WaterStorage(*arg1,(std::string const &)*arg2,arg3);
+ result = (cmf::water::WaterStorage *)new cmf::water::WaterStorage(*arg1,(std::string const &)*arg2,arg3,arg4);
} catch (const std::out_of_range& e) {
SWIG_exception(SWIG_IndexError, e.what());
} catch (const std::exception& e) {
@@ -30014,18 +30025,22 @@ SWIGINTERN PyObject *_wrap_WaterStorage_create(PyObject *SWIGUNUSEDPARM(self), P
PyObject *resultobj = 0;
cmf::project *arg1 = 0 ;
real arg2 = (real) 0.0 ;
+ real arg3 = (real) 1.0 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
+ PyObject * obj2 = 0 ;
char * kwnames[] = {
- (char *) "_project",(char *) "initial_state", NULL
+ (char *) "_project",(char *) "initial_state",(char *) "scale", NULL
};
std::shared_ptr< cmf::water::WaterStorage > result;
- if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:WaterStorage_create",kwnames,&obj0,&obj1)) SWIG_fail;
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:WaterStorage_create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_cmf__project, 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WaterStorage_create" "', argument " "1"" of type '" "cmf::project &""'");
@@ -30041,9 +30056,16 @@ SWIGINTERN PyObject *_wrap_WaterStorage_create(PyObject *SWIGUNUSEDPARM(self), P
}
arg2 = static_cast< real >(val2);
}
+ if (obj2) {
+ ecode3 = SWIG_AsVal_double(obj2, &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "WaterStorage_create" "', argument " "3"" of type '" "real""'");
+ }
+ arg3 = static_cast< real >(val3);
+ }
{
try {
- result = cmf::water::WaterStorage::create(*arg1,arg2);
+ result = cmf::water::WaterStorage::create(*arg1,arg2,arg3);
} catch (const std::out_of_range& e) {
SWIG_exception(SWIG_IndexError, e.what());
} catch (const std::exception& e) {
@@ -74573,11 +74595,42 @@ SWIGINTERN PyObject *SoluteWaterIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(sel
static PyMethodDef SwigMethods[] = {
{ (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
- { (char *)"get_parallel_threads", (PyCFunction)_wrap_get_parallel_threads, METH_NOARGS, (char *)"get_parallel_threads() -> int"},
- { (char *)"set_parallel_threads", (PyCFunction) _wrap_set_parallel_threads, METH_VARARGS | METH_KEYWORDS, (char *)"set_parallel_threads(int numthreads) -> int"},
- { (char *)"new_cubicspline", (PyCFunction) _wrap_new_cubicspline, METH_VARARGS | METH_KEYWORDS, (char *)"new_cubicspline(cmf::math::num_array const & x, cmf::math::num_array const & y) -> cubicspline"},
- { (char *)"cubicspline_generate", (PyCFunction)_wrap_cubicspline_generate, METH_O, (char *)"cubicspline_generate(cubicspline self)"},
- { (char *)"cubicspline_size", (PyCFunction)_wrap_cubicspline_size, METH_O, (char *)"cubicspline_size(cubicspline self) -> size_t"},
+ { (char *)"get_parallel_threads", (PyCFunction)_wrap_get_parallel_threads, METH_NOARGS, (char *)"\n"
+ "get_parallel_threads() -> int\n"
+ "\n"
+ "int\n"
+ "cmf::math::get_parallel_threads()\n"
+ "\n"
+ "Returns the max number of threads used by OpenMP in parallel sections\n"
+ "of the code. \n"
+ ""},
+ { (char *)"set_parallel_threads", (PyCFunction) _wrap_set_parallel_threads, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "set_parallel_threads(int numthreads) -> int\n"
+ "\n"
+ "int\n"
+ "cmf::math::set_parallel_threads(int numthreads)\n"
+ "\n"
+ "Set the number of threads used by OpenMP in parallel sections of the\n"
+ "code. \n"
+ ""},
+ { (char *)"new_cubicspline", (PyCFunction) _wrap_new_cubicspline, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_cubicspline(cmf::math::num_array const & x, cmf::math::num_array const & y) -> cubicspline\n"
+ "\n"
+ "cubicspline(const cmf::math::num_array &x, const cmf::math::num_array\n"
+ "&y) \n"
+ ""},
+ { (char *)"cubicspline_generate", (PyCFunction)_wrap_cubicspline_generate, METH_O, (char *)"\n"
+ "cubicspline_generate(cubicspline self)\n"
+ "\n"
+ "void\n"
+ "generate() \n"
+ ""},
+ { (char *)"cubicspline_size", (PyCFunction)_wrap_cubicspline_size, METH_O, (char *)"\n"
+ "cubicspline_size(cubicspline self) -> size_t\n"
+ "\n"
+ "size_t size()\n"
+ "const \n"
+ ""},
{ (char *)"cubicspline___call__", (PyCFunction) _wrap_cubicspline___call__, METH_VARARGS | METH_KEYWORDS, (char *)"cubicspline___call__(cubicspline self, real x) -> real"},
{ (char *)"delete_cubicspline", (PyCFunction)_wrap_delete_cubicspline, METH_O, (char *)"delete_cubicspline(cubicspline self)"},
{ (char *)"cubicspline_swigregister", cubicspline_swigregister, METH_VARARGS, NULL},
@@ -74592,16 +74645,81 @@ static PyMethodDef SwigMethods[] = {
"point()\n"
"point(point p)\n"
"new_point(double x_, double y_, double z_=0.0) -> point\n"
+ "\n"
+ "point(double x_,\n"
+ "double y_, double z_=0.0)\n"
+ "\n"
+ "Creates a point from two doubles. \n"
+ ""},
+ { (char *)"point_distanceTo", (PyCFunction) _wrap_point_distanceTo, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "point_distanceTo(point self, point p) -> double\n"
+ "\n"
+ "double\n"
+ "distanceTo(point p) const\n"
+ "\n"
+ "Returns the horizontal euclidian distance to another point p.\n"
+ "\n"
+ ":math:`\\\\sqrt{(this.x-p.x)^2+(this.y-p.y)^2}` \n"
+ ""},
+ { (char *)"point_z_weight_distance", (PyCFunction) _wrap_point_z_weight_distance, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "point_z_weight_distance(point self, point p, double z_weight) -> double\n"
+ "\n"
+ "double z_weight_distance(point p, double z_weight) const\n"
+ "\n"
+ "Returns the horizontal euclidian distance plus the absolute of the\n"
+ "height difference times a factor.\n"
+ "\n"
+ ":math:`\\\\sqrt{(this.x-p.x)^2+(this.y-p.y)^2}\\\\ +\\\\ w_{z}|this.z-p.z|`\n"
+ "\n"
+ ""},
+ { (char *)"point_distance3DTo", (PyCFunction) _wrap_point_distance3DTo, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "point_distance3DTo(point self, point p) -> double\n"
+ "\n"
+ "double\n"
+ "distance3DTo(point p) const\n"
+ "\n"
+ "Returns the euclidian distance in space to another point p. \n"
""},
- { (char *)"point_distanceTo", (PyCFunction) _wrap_point_distanceTo, METH_VARARGS | METH_KEYWORDS, (char *)"point_distanceTo(point self, point p) -> double"},
- { (char *)"point_z_weight_distance", (PyCFunction) _wrap_point_z_weight_distance, METH_VARARGS | METH_KEYWORDS, (char *)"point_z_weight_distance(point self, point p, double z_weight) -> double"},
- { (char *)"point_distance3DTo", (PyCFunction) _wrap_point_distance3DTo, METH_VARARGS | METH_KEYWORDS, (char *)"point_distance3DTo(point self, point p) -> double"},
{ (char *)"point_distance", (PyCFunction) _wrap_point_distance, METH_VARARGS | METH_KEYWORDS, (char *)"point_distance(point p1, point p2) -> double"},
- { (char *)"point_distance_max", (PyCFunction) _wrap_point_distance_max, METH_VARARGS | METH_KEYWORDS, (char *)"point_distance_max(point self, point p) -> double"},
- { (char *)"point_azimuth", (PyCFunction) _wrap_point_azimuth, METH_VARARGS | METH_KEYWORDS, (char *)"point_azimuth(point self, point p) -> double"},
- { (char *)"point_angleToXAxis", (PyCFunction) _wrap_point_angleToXAxis, METH_VARARGS | METH_KEYWORDS, (char *)"point_angleToXAxis(point self, point p) -> double"},
- { (char *)"point_sum", (PyCFunction)_wrap_point_sum, METH_O, (char *)"point_sum(point self) -> double"},
- { (char *)"point_length", (PyCFunction)_wrap_point_length, METH_O, (char *)"point_length(point self) -> double"},
+ { (char *)"point_distance_max", (PyCFunction) _wrap_point_distance_max, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "point_distance_max(point self, point p) -> double\n"
+ "\n"
+ "double\n"
+ "distance_max(point p) const\n"
+ "\n"
+ "Returns the distance by the maximum orthogonal offset. \n"
+ ""},
+ { (char *)"point_azimuth", (PyCFunction) _wrap_point_azimuth, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "point_azimuth(point self, point p) -> double\n"
+ "\n"
+ "double\n"
+ "azimuth(point p) const\n"
+ "\n"
+ "Returns the azimuth angle of the line :math:`\\\\overline{this,p}` to the\n"
+ "Azimuth in degrees. \n"
+ ""},
+ { (char *)"point_angleToXAxis", (PyCFunction) _wrap_point_angleToXAxis, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "point_angleToXAxis(point self, point p) -> double\n"
+ "\n"
+ "double\n"
+ "angleToXAxis(point p) const\n"
+ "\n"
+ "Returns the angle between the line :math:`\\\\overline{this,p}` to the\n"
+ "x-Axis in degrees. \n"
+ ""},
+ { (char *)"point_sum", (PyCFunction)_wrap_point_sum, METH_O, (char *)"\n"
+ "point_sum(point self) -> double\n"
+ "\n"
+ "double sum() const\n"
+ "\n"
+ "Returns x+y+z. \n"
+ ""},
+ { (char *)"point_length", (PyCFunction)_wrap_point_length, METH_O, (char *)"\n"
+ "point_length(point self) -> double\n"
+ "\n"
+ "double length()\n"
+ "const \n"
+ ""},
{ (char *)"point___add__", (PyCFunction) _wrap_point___add__, METH_VARARGS | METH_KEYWORDS, (char *)"point___add__(point self, point p) -> point"},
{ (char *)"point___iadd__", (PyCFunction) _wrap_point___iadd__, METH_VARARGS | METH_KEYWORDS, (char *)"point___iadd__(point self, point left) -> point"},
{ (char *)"point___sub__", (PyCFunction) _wrap_point___sub__, METH_VARARGS | METH_KEYWORDS, (char *)"point___sub__(point self, point p) -> point"},
@@ -74630,46 +74748,195 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"delete_point", (PyCFunction)_wrap_delete_point, METH_O, (char *)"delete_point(point self)"},
{ (char *)"point_swigregister", point_swigregister, METH_VARARGS, NULL},
{ (char *)"point_swiginit", point_swiginit, METH_VARARGS, NULL},
- { (char *)"dot", (PyCFunction) _wrap_dot, METH_VARARGS | METH_KEYWORDS, (char *)"dot(point p1, point p2) -> double"},
- { (char *)"distance", (PyCFunction) _wrap_distance, METH_VARARGS | METH_KEYWORDS, (char *)"distance(point p1, point p2) -> double"},
+ { (char *)"dot", (PyCFunction) _wrap_dot, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "dot(point p1, point p2) -> double\n"
+ "\n"
+ "double\n"
+ "cmf::geometry::dot(const point &p1, const point &p2) \n"
+ ""},
+ { (char *)"distance", (PyCFunction) _wrap_distance, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "distance(point p1, point p2) -> double\n"
+ "\n"
+ "double\n"
+ "cmf::geometry::distance(const point &p1, const point &p2) \n"
+ ""},
{ (char *)"point_vector_X_set", _wrap_point_vector_X_set, METH_VARARGS, (char *)"point_vector_X_set(point_vector self, cmf::math::num_array X)"},
{ (char *)"point_vector_X_get", (PyCFunction)_wrap_point_vector_X_get, METH_O, (char *)"point_vector_X_get(point_vector self) -> cmf::math::num_array"},
{ (char *)"point_vector_Y_set", _wrap_point_vector_Y_set, METH_VARARGS, (char *)"point_vector_Y_set(point_vector self, cmf::math::num_array Y)"},
{ (char *)"point_vector_Y_get", (PyCFunction)_wrap_point_vector_Y_get, METH_O, (char *)"point_vector_Y_get(point_vector self) -> cmf::math::num_array"},
{ (char *)"point_vector_Z_set", _wrap_point_vector_Z_set, METH_VARARGS, (char *)"point_vector_Z_set(point_vector self, cmf::math::num_array Z)"},
{ (char *)"point_vector_Z_get", (PyCFunction)_wrap_point_vector_Z_get, METH_O, (char *)"point_vector_Z_get(point_vector self) -> cmf::math::num_array"},
- { (char *)"new_point_vector", (PyCFunction) _wrap_new_point_vector, METH_VARARGS | METH_KEYWORDS, (char *)"new_point_vector(ptrdiff_t size) -> point_vector"},
- { (char *)"point_vector_get", (PyCFunction) _wrap_point_vector_get, METH_VARARGS | METH_KEYWORDS, (char *)"point_vector_get(point_vector self, ptrdiff_t index) -> point"},
- { (char *)"point_vector_set", (PyCFunction) _wrap_point_vector_set, METH_VARARGS | METH_KEYWORDS, (char *)"point_vector_set(point_vector self, ptrdiff_t index, point p)"},
- { (char *)"point_vector_size", (PyCFunction)_wrap_point_vector_size, METH_O, (char *)"point_vector_size(point_vector self) -> size_t"},
+ { (char *)"new_point_vector", (PyCFunction) _wrap_new_point_vector, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_point_vector(ptrdiff_t size) -> point_vector\n"
+ "\n"
+ "point_vector(ptrdiff_t size)\n"
+ "\n"
+ "Create a point vector of a specific size. \n"
+ ""},
+ { (char *)"point_vector_get", (PyCFunction) _wrap_point_vector_get, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "point_vector_get(point_vector self, ptrdiff_t index) -> point\n"
+ "\n"
+ "point\n"
+ "get(ptrdiff_t index) const\n"
+ "\n"
+ "Return a point at index. \n"
+ ""},
+ { (char *)"point_vector_set", (PyCFunction) _wrap_point_vector_set, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "point_vector_set(point_vector self, ptrdiff_t index, point p)\n"
+ "\n"
+ "void\n"
+ "set(ptrdiff_t index, cmf::geometry::point p)\n"
+ "\n"
+ "Change the point at index. \n"
+ ""},
+ { (char *)"point_vector_size", (PyCFunction)_wrap_point_vector_size, METH_O, (char *)"\n"
+ "point_vector_size(point_vector self) -> size_t\n"
+ "\n"
+ "size_t\n"
+ "size() const\n"
+ "\n"
+ "Return the number of points in the point_vector. \n"
+ ""},
{ (char *)"delete_point_vector", (PyCFunction)_wrap_delete_point_vector, METH_O, (char *)"delete_point_vector(point_vector self)"},
{ (char *)"point_vector_swigregister", point_vector_swigregister, METH_VARARGS, NULL},
{ (char *)"point_vector_swiginit", point_vector_swiginit, METH_VARARGS, NULL},
- { (char *)"minimum", (PyCFunction) _wrap_minimum, METH_VARARGS | METH_KEYWORDS, (char *)"minimum(real a, real b) -> real"},
- { (char *)"maximum", (PyCFunction) _wrap_maximum, METH_VARARGS | METH_KEYWORDS, (char *)"maximum(real a, real b) -> real"},
- { (char *)"minmax", (PyCFunction) _wrap_minmax, METH_VARARGS | METH_KEYWORDS, (char *)"minmax(real x, real min, real max) -> real"},
- { (char *)"mean", (PyCFunction) _wrap_mean, METH_VARARGS | METH_KEYWORDS, (char *)"mean(real a, real b) -> real"},
- { (char *)"geo_mean", (PyCFunction) _wrap_geo_mean, METH_VARARGS | METH_KEYWORDS, (char *)"geo_mean(real a, real b) -> real"},
- { (char *)"harmonic_mean", (PyCFunction) _wrap_harmonic_mean, METH_VARARGS | METH_KEYWORDS, (char *)"harmonic_mean(real a, real b) -> real"},
- { (char *)"piecewise_linear", (PyCFunction) _wrap_piecewise_linear, METH_VARARGS | METH_KEYWORDS, (char *)"piecewise_linear(real x, real xmin, real xmax, real ymin=0, real ymax=1) -> real"},
- { (char *)"boltzmann", (PyCFunction) _wrap_boltzmann, METH_VARARGS | METH_KEYWORDS, (char *)"boltzmann(real x, real x_half, real tau) -> real"},
- { (char *)"sign", (PyCFunction) _wrap_sign, METH_VARARGS | METH_KEYWORDS, (char *)"sign(real x) -> real"},
- { (char *)"square", (PyCFunction) _wrap_square, METH_VARARGS | METH_KEYWORDS, (char *)"square(real x) -> real"},
+ { (char *)"minimum", (PyCFunction) _wrap_minimum, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "minimum(real a, real b) -> real\n"
+ "\n"
+ "real minimum(real a, real b)\n"
+ "\n"
+ "Returns the minimum of two values. \n"
+ ""},
+ { (char *)"maximum", (PyCFunction) _wrap_maximum, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "maximum(real a, real b) -> real\n"
+ "\n"
+ "real maximum(real a, real b) \n"
+ ""},
+ { (char *)"minmax", (PyCFunction) _wrap_minmax, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "minmax(real x, real min, real max) -> real\n"
+ "\n"
+ "real minmax(real x, real min, real\n"
+ "max) \n"
+ ""},
+ { (char *)"mean", (PyCFunction) _wrap_mean, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "mean(real a, real b) -> real\n"
+ "\n"
+ "real mean(real a, real b) \n"
+ ""},
+ { (char *)"geo_mean", (PyCFunction) _wrap_geo_mean, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "geo_mean(real a, real b) -> real\n"
+ "\n"
+ "real geo_mean(real a, real b) \n"
+ ""},
+ { (char *)"harmonic_mean", (PyCFunction) _wrap_harmonic_mean, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "harmonic_mean(real a, real b) -> real\n"
+ "\n"
+ "real harmonic_mean(real a, real\n"
+ "b) \n"
+ ""},
+ { (char *)"piecewise_linear", (PyCFunction) _wrap_piecewise_linear, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "piecewise_linear(real x, real xmin, real xmax, real ymin=0, real ymax=1) -> real\n"
+ "\n"
+ "real piecewise_linear(real\n"
+ "x, real xmin, real xmax, real ymin=0, real ymax=1) \n"
+ ""},
+ { (char *)"boltzmann", (PyCFunction) _wrap_boltzmann, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "boltzmann(real x, real x_half, real tau) -> real\n"
+ "\n"
+ "real boltzmann(real x, real x_half,\n"
+ "real tau)\n"
+ "\n"
+ "The boltzmann function, used in cmf at several places where a s-shaped\n"
+ "curve is needed.\n"
+ "\n"
+ "\n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " f(x,x_{1/2},\\\\tau)=\\\\frac{1}{1+e^{-\\\\frac{x-x_{1/2}}{tau}}}\n"
+ "\n"
+ "\n"
+ ""},
+ { (char *)"sign", (PyCFunction) _wrap_sign, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "sign(real x) -> real\n"
+ "\n"
+ "real sign(real x) \n"
+ ""},
+ { (char *)"square", (PyCFunction) _wrap_square, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "square(real x) -> real\n"
+ "\n"
+ "real square(real x) \n"
+ ""},
{ (char *)"new_Time", _wrap_new_Time, METH_VARARGS, (char *)"\n"
"Time(int day, int month, int year, int hour=0, int minute=0, int second=0, int ms=0)\n"
"Time(Date date)\n"
"Time(Time t)\n"
"new_Time() -> Time\n"
+ "\n"
+ "Time(long long ms) \n"
+ ""},
+ { (char *)"Time_AsDays", (PyCFunction)_wrap_Time_AsDays, METH_O, (char *)"\n"
+ "Time_AsDays(Time self) -> double\n"
+ "\n"
+ "double AsDays() const\n"
+ "\n"
+ "Time in days. \n"
+ ""},
+ { (char *)"Time_AsHours", (PyCFunction)_wrap_Time_AsHours, METH_O, (char *)"\n"
+ "Time_AsHours(Time self) -> double\n"
+ "\n"
+ "double AsHours()\n"
+ "const\n"
+ "\n"
+ "Time in hours. \n"
+ ""},
+ { (char *)"Time_AsMinutes", (PyCFunction)_wrap_Time_AsMinutes, METH_O, (char *)"\n"
+ "Time_AsMinutes(Time self) -> double\n"
+ "\n"
+ "double AsMinutes()\n"
+ "const\n"
+ "\n"
+ "Time in minutes. \n"
+ ""},
+ { (char *)"Time_AsSeconds", (PyCFunction)_wrap_Time_AsSeconds, METH_O, (char *)"\n"
+ "Time_AsSeconds(Time self) -> double\n"
+ "\n"
+ "double AsSeconds()\n"
+ "const\n"
+ "\n"
+ "Time in seconds. \n"
+ ""},
+ { (char *)"Time_AsMilliseconds", (PyCFunction)_wrap_Time_AsMilliseconds, METH_O, (char *)"\n"
+ "Time_AsMilliseconds(Time self) -> long long\n"
+ "\n"
+ "long long\n"
+ "AsMilliseconds() const\n"
+ "\n"
+ "Time in milliseconds. \n"
+ ""},
+ { (char *)"Time_AsDate", (PyCFunction)_wrap_Time_AsDate, METH_O, (char *)"\n"
+ "Time_AsDate(Time self) -> Date\n"
+ "\n"
+ "Date AsDate() const\n"
+ "\n"
+ ""},
+ { (char *)"Time_to_string", (PyCFunction) _wrap_Time_to_string, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Time_to_string(Time self, char seperator) -> std::string\n"
+ "\n"
+ "std::string\n"
+ "to_string(char seperator=':') \n"
+ ""},
+ { (char *)"Time_is_not_0", (PyCFunction)_wrap_Time_is_not_0, METH_O, (char *)"\n"
+ "Time_is_not_0(Time self) -> bool\n"
+ "\n"
+ "bool is_not_0()\n"
+ "const \n"
+ ""},
+ { (char *)"Time_DOY", (PyCFunction)_wrap_Time_DOY, METH_O, (char *)"\n"
+ "Time_DOY(Time self) -> double\n"
+ "\n"
+ "double DOY() const \n"
""},
- { (char *)"Time_AsDays", (PyCFunction)_wrap_Time_AsDays, METH_O, (char *)"Time_AsDays(Time self) -> double"},
- { (char *)"Time_AsHours", (PyCFunction)_wrap_Time_AsHours, METH_O, (char *)"Time_AsHours(Time self) -> double"},
- { (char *)"Time_AsMinutes", (PyCFunction)_wrap_Time_AsMinutes, METH_O, (char *)"Time_AsMinutes(Time self) -> double"},
- { (char *)"Time_AsSeconds", (PyCFunction)_wrap_Time_AsSeconds, METH_O, (char *)"Time_AsSeconds(Time self) -> double"},
- { (char *)"Time_AsMilliseconds", (PyCFunction)_wrap_Time_AsMilliseconds, METH_O, (char *)"Time_AsMilliseconds(Time self) -> long long"},
- { (char *)"Time_AsDate", (PyCFunction)_wrap_Time_AsDate, METH_O, (char *)"Time_AsDate(Time self) -> Date"},
- { (char *)"Time_to_string", (PyCFunction) _wrap_Time_to_string, METH_VARARGS | METH_KEYWORDS, (char *)"Time_to_string(Time self, char seperator) -> std::string"},
- { (char *)"Time_is_not_0", (PyCFunction)_wrap_Time_is_not_0, METH_O, (char *)"Time_is_not_0(Time self) -> bool"},
- { (char *)"Time_DOY", (PyCFunction)_wrap_Time_DOY, METH_O, (char *)"Time_DOY(Time self) -> double"},
{ (char *)"Time___add__", (PyCFunction) _wrap_Time___add__, METH_VARARGS | METH_KEYWORDS, (char *)"Time___add__(Time self, Time t1) -> Time"},
{ (char *)"Time___sub__", (PyCFunction) _wrap_Time___sub__, METH_VARARGS | METH_KEYWORDS, (char *)"Time___sub__(Time self, Time t1) -> Time"},
{ (char *)"Time___iadd__", (PyCFunction) _wrap_Time___iadd__, METH_VARARGS | METH_KEYWORDS, (char *)"Time___iadd__(Time self, Time t1) -> Time"},
@@ -74697,7 +74964,14 @@ static PyMethodDef SwigMethods[] = {
"__truediv__(int x) -> Time\n"
"Time___truediv__(Time self, Time t1) -> double\n"
""},
- { (char *)"Time_times_in", (PyCFunction) _wrap_Time_times_in, METH_VARARGS | METH_KEYWORDS, (char *)"Time_times_in(Time self, Time t1) -> long long"},
+ { (char *)"Time_times_in", (PyCFunction) _wrap_Time_times_in, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Time_times_in(Time self, Time t1) -> long long\n"
+ "\n"
+ "long long\n"
+ "times_in(const Time &t1) const\n"
+ "\n"
+ "Returns the number of times this is included in t1. \n"
+ ""},
{ (char *)"Time___lt__", (PyCFunction) _wrap_Time___lt__, METH_VARARGS | METH_KEYWORDS, (char *)"Time___lt__(Time self, Time t1) -> bool"},
{ (char *)"Time___gt__", (PyCFunction) _wrap_Time___gt__, METH_VARARGS | METH_KEYWORDS, (char *)"Time___gt__(Time self, Time t1) -> bool"},
{ (char *)"Time___le__", (PyCFunction) _wrap_Time___le__, METH_VARARGS | METH_KEYWORDS, (char *)"Time___le__(Time self, Time t1) -> bool"},
@@ -74724,38 +74998,148 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"new_Date", _wrap_new_Date, METH_VARARGS, (char *)"\n"
"Date(int _day, int _month, int _year, int _hour=0, int _minute=0, int _second=0, int _ms=0)\n"
"new_Date(Time time) -> Date\n"
+ "\n"
+ "Date(const Time &time)\n"
+ "\n"
+ "Creates a new date from time (based on the 31.12.1899, like in\n"
+ "Excel(TM)) \n"
+ ""},
+ { (char *)"Date_ToTime", (PyCFunction)_wrap_Date_ToTime, METH_O, (char *)"\n"
+ "Date_ToTime(Date self) -> Time\n"
+ "\n"
+ "Time ToTime()\n"
+ "\n"
+ "Converts a date to Time (based on the 31.12.1899, like in Excel(TM) \n"
+ ""},
+ { (char *)"Date_DOY", (PyCFunction)_wrap_Date_DOY, METH_O, (char *)"\n"
+ "Date_DOY(Date self) -> double\n"
+ "\n"
+ "double DOY()\n"
+ "\n"
+ "Returns the day of year. \n"
+ ""},
+ { (char *)"Date_to_string", (PyCFunction)_wrap_Date_to_string, METH_O, (char *)"\n"
+ "Date_to_string(Date self) -> std::string\n"
+ "\n"
+ "std::string\n"
+ "to_string()\n"
+ "\n"
+ "Returns a string representing the date. \n"
""},
- { (char *)"Date_ToTime", (PyCFunction)_wrap_Date_ToTime, METH_O, (char *)"Date_ToTime(Date self) -> Time"},
- { (char *)"Date_DOY", (PyCFunction)_wrap_Date_DOY, METH_O, (char *)"Date_DOY(Date self) -> double"},
- { (char *)"Date_to_string", (PyCFunction)_wrap_Date_to_string, METH_O, (char *)"Date_to_string(Date self) -> std::string"},
{ (char *)"delete_Date", (PyCFunction)_wrap_delete_Date, METH_O, (char *)"delete_Date(Date self)"},
{ (char *)"Date_swigregister", Date_swigregister, METH_VARARGS, NULL},
{ (char *)"Date_swiginit", Date_swiginit, METH_VARARGS, NULL},
- { (char *)"timeseries_interpolationpower", (PyCFunction)_wrap_timeseries_interpolationpower, METH_O, (char *)"timeseries_interpolationpower(timeseries self) -> int"},
- { (char *)"timeseries_add", (PyCFunction) _wrap_timeseries_add, METH_VARARGS | METH_KEYWORDS, (char *)"timeseries_add(timeseries self, double Value)"},
- { (char *)"timeseries_is_empty", (PyCFunction)_wrap_timeseries_is_empty, METH_O, (char *)"timeseries_is_empty(timeseries self) -> bool"},
- { (char *)"timeseries_clear", (PyCFunction)_wrap_timeseries_clear, METH_O, (char *)"timeseries_clear(timeseries self)"},
- { (char *)"timeseries_adress", (PyCFunction)_wrap_timeseries_adress, METH_O, (char *)"timeseries_adress(timeseries self) -> size_t"},
- { (char *)"timeseries_copy", (PyCFunction)_wrap_timeseries_copy, METH_O, (char *)"timeseries_copy(timeseries self) -> timeseries"},
- { (char *)"timeseries_size", (PyCFunction)_wrap_timeseries_size, METH_O, (char *)"timeseries_size(timeseries self) -> size_t"},
- { (char *)"timeseries_count_values", (PyCFunction)_wrap_timeseries_count_values, METH_O, (char *)"timeseries_count_values(timeseries self) -> size_t"},
- { (char *)"new_timeseries", (PyCFunction) _wrap_new_timeseries, METH_VARARGS | METH_KEYWORDS, (char *)"new_timeseries(Time begin, Time step, int interpolationmethod=1, size_t count=0) -> timeseries"},
+ { (char *)"timeseries_interpolationpower", (PyCFunction)_wrap_timeseries_interpolationpower, METH_O, (char *)"\n"
+ "timeseries_interpolationpower(timeseries self) -> int\n"
+ "\n"
+ "int\n"
+ "interpolationpower() const\n"
+ "\n"
+ "Method for the interpolation (0 - Nearest neighbor, 1- linear, 2 -\n"
+ "cubic spline (not implemented yet) \n"
+ ""},
+ { (char *)"timeseries_add", (PyCFunction) _wrap_timeseries_add, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "timeseries_add(timeseries self, double Value)\n"
+ "\n"
+ "void add(double\n"
+ "Value)\n"
+ "\n"
+ "Appends a measurement. \n"
+ ""},
+ { (char *)"timeseries_is_empty", (PyCFunction)_wrap_timeseries_is_empty, METH_O, (char *)"\n"
+ "timeseries_is_empty(timeseries self) -> bool\n"
+ "\n"
+ "bool\n"
+ "is_empty() const\n"
+ "\n"
+ "returns true if no values are added to the timeseries \n"
+ ""},
+ { (char *)"timeseries_clear", (PyCFunction)_wrap_timeseries_clear, METH_O, (char *)"\n"
+ "timeseries_clear(timeseries self)\n"
+ "\n"
+ "void clear() \n"
+ ""},
+ { (char *)"timeseries_adress", (PyCFunction)_wrap_timeseries_adress, METH_O, (char *)"\n"
+ "timeseries_adress(timeseries self) -> size_t\n"
+ "\n"
+ "size_t adress()\n"
+ "const \n"
+ ""},
+ { (char *)"timeseries_copy", (PyCFunction)_wrap_timeseries_copy, METH_O, (char *)"\n"
+ "timeseries_copy(timeseries self) -> timeseries\n"
+ "\n"
+ "timeseries copy()\n"
+ "const \n"
+ ""},
+ { (char *)"timeseries_size", (PyCFunction)_wrap_timeseries_size, METH_O, (char *)"\n"
+ "timeseries_size(timeseries self) -> size_t\n"
+ "\n"
+ "size_t size()\n"
+ "const\n"
+ "\n"
+ "Number of items in the timeseries. \n"
+ ""},
+ { (char *)"timeseries_count_values", (PyCFunction)_wrap_timeseries_count_values, METH_O, (char *)"\n"
+ "timeseries_count_values(timeseries self) -> size_t\n"
+ "\n"
+ "size_t\n"
+ "count_values() const\n"
+ "\n"
+ "Number of valid values (=size - # of NaN's) \n"
+ ""},
+ { (char *)"new_timeseries", (PyCFunction) _wrap_new_timeseries, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_timeseries(Time begin, Time step, int interpolationmethod=1, size_t count=0) -> timeseries\n"
+ "\n"
+ "timeseries(const cmf::math::timeseries &ts) \n"
+ ""},
{ (char *)"timeseries_from_array", (PyCFunction) _wrap_timeseries_from_array, METH_VARARGS | METH_KEYWORDS, (char *)"timeseries_from_array(Time begin, Time step, cmf::math::num_array const & data) -> timeseries"},
{ (char *)"timeseries_from_scalar", (PyCFunction) _wrap_timeseries_from_scalar, METH_VARARGS | METH_KEYWORDS, (char *)"timeseries_from_scalar(double scalar) -> timeseries"},
{ (char *)"timeseries_from_file", (PyCFunction) _wrap_timeseries_from_file, METH_VARARGS | METH_KEYWORDS, (char *)"timeseries_from_file(std::string filename) -> timeseries"},
- { (char *)"timeseries_get_t", (PyCFunction) _wrap_timeseries_get_t, METH_VARARGS | METH_KEYWORDS, (char *)"timeseries_get_t(timeseries self, Time t) -> double"},
- { (char *)"timeseries_get_i", (PyCFunction) _wrap_timeseries_get_i, METH_VARARGS | METH_KEYWORDS, (char *)"timeseries_get_i(timeseries self, ptrdiff_t i) -> double"},
- { (char *)"timeseries_set_t", (PyCFunction) _wrap_timeseries_set_t, METH_VARARGS | METH_KEYWORDS, (char *)"timeseries_set_t(timeseries self, Time t, double value)"},
- { (char *)"timeseries_set_i", (PyCFunction) _wrap_timeseries_set_i, METH_VARARGS | METH_KEYWORDS, (char *)"timeseries_set_i(timeseries self, ptrdiff_t i, double value)"},
+ { (char *)"timeseries_get_t", (PyCFunction) _wrap_timeseries_get_t, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "timeseries_get_t(timeseries self, Time t) -> double\n"
+ "\n"
+ "double\n"
+ "get_t(cmf::math::Time t) const \n"
+ ""},
+ { (char *)"timeseries_get_i", (PyCFunction) _wrap_timeseries_get_i, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "timeseries_get_i(timeseries self, ptrdiff_t i) -> double\n"
+ "\n"
+ "double\n"
+ "get_i(ptrdiff_t i) const \n"
+ ""},
+ { (char *)"timeseries_set_t", (PyCFunction) _wrap_timeseries_set_t, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "timeseries_set_t(timeseries self, Time t, double value)\n"
+ "\n"
+ "void\n"
+ "set_t(cmf::math::Time t, double value) \n"
+ ""},
+ { (char *)"timeseries_set_i", (PyCFunction) _wrap_timeseries_set_i, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "timeseries_set_i(timeseries self, ptrdiff_t i, double value)\n"
+ "\n"
+ "void\n"
+ "set_i(ptrdiff_t i, double value) \n"
+ ""},
{ (char *)"timeseries_get_slice", _wrap_timeseries_get_slice, METH_VARARGS, (char *)"\n"
"get_slice(Time _begin, Time _end, Time _step) -> timeseries\n"
"timeseries_get_slice(timeseries self, ptrdiff_t _begin, ptrdiff_t _end, ptrdiff_t step=1) -> timeseries\n"
+ "\n"
+ "cmf::math::timeseries get_slice(ptrdiff_t _begin, ptrdiff_t _end,\n"
+ "ptrdiff_t step=1) \n"
""},
{ (char *)"timeseries_set_slice", _wrap_timeseries_set_slice, METH_VARARGS, (char *)"\n"
"set_slice(Time _begin, Time _end, timeseries values)\n"
"timeseries_set_slice(timeseries self, ptrdiff_t _begin, ptrdiff_t _end, timeseries _values)\n"
+ "\n"
+ "void\n"
+ "set_slice(ptrdiff_t _begin, ptrdiff_t _end, cmf::math::timeseries\n"
+ "_values) \n"
+ ""},
+ { (char *)"timeseries_remove_nodata", (PyCFunction) _wrap_timeseries_remove_nodata, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "timeseries_remove_nodata(timeseries self, double nodata_value)\n"
+ "\n"
+ "void\n"
+ "remove_nodata(double nodata_value) \n"
""},
- { (char *)"timeseries_remove_nodata", (PyCFunction) _wrap_timeseries_remove_nodata, METH_VARARGS | METH_KEYWORDS, (char *)"timeseries_remove_nodata(timeseries self, double nodata_value)"},
{ (char *)"timeseries___iadd__", _wrap_timeseries___iadd__, METH_VARARGS, (char *)"\n"
"__iadd__(timeseries arg2) -> timeseries\n"
"timeseries___iadd__(timeseries self, double arg3) -> timeseries\n"
@@ -74789,109 +75173,485 @@ static PyMethodDef SwigMethods[] = {
"timeseries___truediv__(timeseries self, double arg3) -> timeseries\n"
""},
{ (char *)"timeseries___neg__", (PyCFunction)_wrap_timeseries___neg__, METH_O, (char *)"timeseries___neg__(timeseries self) -> timeseries"},
- { (char *)"timeseries_inv", (PyCFunction)_wrap_timeseries_inv, METH_O, (char *)"timeseries_inv(timeseries self) -> timeseries"},
- { (char *)"timeseries_reduce_min", (PyCFunction) _wrap_timeseries_reduce_min, METH_VARARGS | METH_KEYWORDS, (char *)"timeseries_reduce_min(timeseries self, Time begin, Time step) -> timeseries"},
- { (char *)"timeseries_reduce_max", (PyCFunction) _wrap_timeseries_reduce_max, METH_VARARGS | METH_KEYWORDS, (char *)"timeseries_reduce_max(timeseries self, Time begin, Time step) -> timeseries"},
- { (char *)"timeseries_reduce_sum", (PyCFunction) _wrap_timeseries_reduce_sum, METH_VARARGS | METH_KEYWORDS, (char *)"timeseries_reduce_sum(timeseries self, Time begin, Time step) -> timeseries"},
- { (char *)"timeseries_reduce_avg", (PyCFunction) _wrap_timeseries_reduce_avg, METH_VARARGS | METH_KEYWORDS, (char *)"timeseries_reduce_avg(timeseries self, Time begin, Time step) -> timeseries"},
+ { (char *)"timeseries_inv", (PyCFunction)_wrap_timeseries_inv, METH_O, (char *)"\n"
+ "timeseries_inv(timeseries self) -> timeseries\n"
+ "\n"
+ "timeseries inv()\n"
+ "const \n"
+ ""},
+ { (char *)"timeseries_reduce_min", (PyCFunction) _wrap_timeseries_reduce_min, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "timeseries_reduce_min(timeseries self, Time begin, Time step) -> timeseries\n"
+ "\n"
+ "timeseries\n"
+ "reduce_min(cmf::math::Time begin, cmf::math::Time step) const\n"
+ "\n"
+ "Creates a timeseries with a bigger timestep, containing the minimum.\n"
+ "\n"
+ ""},
+ { (char *)"timeseries_reduce_max", (PyCFunction) _wrap_timeseries_reduce_max, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "timeseries_reduce_max(timeseries self, Time begin, Time step) -> timeseries\n"
+ "\n"
+ "timeseries\n"
+ "reduce_max(cmf::math::Time begin, cmf::math::Time step) const\n"
+ "\n"
+ "Creates a timeseries with a bigger timestep, containing the maximum.\n"
+ "\n"
+ ""},
+ { (char *)"timeseries_reduce_sum", (PyCFunction) _wrap_timeseries_reduce_sum, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "timeseries_reduce_sum(timeseries self, Time begin, Time step) -> timeseries\n"
+ "\n"
+ "timeseries\n"
+ "reduce_sum(cmf::math::Time begin, cmf::math::Time step) const\n"
+ "\n"
+ "Creates a timeseries with a bigger timestep, containing the sum. \n"
+ ""},
+ { (char *)"timeseries_reduce_avg", (PyCFunction) _wrap_timeseries_reduce_avg, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "timeseries_reduce_avg(timeseries self, Time begin, Time step) -> timeseries\n"
+ "\n"
+ "timeseries\n"
+ "reduce_avg(cmf::math::Time begin, cmf::math::Time step) const\n"
+ "\n"
+ "Creates a timeseries with a bigger timestep, containing the average.\n"
+ "\n"
+ ""},
{ (char *)"timeseries_floating_avg", _wrap_timeseries_floating_avg, METH_VARARGS, (char *)"\n"
"floating_avg(Time window_width) -> timeseries\n"
"timeseries_floating_avg(timeseries self, size_t window_size) -> timeseries\n"
+ "\n"
+ "timeseries floating_avg(size_t window_size) const \n"
+ ""},
+ { (char *)"timeseries_floating_max", (PyCFunction) _wrap_timeseries_floating_max, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "timeseries_floating_max(timeseries self, Time window_width) -> timeseries\n"
+ "\n"
+ "timeseries floating_max(cmf::math::Time window_width) const \n"
+ ""},
+ { (char *)"timeseries_floating_min", (PyCFunction) _wrap_timeseries_floating_min, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "timeseries_floating_min(timeseries self, Time window_width) -> timeseries\n"
+ "\n"
+ "timeseries floating_min(cmf::math::Time window_width) const \n"
+ ""},
+ { (char *)"timeseries_mean", (PyCFunction)_wrap_timeseries_mean, METH_O, (char *)"\n"
+ "timeseries_mean(timeseries self) -> double\n"
+ "\n"
+ "double mean()\n"
+ "const \n"
+ ""},
+ { (char *)"timeseries_min", (PyCFunction)_wrap_timeseries_min, METH_O, (char *)"\n"
+ "timeseries_min(timeseries self) -> double\n"
+ "\n"
+ "double min() const\n"
+ "\n"
+ ""},
+ { (char *)"timeseries_max", (PyCFunction)_wrap_timeseries_max, METH_O, (char *)"\n"
+ "timeseries_max(timeseries self) -> double\n"
+ "\n"
+ "double max() const\n"
+ "\n"
+ ""},
+ { (char *)"timeseries_log", (PyCFunction)_wrap_timeseries_log, METH_O, (char *)"\n"
+ "timeseries_log(timeseries self) -> timeseries\n"
+ "\n"
+ "timeseries log()\n"
+ "const \n"
+ ""},
+ { (char *)"timeseries_log10", (PyCFunction)_wrap_timeseries_log10, METH_O, (char *)"\n"
+ "timeseries_log10(timeseries self) -> timeseries\n"
+ "\n"
+ "timeseries\n"
+ "log10() const \n"
+ ""},
+ { (char *)"timeseries_power", (PyCFunction) _wrap_timeseries_power, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "timeseries_power(timeseries self, double exponent) -> timeseries\n"
+ "\n"
+ "timeseries\n"
+ "power(double exponent) const \n"
+ ""},
+ { (char *)"timeseries_exp", (PyCFunction)_wrap_timeseries_exp, METH_O, (char *)"\n"
+ "timeseries_exp(timeseries self) -> timeseries\n"
+ "\n"
+ "timeseries exp()\n"
+ "const \n"
+ ""},
+ { (char *)"timeseries_begin_get", (PyCFunction)_wrap_timeseries_begin_get, METH_O, (char *)"\n"
+ "timeseries_begin_get(timeseries self) -> Time\n"
+ "\n"
+ "cmf::math::Time\n"
+ "begin() const\n"
+ "\n"
+ "First date of measurement. \n"
+ ""},
+ { (char *)"timeseries_step_get", (PyCFunction)_wrap_timeseries_step_get, METH_O, (char *)"\n"
+ "timeseries_step_get(timeseries self) -> Time\n"
+ "\n"
+ "cmf::math::Time\n"
+ "step() const\n"
+ "\n"
+ "Time between the measurements. \n"
+ ""},
+ { (char *)"timeseries_end_get", (PyCFunction)_wrap_timeseries_end_get, METH_O, (char *)"\n"
+ "timeseries_end_get(timeseries self) -> Time\n"
+ "\n"
+ "cmf::math::Time\n"
+ "end() const\n"
+ "\n"
+ "Last date of measurements. \n"
""},
- { (char *)"timeseries_floating_max", (PyCFunction) _wrap_timeseries_floating_max, METH_VARARGS | METH_KEYWORDS, (char *)"timeseries_floating_max(timeseries self, Time window_width) -> timeseries"},
- { (char *)"timeseries_floating_min", (PyCFunction) _wrap_timeseries_floating_min, METH_VARARGS | METH_KEYWORDS, (char *)"timeseries_floating_min(timeseries self, Time window_width) -> timeseries"},
- { (char *)"timeseries_mean", (PyCFunction)_wrap_timeseries_mean, METH_O, (char *)"timeseries_mean(timeseries self) -> double"},
- { (char *)"timeseries_min", (PyCFunction)_wrap_timeseries_min, METH_O, (char *)"timeseries_min(timeseries self) -> double"},
- { (char *)"timeseries_max", (PyCFunction)_wrap_timeseries_max, METH_O, (char *)"timeseries_max(timeseries self) -> double"},
- { (char *)"timeseries_log", (PyCFunction)_wrap_timeseries_log, METH_O, (char *)"timeseries_log(timeseries self) -> timeseries"},
- { (char *)"timeseries_log10", (PyCFunction)_wrap_timeseries_log10, METH_O, (char *)"timeseries_log10(timeseries self) -> timeseries"},
- { (char *)"timeseries_power", (PyCFunction) _wrap_timeseries_power, METH_VARARGS | METH_KEYWORDS, (char *)"timeseries_power(timeseries self, double exponent) -> timeseries"},
- { (char *)"timeseries_exp", (PyCFunction)_wrap_timeseries_exp, METH_O, (char *)"timeseries_exp(timeseries self) -> timeseries"},
- { (char *)"timeseries_begin_get", (PyCFunction)_wrap_timeseries_begin_get, METH_O, (char *)"timeseries_begin_get(timeseries self) -> Time"},
- { (char *)"timeseries_step_get", (PyCFunction)_wrap_timeseries_step_get, METH_O, (char *)"timeseries_step_get(timeseries self) -> Time"},
- { (char *)"timeseries_end_get", (PyCFunction)_wrap_timeseries_end_get, METH_O, (char *)"timeseries_end_get(timeseries self) -> Time"},
{ (char *)"timeseries___len__", (PyCFunction)_wrap_timeseries___len__, METH_O, (char *)"timeseries___len__(timeseries self) -> ptrdiff_t"},
{ (char *)"delete_timeseries", (PyCFunction)_wrap_delete_timeseries, METH_O, (char *)"delete_timeseries(timeseries self)"},
{ (char *)"timeseries_swigregister", timeseries_swigregister, METH_VARARGS, NULL},
{ (char *)"timeseries_swiginit", timeseries_swiginit, METH_VARARGS, NULL},
- { (char *)"nash_sutcliffe", (PyCFunction) _wrap_nash_sutcliffe, METH_VARARGS | METH_KEYWORDS, (char *)"nash_sutcliffe(timeseries model, timeseries observation) -> double"},
- { (char *)"integratable_integrate", (PyCFunction) _wrap_integratable_integrate, METH_VARARGS | METH_KEYWORDS, (char *)"integratable_integrate(integratable self, Time t)"},
- { (char *)"integratable_reset", (PyCFunction) _wrap_integratable_reset, METH_VARARGS | METH_KEYWORDS, (char *)"integratable_reset(integratable self, Time t)"},
- { (char *)"integratable_sum", (PyCFunction)_wrap_integratable_sum, METH_O, (char *)"integratable_sum(integratable self) -> double"},
- { (char *)"integratable_avg", (PyCFunction)_wrap_integratable_avg, METH_O, (char *)"integratable_avg(integratable self) -> double"},
+ { (char *)"nash_sutcliffe", (PyCFunction) _wrap_nash_sutcliffe, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "nash_sutcliffe(timeseries model, timeseries observation) -> double\n"
+ "\n"
+ "double\n"
+ "cmf::math::nash_sutcliffe(const cmf::math::timeseries &model, const\n"
+ "cmf::math::timeseries &observation)\n"
+ "\n"
+ "Calculates the Nash-Sutcliffe efficiency of a modeled timeseries in\n"
+ "comparison with an observed timeseries.\n"
+ "\n"
+ "The Nash-Sutcliffe efficiancy is defined as: \n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " E = 1 -\n"
+ " \\\\frac{\\\\sum_{t=1}^{T}(M_t - O_t)^2}{\\\\sum_{t=1}^{T}(O_t -\n"
+ " \\\\overline{O})^2}\n"
+ "\n"
+ "where :math:`T` is the number of observation time\n"
+ "steps\n"
+ "\n"
+ ":math:`M` is the timeseries of model results matchinig O\n"
+ "\n"
+ ":math:`O` is the timeseries containing observations\n"
+ "\n"
+ ":math:`\\\\overline{O}` is the arithmetic mean of observations \n"
+ ""},
+ { (char *)"integratable_integrate", (PyCFunction) _wrap_integratable_integrate, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "integratable_integrate(integratable self, Time t)\n"
+ "\n"
+ "virtual\n"
+ "void integrate(Time t)=0\n"
+ "\n"
+ "Integrates the variable until time t. \n"
+ ""},
+ { (char *)"integratable_reset", (PyCFunction) _wrap_integratable_reset, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "integratable_reset(integratable self, Time t)\n"
+ "\n"
+ "virtual void\n"
+ "reset(Time t)=0\n"
+ "\n"
+ "Sets the start time of the integral. \n"
+ ""},
+ { (char *)"integratable_sum", (PyCFunction)_wrap_integratable_sum, METH_O, (char *)"\n"
+ "integratable_sum(integratable self) -> double\n"
+ "\n"
+ "virtual double\n"
+ "sum() const =0\n"
+ "\n"
+ "Get the integral from the last reset until the last call of integrate.\n"
+ "\n"
+ ""},
+ { (char *)"integratable_avg", (PyCFunction)_wrap_integratable_avg, METH_O, (char *)"\n"
+ "integratable_avg(integratable self) -> double\n"
+ "\n"
+ "virtual double\n"
+ "avg() const =0\n"
+ "\n"
+ "Returns average of the integrated variable (eg. flux) from the last\n"
+ "reset until the last call of integrate. \n"
+ ""},
{ (char *)"delete_integratable", (PyCFunction)_wrap_delete_integratable, METH_O, (char *)"delete_integratable(integratable self)"},
{ (char *)"integratable_swigregister", integratable_swigregister, METH_VARARGS, NULL},
- { (char *)"integratable_list_append", (PyCFunction) _wrap_integratable_list_append, METH_VARARGS | METH_KEYWORDS, (char *)"integratable_list_append(integratable_list self, cmf::math::integratable::ptr add)"},
- { (char *)"integratable_list_remove", (PyCFunction) _wrap_integratable_list_remove, METH_VARARGS | METH_KEYWORDS, (char *)"integratable_list_remove(integratable_list self, cmf::math::integratable::ptr rm)"},
+ { (char *)"integratable_list_append", (PyCFunction) _wrap_integratable_list_append, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "integratable_list_append(integratable_list self, cmf::math::integratable::ptr add)\n"
+ "\n"
+ "void\n"
+ "append(cmf::math::integratable::ptr add)\n"
+ "\n"
+ "Adds an integratable to the list. \n"
+ ""},
+ { (char *)"integratable_list_remove", (PyCFunction) _wrap_integratable_list_remove, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "integratable_list_remove(integratable_list self, cmf::math::integratable::ptr rm)\n"
+ "\n"
+ "void\n"
+ "remove(cmf::math::integratable::ptr rm)\n"
+ "\n"
+ "Removes an integratable from the list. \n"
+ ""},
{ (char *)"integratable_list___getitem", (PyCFunction) _wrap_integratable_list___getitem, METH_VARARGS | METH_KEYWORDS, (char *)"integratable_list___getitem(integratable_list self, int index) -> cmf::math::integratable::ptr"},
- { (char *)"integratable_list_size", (PyCFunction)_wrap_integratable_list_size, METH_O, (char *)"integratable_list_size(integratable_list self) -> size_t"},
- { (char *)"integratable_list_avg", (PyCFunction)_wrap_integratable_list_avg, METH_O, (char *)"integratable_list_avg(integratable_list self) -> cmf::math::num_array"},
- { (char *)"integratable_list_sum", (PyCFunction)_wrap_integratable_list_sum, METH_O, (char *)"integratable_list_sum(integratable_list self) -> cmf::math::num_array"},
- { (char *)"integratable_list_reset", (PyCFunction) _wrap_integratable_list_reset, METH_VARARGS | METH_KEYWORDS, (char *)"integratable_list_reset(integratable_list self, Time t)"},
- { (char *)"integratable_list_integrate", (PyCFunction) _wrap_integratable_list_integrate, METH_VARARGS | METH_KEYWORDS, (char *)"integratable_list_integrate(integratable_list self, Time t)"},
+ { (char *)"integratable_list_size", (PyCFunction)_wrap_integratable_list_size, METH_O, (char *)"\n"
+ "integratable_list_size(integratable_list self) -> size_t\n"
+ "\n"
+ "size_t\n"
+ "size() const\n"
+ "\n"
+ "Number of integratables in the list. \n"
+ ""},
+ { (char *)"integratable_list_avg", (PyCFunction)_wrap_integratable_list_avg, METH_O, (char *)"\n"
+ "integratable_list_avg(integratable_list self) -> cmf::math::num_array\n"
+ "\n"
+ "cmf::math::num_array avg() const \n"
+ ""},
+ { (char *)"integratable_list_sum", (PyCFunction)_wrap_integratable_list_sum, METH_O, (char *)"\n"
+ "integratable_list_sum(integratable_list self) -> cmf::math::num_array\n"
+ "\n"
+ "cmf::math::num_array sum() const \n"
+ ""},
+ { (char *)"integratable_list_reset", (PyCFunction) _wrap_integratable_list_reset, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "integratable_list_reset(integratable_list self, Time t)\n"
+ "\n"
+ "void\n"
+ "reset(Time t) \n"
+ ""},
+ { (char *)"integratable_list_integrate", (PyCFunction) _wrap_integratable_list_integrate, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "integratable_list_integrate(integratable_list self, Time t)\n"
+ "\n"
+ "void\n"
+ "integrate(Time t) \n"
+ ""},
{ (char *)"new_integratable_list", _wrap_new_integratable_list, METH_VARARGS, (char *)"\n"
"integratable_list()\n"
"new_integratable_list(integratable_list for_copy) -> integratable_list\n"
+ "\n"
+ "integratable_list(const integratable_list &for_copy) \n"
""},
{ (char *)"integratable_list___len__", (PyCFunction)_wrap_integratable_list___len__, METH_O, (char *)"integratable_list___len__(integratable_list self) -> size_t"},
{ (char *)"delete_integratable_list", (PyCFunction)_wrap_delete_integratable_list, METH_O, (char *)"delete_integratable_list(integratable_list self)"},
{ (char *)"integratable_list_swigregister", integratable_list_swigregister, METH_VARARGS, NULL},
{ (char *)"integratable_list_swiginit", integratable_list_swiginit, METH_VARARGS, NULL},
- { (char *)"StateVariable_dxdt", (PyCFunction) _wrap_StateVariable_dxdt, METH_VARARGS | METH_KEYWORDS, (char *)"StateVariable_dxdt(StateVariable self, Time time) -> real"},
- { (char *)"StateVariable_get_abs_errtol", (PyCFunction) _wrap_StateVariable_get_abs_errtol, METH_VARARGS | METH_KEYWORDS, (char *)"StateVariable_get_abs_errtol(StateVariable self, real rel_errtol) -> real"},
- { (char *)"StateVariable_to_string", (PyCFunction)_wrap_StateVariable_to_string, METH_O, (char *)"StateVariable_to_string(StateVariable self) -> std::string"},
- { (char *)"delete_StateVariable", (PyCFunction)_wrap_delete_StateVariable, METH_O, (char *)"delete_StateVariable(StateVariable self)"},
+ { (char *)"StateVariable_dxdt", (PyCFunction) _wrap_StateVariable_dxdt, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "StateVariable_dxdt(StateVariable self, Time time) -> real\n"
+ "\n"
+ "virtual real\n"
+ "dxdt(const cmf::math::Time &time)=0\n"
+ "\n"
+ "Returns the derivate of the state variable at time time. \n"
+ ""},
+ { (char *)"StateVariable_get_abs_errtol", (PyCFunction) _wrap_StateVariable_get_abs_errtol, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "StateVariable_get_abs_errtol(StateVariable self, real rel_errtol) -> real\n"
+ "\n"
+ "virtual real get_abs_errtol(real rel_errtol) const \n"
+ ""},
+ { (char *)"StateVariable_to_string", (PyCFunction)_wrap_StateVariable_to_string, METH_O, (char *)"\n"
+ "StateVariable_to_string(StateVariable self) -> std::string\n"
+ "\n"
+ "virtual\n"
+ "std::string to_string() const =0 \n"
+ ""},
+ { (char *)"delete_StateVariable", (PyCFunction)_wrap_delete_StateVariable, METH_O, (char *)"\n"
+ "delete_StateVariable(StateVariable self)\n"
+ "\n"
+ "virtual ~StateVariable() \n"
+ ""},
{ (char *)"StateVariable_state_set", _wrap_StateVariable_state_set, METH_VARARGS, (char *)"StateVariable_state_set(StateVariable self, real state)"},
{ (char *)"StateVariable_state_get", (PyCFunction)_wrap_StateVariable_state_get, METH_O, (char *)"StateVariable_state_get(StateVariable self) -> real"},
{ (char *)"StateVariable_swigregister", StateVariable_swigregister, METH_VARARGS, NULL},
- { (char *)"StateVariableOwner_get_states", (PyCFunction)_wrap_StateVariableOwner_get_states, METH_O, (char *)"StateVariableOwner_get_states(StateVariableOwner self) -> StateVariableList"},
+ { (char *)"StateVariableOwner_get_states", (PyCFunction)_wrap_StateVariableOwner_get_states, METH_O, (char *)"\n"
+ "StateVariableOwner_get_states(StateVariableOwner self) -> StateVariableList\n"
+ "\n"
+ "virtual StateVariableList get_states()=0\n"
+ "\n"
+ "Add the state variables, owned by an object derived from\n"
+ "StateVariableOwner, to the given vector. \n"
+ ""},
{ (char *)"delete_StateVariableOwner", (PyCFunction)_wrap_delete_StateVariableOwner, METH_O, (char *)"delete_StateVariableOwner(StateVariableOwner self)"},
{ (char *)"StateVariableOwner_swigregister", StateVariableOwner_swigregister, METH_VARARGS, NULL},
- { (char *)"StateVariableList_append", (PyCFunction) _wrap_StateVariableList_append, METH_VARARGS | METH_KEYWORDS, (char *)"StateVariableList_append(StateVariableList self, cmf::math::StateVariable::ptr sv)"},
- { (char *)"StateVariableList_extend", (PyCFunction) _wrap_StateVariableList_extend, METH_VARARGS | METH_KEYWORDS, (char *)"StateVariableList_extend(StateVariableList self, StateVariableOwner svo)"},
+ { (char *)"StateVariableList_append", (PyCFunction) _wrap_StateVariableList_append, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "StateVariableList_append(StateVariableList self, cmf::math::StateVariable::ptr sv)\n"
+ "\n"
+ "void\n"
+ "append(StateVariable::ptr sv) \n"
+ ""},
+ { (char *)"StateVariableList_extend", (PyCFunction) _wrap_StateVariableList_extend, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "StateVariableList_extend(StateVariableList self, StateVariableOwner svo)\n"
+ "\n"
+ "void\n"
+ "extend(StateVariableOwner &svo) \n"
+ ""},
{ (char *)"StateVariableList___iadd__", _wrap_StateVariableList___iadd__, METH_VARARGS, (char *)"\n"
"__iadd__(StateVariableList food) -> StateVariableList\n"
"StateVariableList___iadd__(StateVariableList self, StateVariableOwner svo) -> StateVariableList\n"
""},
- { (char *)"StateVariableList_size", (PyCFunction)_wrap_StateVariableList_size, METH_O, (char *)"StateVariableList_size(StateVariableList self) -> size_t"},
+ { (char *)"StateVariableList_size", (PyCFunction)_wrap_StateVariableList_size, METH_O, (char *)"\n"
+ "StateVariableList_size(StateVariableList self) -> size_t\n"
+ "\n"
+ "size_t\n"
+ "size() const \n"
+ ""},
{ (char *)"StateVariableList___len__", (PyCFunction)_wrap_StateVariableList___len__, METH_O, (char *)"StateVariableList___len__(StateVariableList self) -> size_t"},
{ (char *)"new_StateVariableList", (PyCFunction)_wrap_new_StateVariableList, METH_NOARGS, (char *)"new_StateVariableList() -> StateVariableList"},
{ (char *)"delete_StateVariableList", (PyCFunction)_wrap_delete_StateVariableList, METH_O, (char *)"delete_StateVariableList(StateVariableList self)"},
{ (char *)"StateVariableList_swigregister", StateVariableList_swigregister, METH_VARARGS, NULL},
{ (char *)"StateVariableList_swiginit", StateVariableList_swiginit, METH_VARARGS, NULL},
- { (char *)"Integrator_get_dxdt", (PyCFunction) _wrap_Integrator_get_dxdt, METH_VARARGS | METH_KEYWORDS, (char *)"Integrator_get_dxdt(Integrator self, Time time) -> cmf::math::num_array"},
- { (char *)"Integrator_add_states", (PyCFunction) _wrap_Integrator_add_states, METH_VARARGS | METH_KEYWORDS, (char *)"Integrator_add_states(Integrator self, StateVariableOwner stateOwner)"},
- { (char *)"Integrator_add_single_state", (PyCFunction) _wrap_Integrator_add_single_state, METH_VARARGS | METH_KEYWORDS, (char *)"Integrator_add_single_state(Integrator self, cmf::math::StateVariable::ptr state)"},
+ { (char *)"Integrator_get_dxdt", (PyCFunction) _wrap_Integrator_get_dxdt, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Integrator_get_dxdt(Integrator self, Time time) -> cmf::math::num_array\n"
+ "\n"
+ "cmf::math::num_array get_dxdt(Time time) const \n"
+ ""},
+ { (char *)"Integrator_add_states", (PyCFunction) _wrap_Integrator_add_states, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Integrator_add_states(Integrator self, StateVariableOwner stateOwner)\n"
+ "\n"
+ "virtual\n"
+ "void add_states(cmf::math::StateVariableOwner &stateOwner)\n"
+ "\n"
+ "Add state variables from a StateVariableOwner. \n"
+ ""},
+ { (char *)"Integrator_add_single_state", (PyCFunction) _wrap_Integrator_add_single_state, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Integrator_add_single_state(Integrator self, cmf::math::StateVariable::ptr state)\n"
+ "\n"
+ "virtual void add_single_state(cmf::math::StateVariable::ptr state)\n"
+ "\n"
+ "Adds a single state variable to the integrator. \n"
+ ""},
{ (char *)"Integrator_integratables_set", _wrap_Integrator_integratables_set, METH_VARARGS, (char *)"Integrator_integratables_set(Integrator self, integratable_list integratables)"},
{ (char *)"Integrator_integratables_get", (PyCFunction)_wrap_Integrator_integratables_get, METH_O, (char *)"Integrator_integratables_get(Integrator self) -> integratable_list"},
{ (char *)"Integrator_reset_integratables_set", _wrap_Integrator_reset_integratables_set, METH_VARARGS, (char *)"Integrator_reset_integratables_set(Integrator self, bool reset_integratables)"},
{ (char *)"Integrator_reset_integratables_get", (PyCFunction)_wrap_Integrator_reset_integratables_get, METH_O, (char *)"Integrator_reset_integratables_get(Integrator self) -> bool"},
{ (char *)"Integrator_use_OpenMP_set", _wrap_Integrator_use_OpenMP_set, METH_VARARGS, (char *)"Integrator_use_OpenMP_set(Integrator self, bool use_OpenMP)"},
{ (char *)"Integrator_use_OpenMP_get", (PyCFunction)_wrap_Integrator_use_OpenMP_get, METH_O, (char *)"Integrator_use_OpenMP_get(Integrator self) -> bool"},
- { (char *)"Integrator_size", (PyCFunction)_wrap_Integrator_size, METH_O, (char *)"Integrator_size(Integrator self) -> size_t"},
- { (char *)"Integrator_get_state", (PyCFunction) _wrap_Integrator_get_state, METH_VARARGS | METH_KEYWORDS, (char *)"Integrator_get_state(Integrator self, ptrdiff_t position) -> real"},
- { (char *)"Integrator_set_state", (PyCFunction) _wrap_Integrator_set_state, METH_VARARGS | METH_KEYWORDS, (char *)"Integrator_set_state(Integrator self, ptrdiff_t position, real newState)"},
+ { (char *)"Integrator_size", (PyCFunction)_wrap_Integrator_size, METH_O, (char *)"\n"
+ "Integrator_size(Integrator self) -> size_t\n"
+ "\n"
+ "size_t size()\n"
+ "const\n"
+ "\n"
+ "returns the number of state variables \n"
+ ""},
+ { (char *)"Integrator_get_state", (PyCFunction) _wrap_Integrator_get_state, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Integrator_get_state(Integrator self, ptrdiff_t position) -> real\n"
+ "\n"
+ "real\n"
+ "get_state(ptrdiff_t position) const\n"
+ "\n"
+ "Returns the statevariable at position Simplifies the assessment of\n"
+ "state variables. \n"
+ ""},
+ { (char *)"Integrator_set_state", (PyCFunction) _wrap_Integrator_set_state, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Integrator_set_state(Integrator self, ptrdiff_t position, real newState)\n"
+ "\n"
+ "void\n"
+ "set_state(ptrdiff_t position, real newState)\n"
+ "\n"
+ "Simplifies the assessment of state variables. \n"
+ ""},
{ (char *)"Integrator_get_states", _wrap_Integrator_get_states, METH_VARARGS, (char *)"\n"
"get_states() -> cmf::math::num_array\n"
"Integrator_get_states(Integrator self) -> StateVariableList\n"
+ "\n"
+ "StateVariableList get_states()\n"
+ "\n"
+ "gets the state variables of the integrator \n"
+ ""},
+ { (char *)"delete_Integrator", (PyCFunction)_wrap_delete_Integrator, METH_O, (char *)"\n"
+ "delete_Integrator(Integrator self)\n"
+ "\n"
+ "virtual\n"
+ "~Integrator() \n"
+ ""},
+ { (char *)"Integrator_get_t", (PyCFunction)_wrap_Integrator_get_t, METH_O, (char *)"\n"
+ "Integrator_get_t(Integrator self) -> Time\n"
+ "\n"
+ "cmf::math::Time\n"
+ "get_t() const\n"
+ "\n"
+ "Returns the current model time. \n"
+ ""},
+ { (char *)"Integrator_set_t", (PyCFunction) _wrap_Integrator_set_t, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Integrator_set_t(Integrator self, Time val)\n"
+ "\n"
+ "void\n"
+ "set_t(cmf::math::Time val)\n"
+ "\n"
+ "Sets the current model time. \n"
+ ""},
+ { (char *)"Integrator_get_dt", (PyCFunction)_wrap_Integrator_get_dt, METH_O, (char *)"\n"
+ "Integrator_get_dt(Integrator self) -> Time\n"
+ "\n"
+ "cmf::math::Time\n"
+ "get_dt() const\n"
+ "\n"
+ "Returns the last time step. \n"
+ ""},
+ { (char *)"Integrator_reset", (PyCFunction)_wrap_Integrator_reset, METH_O, (char *)"\n"
+ "Integrator_reset(Integrator self)\n"
+ "\n"
+ "virtual void\n"
+ "reset()\n"
+ "\n"
+ "Resets any saved history (for multistep methods) \n"
+ ""},
+ { (char *)"Integrator_copy", (PyCFunction)_wrap_Integrator_copy, METH_O, (char *)"\n"
+ "Integrator_copy(Integrator self) -> Integrator\n"
+ "\n"
+ "virtual\n"
+ "Integrator* copy() const =0\n"
+ "\n"
+ "Polymorphic copy constructor. \n"
+ ""},
+ { (char *)"Integrator_integrate", (PyCFunction) _wrap_Integrator_integrate, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Integrator_integrate(Integrator self, Time t_max, Time dt) -> int\n"
+ "\n"
+ "virtual int\n"
+ "integrate(cmf::math::Time t_max, cmf::math::Time dt)=0\n"
+ "\n"
+ "Integrates the vector of state variables.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "t_max: To stop the model (if running in a model framework) at time\n"
+ "steps of value exchange e.g. full hours, the next value exchange time\n"
+ "can be given\n"
+ "\n"
+ "dt: Takes the proposed time step, and changes it into the effectively\n"
+ "used time step according to the local stiffness of the problem and\n"
+ "MaxTime \n"
+ ""},
+ { (char *)"Integrator_integrate_until", (PyCFunction) _wrap_Integrator_integrate_until, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Integrator_integrate_until(Integrator self, Time t_max, Time dt, bool reset=False)\n"
+ "\n"
+ "void\n"
+ "integrate_until(cmf::math::Time t_max, cmf::math::Time dt=Time(), bool\n"
+ "reset=false)\n"
+ "\n"
+ "Integrates the vector of state variables until t_max.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "t_max: Time, the solver should run to\n"
+ "\n"
+ "dt: Time step (may be omitted)\n"
+ "\n"
+ "reset: If true, solver is reseted before integration starts \n"
""},
- { (char *)"delete_Integrator", (PyCFunction)_wrap_delete_Integrator, METH_O, (char *)"delete_Integrator(Integrator self)"},
- { (char *)"Integrator_get_t", (PyCFunction)_wrap_Integrator_get_t, METH_O, (char *)"Integrator_get_t(Integrator self) -> Time"},
- { (char *)"Integrator_set_t", (PyCFunction) _wrap_Integrator_set_t, METH_VARARGS | METH_KEYWORDS, (char *)"Integrator_set_t(Integrator self, Time val)"},
- { (char *)"Integrator_get_dt", (PyCFunction)_wrap_Integrator_get_dt, METH_O, (char *)"Integrator_get_dt(Integrator self) -> Time"},
- { (char *)"Integrator_reset", (PyCFunction)_wrap_Integrator_reset, METH_O, (char *)"Integrator_reset(Integrator self)"},
- { (char *)"Integrator_copy", (PyCFunction)_wrap_Integrator_copy, METH_O, (char *)"Integrator_copy(Integrator self) -> Integrator"},
- { (char *)"Integrator_integrate", (PyCFunction) _wrap_Integrator_integrate, METH_VARARGS | METH_KEYWORDS, (char *)"Integrator_integrate(Integrator self, Time t_max, Time dt) -> int"},
- { (char *)"Integrator_integrate_until", (PyCFunction) _wrap_Integrator_integrate_until, METH_VARARGS | METH_KEYWORDS, (char *)"Integrator_integrate_until(Integrator self, Time t_max, Time dt, bool reset=False)"},
{ (char *)"Integrator___getitem__", (PyCFunction) _wrap_Integrator___getitem__, METH_VARARGS | METH_KEYWORDS, (char *)"Integrator___getitem__(Integrator self, int index) -> cmf::math::StateVariable::ptr"},
{ (char *)"Integrator_swigregister", Integrator_swigregister, METH_VARARGS, NULL},
- { (char *)"BDF2_get_error_position", (PyCFunction)_wrap_BDF2_get_error_position, METH_O, (char *)"BDF2_get_error_position(BDF2 self) -> int"},
+ { (char *)"BDF2_get_error_position", (PyCFunction)_wrap_BDF2_get_error_position, METH_O, (char *)"\n"
+ "BDF2_get_error_position(BDF2 self) -> int\n"
+ "\n"
+ "int\n"
+ "get_error_position() const\n"
+ "\n"
+ "Returns the position of the biggest error. \n"
+ ""},
{ (char *)"BDF2_max_order_set", _wrap_BDF2_max_order_set, METH_VARARGS, (char *)"BDF2_max_order_set(BDF2 self, int max_order)"},
{ (char *)"BDF2_max_order_get", (PyCFunction)_wrap_BDF2_max_order_get, METH_O, (char *)"BDF2_max_order_get(BDF2 self) -> int"},
{ (char *)"new_BDF2", _wrap_new_BDF2, METH_VARARGS, (char *)"\n"
"BDF2(real epsilon=1e-9, Time tStepMin)\n"
"BDF2(StateVariableOwner states, real epsilon=1e-9, Time tStepMin)\n"
"new_BDF2(Integrator templ) -> BDF2\n"
+ "\n"
+ "BDF2(const Integrator\n"
+ "&templ)\n"
+ "\n"
+ "Constructs a new BDF2 integrator.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "templ: Template to be used to construct a BDF2 method \n"
""},
{ (char *)"delete_BDF2", (PyCFunction)_wrap_delete_BDF2, METH_O, (char *)"delete_BDF2(BDF2 self)"},
{ (char *)"BDF2_swigregister", BDF2_swigregister, METH_VARARGS, NULL},
@@ -74900,8 +75660,17 @@ static PyMethodDef SwigMethods[] = {
"ExplicitEuler_fixed(StateVariableOwner states)\n"
"ExplicitEuler_fixed()\n"
"new_ExplicitEuler_fixed(Integrator copy) -> ExplicitEuler_fixed\n"
+ "\n"
+ "ExplicitEuler_fixed(const Integrator ©)\n"
+ "\n"
+ "copy constructor \n"
+ ""},
+ { (char *)"delete_ExplicitEuler_fixed", (PyCFunction)_wrap_delete_ExplicitEuler_fixed, METH_O, (char *)"\n"
+ "delete_ExplicitEuler_fixed(ExplicitEuler_fixed self)\n"
+ "\n"
+ "virtual\n"
+ "~ExplicitEuler_fixed() \n"
""},
- { (char *)"delete_ExplicitEuler_fixed", (PyCFunction)_wrap_delete_ExplicitEuler_fixed, METH_O, (char *)"delete_ExplicitEuler_fixed(ExplicitEuler_fixed self)"},
{ (char *)"ExplicitEuler_fixed_swigregister", ExplicitEuler_fixed_swigregister, METH_VARARGS, NULL},
{ (char *)"ExplicitEuler_fixed_swiginit", ExplicitEuler_fixed_swiginit, METH_VARARGS, NULL},
{ (char *)"HeunIntegrator_alpha_set", _wrap_HeunIntegrator_alpha_set, METH_VARARGS, (char *)"HeunIntegrator_alpha_set(HeunIntegrator self, real alpha)"},
@@ -74910,8 +75679,16 @@ static PyMethodDef SwigMethods[] = {
"HeunIntegrator(StateVariableOwner states, real Alpha=0.5)\n"
"HeunIntegrator(real Alpha=0.5)\n"
"new_HeunIntegrator(Integrator copy) -> HeunIntegrator\n"
+ "\n"
+ "HeunIntegrator(const Integrator ©)\n"
+ "\n"
+ "copy constructor \n"
+ ""},
+ { (char *)"delete_HeunIntegrator", (PyCFunction)_wrap_delete_HeunIntegrator, METH_O, (char *)"\n"
+ "delete_HeunIntegrator(HeunIntegrator self)\n"
+ "\n"
+ "virtual ~HeunIntegrator() \n"
""},
- { (char *)"delete_HeunIntegrator", (PyCFunction)_wrap_delete_HeunIntegrator, METH_O, (char *)"delete_HeunIntegrator(HeunIntegrator self)"},
{ (char *)"HeunIntegrator_swigregister", HeunIntegrator_swigregister, METH_VARARGS, NULL},
{ (char *)"HeunIntegrator_swiginit", HeunIntegrator_swiginit, METH_VARARGS, NULL},
{ (char *)"ImplicitEuler_dt_min_set", _wrap_ImplicitEuler_dt_min_set, METH_VARARGS, (char *)"ImplicitEuler_dt_min_set(ImplicitEuler self, Time dt_min)"},
@@ -74920,6 +75697,10 @@ static PyMethodDef SwigMethods[] = {
"ImplicitEuler(StateVariableOwner states, real epsilon=1e-9, Time tStepMin)\n"
"ImplicitEuler(real epsilon=1e-9, Time tStepMin)\n"
"new_ImplicitEuler(Integrator arg2) -> ImplicitEuler\n"
+ "\n"
+ "ImplicitEuler(const Integrator &)\n"
+ "\n"
+ "copy constructor \n"
""},
{ (char *)"delete_ImplicitEuler", (PyCFunction)_wrap_delete_ImplicitEuler, METH_O, (char *)"delete_ImplicitEuler(ImplicitEuler self)"},
{ (char *)"ImplicitEuler_swigregister", ImplicitEuler_swigregister, METH_VARARGS, NULL},
@@ -74927,6 +75708,18 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"new_RKFIntegrator", _wrap_new_RKFIntegrator, METH_VARARGS, (char *)"\n"
"RKFIntegrator(StateVariableOwner states, real epsilon=1e-9, Time dt_min)\n"
"new_RKFIntegrator(real epsilon=1e-9, Time dt_min) -> RKFIntegrator\n"
+ "\n"
+ "RKFIntegrator(real epsilon=1e-9, cmf::math::Time\n"
+ "dt_min=cmf::math::timespan(1000))\n"
+ "\n"
+ "Constructs a new RKFIntegrator.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "epsilon: relative error tolerance per time step (default=1e-9)\n"
+ "\n"
+ "dt_min: minimum time step (default=1s) \n"
""},
{ (char *)"delete_RKFIntegrator", (PyCFunction)_wrap_delete_RKFIntegrator, METH_O, (char *)"delete_RKFIntegrator(RKFIntegrator self)"},
{ (char *)"RKFIntegrator_swigregister", RKFIntegrator_swigregister, METH_VARARGS, NULL},
@@ -74947,33 +75740,172 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"CVodeIntegrator_MaxOrder_get", (PyCFunction)_wrap_CVodeIntegrator_MaxOrder_get, METH_O, (char *)"CVodeIntegrator_MaxOrder_get(CVodeIntegrator self) -> int"},
{ (char *)"CVodeIntegrator_max_step_set", _wrap_CVodeIntegrator_max_step_set, METH_VARARGS, (char *)"CVodeIntegrator_max_step_set(CVodeIntegrator self, Time max_step)"},
{ (char *)"CVodeIntegrator_max_step_get", (PyCFunction)_wrap_CVodeIntegrator_max_step_get, METH_O, (char *)"CVodeIntegrator_max_step_get(CVodeIntegrator self) -> Time"},
- { (char *)"CVodeIntegrator_initialize", (PyCFunction)_wrap_CVodeIntegrator_initialize, METH_O, (char *)"CVodeIntegrator_initialize(CVodeIntegrator self)"},
- { (char *)"CVodeIntegrator_release", (PyCFunction)_wrap_CVodeIntegrator_release, METH_O, (char *)"CVodeIntegrator_release(CVodeIntegrator self)"},
+ { (char *)"CVodeIntegrator_initialize", (PyCFunction)_wrap_CVodeIntegrator_initialize, METH_O, (char *)"\n"
+ "CVodeIntegrator_initialize(CVodeIntegrator self)\n"
+ "\n"
+ "void\n"
+ "initialize()\n"
+ "\n"
+ "Initializes the solver. Do not add or remove state variables after\n"
+ "initialization. The solver is automatically intialized when\n"
+ "integrating. \n"
+ ""},
+ { (char *)"CVodeIntegrator_release", (PyCFunction)_wrap_CVodeIntegrator_release, METH_O, (char *)"\n"
+ "CVodeIntegrator_release(CVodeIntegrator self)\n"
+ "\n"
+ "void\n"
+ "release()\n"
+ "\n"
+ "Releases the internal solver. Call release before you add state\n"
+ "variables or to change properties. \n"
+ ""},
{ (char *)"new_CVodeIntegrator", _wrap_new_CVodeIntegrator, METH_VARARGS, (char *)"\n"
"CVodeIntegrator(real epsilon=1e-9, char _preconditioner)\n"
"CVodeIntegrator(StateVariableOwner states, real epsilon=1e-9, char _preconditioner)\n"
"new_CVodeIntegrator(CVodeIntegrator templ) -> CVodeIntegrator\n"
+ "\n"
+ "CVodeIntegrator(const CVodeIntegrator &templ)\n"
+ "\n"
+ "copy constructor, creates a new CVODE integrator similiar to the\n"
+ "given, but without statevariables \n"
+ ""},
+ { (char *)"CVodeIntegrator_get_error", (PyCFunction)_wrap_CVodeIntegrator_get_error, METH_O, (char *)"\n"
+ "CVodeIntegrator_get_error(CVodeIntegrator self) -> cmf::math::num_array\n"
+ "\n"
+ "cmf::math::num_array get_error() const\n"
+ "\n"
+ "Error vector of the integrator. \n"
+ ""},
+ { (char *)"CVodeIntegrator_get_nonlinear_iterations", (PyCFunction)_wrap_CVodeIntegrator_get_nonlinear_iterations, METH_O, (char *)"\n"
+ "CVodeIntegrator_get_nonlinear_iterations(CVodeIntegrator self) -> int\n"
+ "\n"
+ "int\n"
+ "get_nonlinear_iterations() const\n"
+ "\n"
+ "Returns the number of non-linear iterations performed. Calls\n"
+ "CVodeGetNumNonlinSolvIters. \n"
+ ""},
+ { (char *)"CVodeIntegrator_get_rhsevals", (PyCFunction)_wrap_CVodeIntegrator_get_rhsevals, METH_O, (char *)"\n"
+ "CVodeIntegrator_get_rhsevals(CVodeIntegrator self) -> int\n"
+ "\n"
+ "int\n"
+ "get_rhsevals() const\n"
+ "\n"
+ "Returns the number of evaluations of the right hand side of the ODE.\n"
+ "Calls CVodeGetNumRhsEvals. \n"
+ ""},
+ { (char *)"CVodeIntegrator_copy", (PyCFunction)_wrap_CVodeIntegrator_copy, METH_O, (char *)"\n"
+ "CVodeIntegrator_copy(CVodeIntegrator self) -> CVodeIntegrator\n"
+ "\n"
+ "CVodeIntegrator* copy() const\n"
+ "\n"
+ "Polymorphic copy constructor. \n"
+ ""},
+ { (char *)"delete_CVodeIntegrator", (PyCFunction)_wrap_delete_CVodeIntegrator, METH_O, (char *)"\n"
+ "delete_CVodeIntegrator(CVodeIntegrator self)\n"
+ "\n"
+ "virtual ~CVodeIntegrator() \n"
""},
- { (char *)"CVodeIntegrator_get_error", (PyCFunction)_wrap_CVodeIntegrator_get_error, METH_O, (char *)"CVodeIntegrator_get_error(CVodeIntegrator self) -> cmf::math::num_array"},
- { (char *)"CVodeIntegrator_get_nonlinear_iterations", (PyCFunction)_wrap_CVodeIntegrator_get_nonlinear_iterations, METH_O, (char *)"CVodeIntegrator_get_nonlinear_iterations(CVodeIntegrator self) -> int"},
- { (char *)"CVodeIntegrator_get_rhsevals", (PyCFunction)_wrap_CVodeIntegrator_get_rhsevals, METH_O, (char *)"CVodeIntegrator_get_rhsevals(CVodeIntegrator self) -> int"},
- { (char *)"CVodeIntegrator_copy", (PyCFunction)_wrap_CVodeIntegrator_copy, METH_O, (char *)"CVodeIntegrator_copy(CVodeIntegrator self) -> CVodeIntegrator"},
- { (char *)"delete_CVodeIntegrator", (PyCFunction)_wrap_delete_CVodeIntegrator, METH_O, (char *)"delete_CVodeIntegrator(CVodeIntegrator self)"},
{ (char *)"CVodeIntegrator_order_get", (PyCFunction)_wrap_CVodeIntegrator_order_get, METH_O, (char *)"CVodeIntegrator_order_get(CVodeIntegrator self) -> int"},
{ (char *)"CVodeIntegrator_swigregister", CVodeIntegrator_swigregister, METH_VARARGS, NULL},
{ (char *)"CVodeIntegrator_swiginit", CVodeIntegrator_swiginit, METH_VARARGS, NULL},
- { (char *)"MultiIntegrator_copy", (PyCFunction)_wrap_MultiIntegrator_copy, METH_O, (char *)"MultiIntegrator_copy(MultiIntegrator self) -> MultiIntegrator"},
- { (char *)"MultiIntegrator_add_states_to_integrator", (PyCFunction) _wrap_MultiIntegrator_add_states_to_integrator, METH_VARARGS | METH_KEYWORDS, (char *)"MultiIntegrator_add_states_to_integrator(MultiIntegrator self, StateVariableOwner stateOwner, int integrator_position)"},
- { (char *)"new_MultiIntegrator", (PyCFunction) _wrap_new_MultiIntegrator, METH_VARARGS | METH_KEYWORDS, (char *)"new_MultiIntegrator(Integrator template_integrator, int count) -> MultiIntegrator"},
+ { (char *)"MultiIntegrator_copy", (PyCFunction)_wrap_MultiIntegrator_copy, METH_O, (char *)"\n"
+ "MultiIntegrator_copy(MultiIntegrator self) -> MultiIntegrator\n"
+ "\n"
+ "virtual\n"
+ "cmf::math::MultiIntegrator* copy() const\n"
+ "\n"
+ "Polymorphic copy constructor. \n"
+ ""},
+ { (char *)"MultiIntegrator_add_states_to_integrator", (PyCFunction) _wrap_MultiIntegrator_add_states_to_integrator, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "MultiIntegrator_add_states_to_integrator(MultiIntegrator self, StateVariableOwner stateOwner, int integrator_position)\n"
+ "\n"
+ "void\n"
+ "add_states_to_integrator(cmf::math::StateVariableOwner &stateOwner,\n"
+ "int integrator_position)\n"
+ "\n"
+ "Add state variables from a StateVariableOwner. \n"
+ ""},
+ { (char *)"new_MultiIntegrator", (PyCFunction) _wrap_new_MultiIntegrator, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_MultiIntegrator(Integrator template_integrator, int count) -> MultiIntegrator\n"
+ "\n"
+ "MultiIntegrator(const cmf::math::Integrator &template_integrator, int\n"
+ "count)\n"
+ "\n"
+ "Creates a new MultiIntegrator.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "template_integrator: Template for the integrators\n"
+ "\n"
+ "count: Number of integrators \n"
+ ""},
{ (char *)"delete_MultiIntegrator", (PyCFunction)_wrap_delete_MultiIntegrator, METH_O, (char *)"delete_MultiIntegrator(MultiIntegrator self)"},
{ (char *)"MultiIntegrator_swigregister", MultiIntegrator_swigregister, METH_VARARGS, NULL},
{ (char *)"MultiIntegrator_swiginit", MultiIntegrator_swiginit, METH_VARARGS, NULL},
- { (char *)"Adsorption_freesolute", (PyCFunction) _wrap_Adsorption_freesolute, METH_VARARGS | METH_KEYWORDS, (char *)"Adsorption_freesolute(Adsorption self, real xt, real V) -> real"},
- { (char *)"Adsorption_totalsolute", (PyCFunction) _wrap_Adsorption_totalsolute, METH_VARARGS | METH_KEYWORDS, (char *)"Adsorption_totalsolute(Adsorption self, real xf, real V) -> real"},
- { (char *)"Adsorption_copy", (PyCFunction) _wrap_Adsorption_copy, METH_VARARGS | METH_KEYWORDS, (char *)"Adsorption_copy(Adsorption self, real m=-1) -> Adsorption"},
+ { (char *)"Adsorption_freesolute", (PyCFunction) _wrap_Adsorption_freesolute, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Adsorption_freesolute(Adsorption self, real xt, real V) -> real\n"
+ "\n"
+ "virtual\n"
+ "real freesolute(real xt, real V) const =0\n"
+ "\n"
+ "Returns the mass of dissolved tracer as a function of the total tracer\n"
+ "mass in the solute storage and the water volume.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "xt: :math:`x_t` the total tracer mass in the storage\n"
+ "\n"
+ "V: :math:`V m^3` the water volume in the storage\n"
+ "\n"
+ ":math:`x_f` the dissolved mass of the tracer \n"
+ ""},
+ { (char *)"Adsorption_totalsolute", (PyCFunction) _wrap_Adsorption_totalsolute, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Adsorption_totalsolute(Adsorption self, real xf, real V) -> real\n"
+ "\n"
+ "virtual\n"
+ "real totalsolute(real xf, real V) const =0\n"
+ "\n"
+ "Returns the total mass of the tracer from the dissolved concetration\n"
+ "in tracer unit/m3.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "xf: :math:`x_f` the dissolved tracer mass in the storage\n"
+ "\n"
+ "V: :math:`V m^3` the water volume in the storage\n"
+ "\n"
+ ":math:`x_t` the total mass of the tracer \n"
+ ""},
+ { (char *)"Adsorption_copy", (PyCFunction) _wrap_Adsorption_copy, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Adsorption_copy(Adsorption self, real m=-1) -> Adsorption\n"
+ "\n"
+ "virtual\n"
+ "Adsorption* copy(real m=-1) const =0\n"
+ "\n"
+ "returns a copy of the Adsorption object.\n"
+ "\n"
+ "If the adsorption is depending on the sorbent mass, you can give a\n"
+ "positive value for the sorbent mass m. If the value is not given or\n"
+ "negative, m is used from the original object. \n"
+ ""},
{ (char *)"delete_Adsorption", (PyCFunction)_wrap_delete_Adsorption, METH_O, (char *)"delete_Adsorption(Adsorption self)"},
{ (char *)"Adsorption_swigregister", Adsorption_swigregister, METH_VARARGS, NULL},
- { (char *)"NullAdsorption_copy", (PyCFunction) _wrap_NullAdsorption_copy, METH_VARARGS | METH_KEYWORDS, (char *)"NullAdsorption_copy(NullAdsorption self, real m=-1) -> NullAdsorption"},
+ { (char *)"NullAdsorption_copy", (PyCFunction) _wrap_NullAdsorption_copy, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "NullAdsorption_copy(NullAdsorption self, real m=-1) -> NullAdsorption\n"
+ "\n"
+ "virtual\n"
+ "NullAdsorption* copy(real m=-1) const\n"
+ "\n"
+ "returns a copy of the Adsorption object.\n"
+ "\n"
+ "If the adsorption is depending on the sorbent mass, you can give a\n"
+ "positive value for the sorbent mass m. If the value is not given or\n"
+ "negative, m is used from the original object. \n"
+ ""},
{ (char *)"new_NullAdsorption", (PyCFunction)_wrap_new_NullAdsorption, METH_NOARGS, (char *)"new_NullAdsorption() -> NullAdsorption"},
{ (char *)"delete_NullAdsorption", (PyCFunction)_wrap_delete_NullAdsorption, METH_O, (char *)"delete_NullAdsorption(NullAdsorption self)"},
{ (char *)"NullAdsorption_swigregister", NullAdsorption_swigregister, METH_VARARGS, NULL},
@@ -74985,8 +75917,20 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"new_LinearAdsorption", _wrap_new_LinearAdsorption, METH_VARARGS, (char *)"\n"
"LinearAdsorption(real K, real m)\n"
"new_LinearAdsorption(LinearAdsorption other) -> LinearAdsorption\n"
+ "\n"
+ "LinearAdsorption(const LinearAdsorption &other) \n"
+ ""},
+ { (char *)"LinearAdsorption_copy", (PyCFunction) _wrap_LinearAdsorption_copy, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "LinearAdsorption_copy(LinearAdsorption self, real m=-1) -> LinearAdsorption\n"
+ "\n"
+ "LinearAdsorption* copy(real m=-1) const\n"
+ "\n"
+ "returns a copy of the Adsorption object.\n"
+ "\n"
+ "If the adsorption is depending on the sorbent mass, you can give a\n"
+ "positive value for the sorbent mass m. If the value is not given or\n"
+ "negative, m is used from the original object. \n"
""},
- { (char *)"LinearAdsorption_copy", (PyCFunction) _wrap_LinearAdsorption_copy, METH_VARARGS | METH_KEYWORDS, (char *)"LinearAdsorption_copy(LinearAdsorption self, real m=-1) -> LinearAdsorption"},
{ (char *)"delete_LinearAdsorption", (PyCFunction)_wrap_delete_LinearAdsorption, METH_O, (char *)"delete_LinearAdsorption(LinearAdsorption self)"},
{ (char *)"LinearAdsorption_swigregister", LinearAdsorption_swigregister, METH_VARARGS, NULL},
{ (char *)"LinearAdsorption_swiginit", LinearAdsorption_swiginit, METH_VARARGS, NULL},
@@ -75003,8 +75947,20 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"new_FreundlichAdsorbtion", _wrap_new_FreundlichAdsorbtion, METH_VARARGS, (char *)"\n"
"FreundlichAdsorbtion(real K, real n, real m, real epsilon=1e-12, int maxiter=100)\n"
"new_FreundlichAdsorbtion(FreundlichAdsorbtion other) -> FreundlichAdsorbtion\n"
+ "\n"
+ "FreundlichAdsorbtion(const FreundlichAdsorbtion &other) \n"
+ ""},
+ { (char *)"FreundlichAdsorbtion_copy", (PyCFunction) _wrap_FreundlichAdsorbtion_copy, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "FreundlichAdsorbtion_copy(FreundlichAdsorbtion self, real m=-1) -> FreundlichAdsorbtion\n"
+ "\n"
+ "FreundlichAdsorbtion* copy(real m=-1) const\n"
+ "\n"
+ "returns a copy of the Adsorption object.\n"
+ "\n"
+ "If the adsorption is depending on the sorbent mass, you can give a\n"
+ "positive value for the sorbent mass m. If the value is not given or\n"
+ "negative, m is used from the original object. \n"
""},
- { (char *)"FreundlichAdsorbtion_copy", (PyCFunction) _wrap_FreundlichAdsorbtion_copy, METH_VARARGS | METH_KEYWORDS, (char *)"FreundlichAdsorbtion_copy(FreundlichAdsorbtion self, real m=-1) -> FreundlichAdsorbtion"},
{ (char *)"delete_FreundlichAdsorbtion", (PyCFunction)_wrap_delete_FreundlichAdsorbtion, METH_O, (char *)"delete_FreundlichAdsorbtion(FreundlichAdsorbtion self)"},
{ (char *)"FreundlichAdsorbtion_swigregister", FreundlichAdsorbtion_swigregister, METH_VARARGS, NULL},
{ (char *)"FreundlichAdsorbtion_swiginit", FreundlichAdsorbtion_swiginit, METH_VARARGS, NULL},
@@ -75015,12 +75971,29 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"new_LangmuirAdsorption", _wrap_new_LangmuirAdsorption, METH_VARARGS, (char *)"\n"
"LangmuirAdsorption(real K, real m)\n"
"new_LangmuirAdsorption(LangmuirAdsorption other) -> LangmuirAdsorption\n"
+ "\n"
+ "LangmuirAdsorption(const LangmuirAdsorption &other) \n"
+ ""},
+ { (char *)"LangmuirAdsorption_copy", (PyCFunction) _wrap_LangmuirAdsorption_copy, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "LangmuirAdsorption_copy(LangmuirAdsorption self, real m=-1) -> LangmuirAdsorption\n"
+ "\n"
+ "LangmuirAdsorption* copy(real m=-1) const\n"
+ "\n"
+ "returns a copy of the Adsorption object.\n"
+ "\n"
+ "If the adsorption is depending on the sorbent mass, you can give a\n"
+ "positive value for the sorbent mass m. If the value is not given or\n"
+ "negative, m is used from the original object. \n"
""},
- { (char *)"LangmuirAdsorption_copy", (PyCFunction) _wrap_LangmuirAdsorption_copy, METH_VARARGS | METH_KEYWORDS, (char *)"LangmuirAdsorption_copy(LangmuirAdsorption self, real m=-1) -> LangmuirAdsorption"},
{ (char *)"delete_LangmuirAdsorption", (PyCFunction)_wrap_delete_LangmuirAdsorption, METH_O, (char *)"delete_LangmuirAdsorption(LangmuirAdsorption self)"},
{ (char *)"LangmuirAdsorption_swigregister", LangmuirAdsorption_swigregister, METH_VARARGS, NULL},
{ (char *)"LangmuirAdsorption_swiginit", LangmuirAdsorption_swiginit, METH_VARARGS, NULL},
- { (char *)"new_solute", (PyCFunction) _wrap_new_solute, METH_VARARGS | METH_KEYWORDS, (char *)"new_solute(solute copy) -> solute"},
+ { (char *)"new_solute", (PyCFunction) _wrap_new_solute, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_solute(solute copy) -> solute\n"
+ "\n"
+ "solute(const\n"
+ "solute ©) \n"
+ ""},
{ (char *)"solute___eq__", (PyCFunction) _wrap_solute___eq__, METH_VARARGS | METH_KEYWORDS, (char *)"solute___eq__(solute self, solute cmp) -> bool"},
{ (char *)"solute___lt__", (PyCFunction) _wrap_solute___lt__, METH_VARARGS | METH_KEYWORDS, (char *)"solute___lt__(solute self, solute cmp) -> bool"},
{ (char *)"solute___gt__", (PyCFunction) _wrap_solute___gt__, METH_VARARGS | METH_KEYWORDS, (char *)"solute___gt__(solute self, solute cmp) -> bool"},
@@ -75038,20 +76011,50 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"delete_solute", (PyCFunction)_wrap_delete_solute, METH_O, (char *)"delete_solute(solute self)"},
{ (char *)"solute_swigregister", solute_swigregister, METH_VARARGS, NULL},
{ (char *)"solute_swiginit", solute_swiginit, METH_VARARGS, NULL},
- { (char *)"solute_vector_size", (PyCFunction)_wrap_solute_vector_size, METH_O, (char *)"solute_vector_size(solute_vector self) -> size_t"},
- { (char *)"new_solute_vector", (PyCFunction) _wrap_new_solute_vector, METH_VARARGS | METH_KEYWORDS, (char *)"new_solute_vector(std::string str) -> solute_vector"},
- { (char *)"solute_vector_get_solute", (PyCFunction) _wrap_solute_vector_get_solute, METH_VARARGS | METH_KEYWORDS, (char *)"solute_vector_get_solute(solute_vector self, int position) -> solute"},
+ { (char *)"solute_vector_size", (PyCFunction)_wrap_solute_vector_size, METH_O, (char *)"\n"
+ "solute_vector_size(solute_vector self) -> size_t\n"
+ "\n"
+ "size_t size()\n"
+ "const \n"
+ ""},
+ { (char *)"new_solute_vector", (PyCFunction) _wrap_new_solute_vector, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_solute_vector(std::string str) -> solute_vector\n"
+ "\n"
+ "solute_vector(std::string str)\n"
+ "\n"
+ "Creates a solute vector from solute names, separated by whitespace.\n"
+ "E.g. solutes= solute_vector(\"dO18 dH2\") \n"
+ ""},
+ { (char *)"solute_vector_get_solute", (PyCFunction) _wrap_solute_vector_get_solute, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "solute_vector_get_solute(solute_vector self, int position) -> solute\n"
+ "\n"
+ "cmf::water::solute* get_solute(int position) \n"
+ ""},
{ (char *)"solute_vector___getitem__", (PyCFunction) _wrap_solute_vector___getitem__, METH_VARARGS | METH_KEYWORDS, (char *)"solute_vector___getitem__(solute_vector self, int i) -> solute"},
{ (char *)"solute_vector___len__", (PyCFunction)_wrap_solute_vector___len__, METH_O, (char *)"solute_vector___len__(solute_vector self) -> size_t"},
{ (char *)"delete_solute_vector", (PyCFunction)_wrap_delete_solute_vector, METH_O, (char *)"delete_solute_vector(solute_vector self)"},
{ (char *)"solute_vector_swigregister", solute_vector_swigregister, METH_VARARGS, NULL},
{ (char *)"solute_vector_swiginit", solute_vector_swiginit, METH_VARARGS, NULL},
- { (char *)"SoluteTimeseries_conc", (PyCFunction) _wrap_SoluteTimeseries_conc, METH_VARARGS | METH_KEYWORDS, (char *)"SoluteTimeseries_conc(SoluteTimeseries self, Time t, solute _Solute) -> real"},
- { (char *)"SoluteTimeseries_size", (PyCFunction)_wrap_SoluteTimeseries_size, METH_O, (char *)"SoluteTimeseries_size(SoluteTimeseries self) -> size_t"},
+ { (char *)"SoluteTimeseries_conc", (PyCFunction) _wrap_SoluteTimeseries_conc, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "SoluteTimeseries_conc(SoluteTimeseries self, Time t, solute _Solute) -> real\n"
+ "\n"
+ "real\n"
+ "conc(cmf::math::Time t, const cmf::water::solute &_Solute) const \n"
+ ""},
+ { (char *)"SoluteTimeseries_size", (PyCFunction)_wrap_SoluteTimeseries_size, METH_O, (char *)"\n"
+ "SoluteTimeseries_size(SoluteTimeseries self) -> size_t\n"
+ "\n"
+ "size_t\n"
+ "size() const\n"
+ "\n"
+ "Returns the number of solutes in the solution. \n"
+ ""},
{ (char *)"new_SoluteTimeseries", _wrap_new_SoluteTimeseries, METH_VARARGS, (char *)"\n"
"SoluteTimeseries()\n"
"SoluteTimeseries(solute_vector solutes, Time begin, Time step)\n"
"new_SoluteTimeseries(SoluteTimeseries sts) -> SoluteTimeseries\n"
+ "\n"
+ "SoluteTimeseries(const cmf::water::SoluteTimeseries &sts) \n"
""},
{ (char *)"SoluteTimeseries___getitem__", (PyCFunction) _wrap_SoluteTimeseries___getitem__, METH_VARARGS | METH_KEYWORDS, (char *)"SoluteTimeseries___getitem__(SoluteTimeseries self, solute solute) -> timeseries"},
{ (char *)"SoluteTimeseries___setitem__", (PyCFunction) _wrap_SoluteTimeseries___setitem__, METH_VARARGS | METH_KEYWORDS, (char *)"SoluteTimeseries___setitem__(SoluteTimeseries self, solute solute, timeseries concentration)"},
@@ -75059,94 +76062,377 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"delete_SoluteTimeseries", (PyCFunction)_wrap_delete_SoluteTimeseries, METH_O, (char *)"delete_SoluteTimeseries(SoluteTimeseries self)"},
{ (char *)"SoluteTimeseries_swigregister", SoluteTimeseries_swigregister, METH_VARARGS, NULL},
{ (char *)"SoluteTimeseries_swiginit", SoluteTimeseries_swiginit, METH_VARARGS, NULL},
- { (char *)"SoluteStorage_set_adsorption", (PyCFunction) _wrap_SoluteStorage_set_adsorption, METH_VARARGS | METH_KEYWORDS, (char *)"SoluteStorage_set_adsorption(SoluteStorage self, Adsorption newadsorption, real m=-1)"},
+ { (char *)"SoluteStorage_set_adsorption", (PyCFunction) _wrap_SoluteStorage_set_adsorption, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "SoluteStorage_set_adsorption(SoluteStorage self, Adsorption newadsorption, real m=-1)\n"
+ "\n"
+ "void set_adsorption(const Adsorption &newadsorption, real m=-1) \n"
+ ""},
{ (char *)"SoluteStorage_decay_set", _wrap_SoluteStorage_decay_set, METH_VARARGS, (char *)"SoluteStorage_decay_set(SoluteStorage self, real decay)"},
{ (char *)"SoluteStorage_decay_get", (PyCFunction)_wrap_SoluteStorage_decay_get, METH_O, (char *)"SoluteStorage_decay_get(SoluteStorage self) -> real"},
{ (char *)"SoluteStorage_source_set", _wrap_SoluteStorage_source_set, METH_VARARGS, (char *)"SoluteStorage_source_set(SoluteStorage self, real source)"},
{ (char *)"SoluteStorage_source_get", (PyCFunction)_wrap_SoluteStorage_source_get, METH_O, (char *)"SoluteStorage_source_get(SoluteStorage self) -> real"},
{ (char *)"SoluteStorage_Solute_get", (PyCFunction)_wrap_SoluteStorage_Solute_get, METH_O, (char *)"SoluteStorage_Solute_get(SoluteStorage self) -> solute"},
- { (char *)"SoluteStorage_conc", (PyCFunction)_wrap_SoluteStorage_conc, METH_O, (char *)"SoluteStorage_conc(SoluteStorage self) -> real"},
- { (char *)"SoluteStorage_set_conc", (PyCFunction) _wrap_SoluteStorage_set_conc, METH_VARARGS | METH_KEYWORDS, (char *)"SoluteStorage_set_conc(SoluteStorage self, real NewConcentration)"},
+ { (char *)"SoluteStorage_conc", (PyCFunction)_wrap_SoluteStorage_conc, METH_O, (char *)"\n"
+ "SoluteStorage_conc(SoluteStorage self) -> real\n"
+ "\n"
+ "real conc()\n"
+ "const\n"
+ "\n"
+ "Returns the concentration of the solute. \n"
+ ""},
+ { (char *)"SoluteStorage_set_conc", (PyCFunction) _wrap_SoluteStorage_set_conc, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "SoluteStorage_set_conc(SoluteStorage self, real NewConcentration)\n"
+ "\n"
+ "void\n"
+ "set_conc(real NewConcentration)\n"
+ "\n"
+ "set a new concentration of dissolved tracers.\n"
+ "\n"
+ "In case of adsorption functions, the isotherm is used \n"
+ ""},
{ (char *)"delete_SoluteStorage", (PyCFunction)_wrap_delete_SoluteStorage, METH_O, (char *)"delete_SoluteStorage(SoluteStorage self)"},
{ (char *)"SoluteStorage_swigregister", SoluteStorage_swigregister, METH_VARARGS, NULL},
{ (char *)"flux_node_node_id_get", (PyCFunction)_wrap_flux_node_node_id_get, METH_O, (char *)"flux_node_node_id_get(flux_node self) -> int const"},
- { (char *)"flux_node_is_storage", (PyCFunction)_wrap_flux_node_is_storage, METH_O, (char *)"flux_node_is_storage(flux_node self) -> bool"},
+ { (char *)"flux_node_is_storage", (PyCFunction)_wrap_flux_node_is_storage, METH_O, (char *)"\n"
+ "flux_node_is_storage(flux_node self) -> bool\n"
+ "\n"
+ "virtual\n"
+ "bool is_storage() const\n"
+ "\n"
+ "true, if this is a waterstorage \n"
+ ""},
{ (char *)"flux_node_Name_set", _wrap_flux_node_Name_set, METH_VARARGS, (char *)"flux_node_Name_set(flux_node self, std::string const & Name)"},
{ (char *)"flux_node_Name_get", (PyCFunction)_wrap_flux_node_Name_get, METH_O, (char *)"flux_node_Name_get(flux_node self) -> std::string const &"},
- { (char *)"flux_node_to_string", (PyCFunction)_wrap_flux_node_to_string, METH_O, (char *)"flux_node_to_string(flux_node self) -> std::string"},
- { (char *)"delete_flux_node", (PyCFunction)_wrap_delete_flux_node, METH_O, (char *)"delete_flux_node(flux_node self)"},
+ { (char *)"flux_node_to_string", (PyCFunction)_wrap_flux_node_to_string, METH_O, (char *)"\n"
+ "flux_node_to_string(flux_node self) -> std::string\n"
+ "\n"
+ "virtual\n"
+ "std::string to_string() const \n"
+ ""},
+ { (char *)"delete_flux_node", (PyCFunction)_wrap_delete_flux_node, METH_O, (char *)"\n"
+ "delete_flux_node(flux_node self)\n"
+ "\n"
+ "virtual\n"
+ "~flux_node()\n"
+ "\n"
+ "The destructor deletes all connections. \n"
+ ""},
{ (char *)"flux_node___eq__", (PyCFunction) _wrap_flux_node___eq__, METH_VARARGS | METH_KEYWORDS, (char *)"flux_node___eq__(flux_node self, flux_node other) -> bool"},
- { (char *)"flux_node_RecalcFluxes", (PyCFunction) _wrap_flux_node_RecalcFluxes, METH_VARARGS | METH_KEYWORDS, (char *)"flux_node_RecalcFluxes(flux_node self, Time t) -> bool"},
- { (char *)"flux_node_connection_to", (PyCFunction) _wrap_flux_node_connection_to, METH_VARARGS | METH_KEYWORDS, (char *)"flux_node_connection_to(flux_node self, flux_node target) -> flux_connection"},
- { (char *)"flux_node_remove_connection", (PyCFunction) _wrap_flux_node_remove_connection, METH_VARARGS | METH_KEYWORDS, (char *)"flux_node_remove_connection(flux_node self, cmf::water::flux_node::ptr To) -> bool"},
- { (char *)"flux_node_flux_to", (PyCFunction) _wrap_flux_node_flux_to, METH_VARARGS | METH_KEYWORDS, (char *)"flux_node_flux_to(flux_node self, flux_node target, Time t) -> real"},
- { (char *)"flux_node_flux3d_to", (PyCFunction) _wrap_flux_node_flux3d_to, METH_VARARGS | METH_KEYWORDS, (char *)"flux_node_flux3d_to(flux_node self, flux_node target, Time t) -> point"},
- { (char *)"flux_node_get_3d_flux", (PyCFunction) _wrap_flux_node_get_3d_flux, METH_VARARGS | METH_KEYWORDS, (char *)"flux_node_get_3d_flux(flux_node self, Time t) -> point"},
- { (char *)"flux_node_waterbalance", (PyCFunction) _wrap_flux_node_waterbalance, METH_VARARGS | METH_KEYWORDS, (char *)"flux_node_waterbalance(flux_node self, Time t, flux_connection Without=None) -> real"},
+ { (char *)"flux_node_RecalcFluxes", (PyCFunction) _wrap_flux_node_RecalcFluxes, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "flux_node_RecalcFluxes(flux_node self, Time t) -> bool\n"
+ "\n"
+ "virtual\n"
+ "bool RecalcFluxes(cmf::math::Time t)\n"
+ "\n"
+ "Pure flux_nodes do not influence fluxes, therefore no recalculation of\n"
+ "fluxes is required by flux_node.\n"
+ "\n"
+ "WaterStorage overrides this, since state changes require an update of\n"
+ "the fluxes \n"
+ ""},
+ { (char *)"flux_node_connection_to", (PyCFunction) _wrap_flux_node_connection_to, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "flux_node_connection_to(flux_node self, flux_node target) -> flux_connection\n"
+ "\n"
+ "cmf::water::flux_connection* connection_to(const cmf::water::flux_node\n"
+ "&target)\n"
+ "\n"
+ "Returns the connection between this and target. \n"
+ ""},
+ { (char *)"flux_node_remove_connection", (PyCFunction) _wrap_flux_node_remove_connection, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "flux_node_remove_connection(flux_node self, cmf::water::flux_node::ptr To) -> bool\n"
+ "\n"
+ "bool\n"
+ "remove_connection(cmf::water::flux_node::ptr To)\n"
+ "\n"
+ "Remove the connection. \n"
+ ""},
+ { (char *)"flux_node_flux_to", (PyCFunction) _wrap_flux_node_flux_to, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "flux_node_flux_to(flux_node self, flux_node target, Time t) -> real\n"
+ "\n"
+ "real\n"
+ "flux_to(const cmf::water::flux_node &target, cmf::math::Time t)\n"
+ "\n"
+ "Returns the actual flux between this and target (positive sign means\n"
+ "\"from this into target\") \n"
+ ""},
+ { (char *)"flux_node_flux3d_to", (PyCFunction) _wrap_flux_node_flux3d_to, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "flux_node_flux3d_to(flux_node self, flux_node target, Time t) -> point\n"
+ "\n"
+ "cmf::geometry::point flux3d_to(const cmf::water::flux_node &target,\n"
+ "cmf::math::Time t) \n"
+ ""},
+ { (char *)"flux_node_get_3d_flux", (PyCFunction) _wrap_flux_node_get_3d_flux, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "flux_node_get_3d_flux(flux_node self, Time t) -> point\n"
+ "\n"
+ "cmf::geometry::point get_3d_flux(cmf::math::Time t)\n"
+ "\n"
+ "Returns the sum of all flux vectors. \n"
+ ""},
+ { (char *)"flux_node_waterbalance", (PyCFunction) _wrap_flux_node_waterbalance, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "flux_node_waterbalance(flux_node self, Time t, flux_connection Without=None) -> real\n"
+ "\n"
+ "real\n"
+ "waterbalance(cmf::math::Time t, const flux_connection *Without=0)\n"
+ "const\n"
+ "\n"
+ "Returns the sum of all fluxes (positive and negative) at time t.\n"
+ "\n"
+ "Single fluxes can be excluded from the calculation\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "t: Time of the query\n"
+ "\n"
+ "Without: A flux_connection that is excluded from the waterbalance\n"
+ "(e.g. to prevent closed circuits) \n"
+ ""},
{ (char *)"flux_node___call__", (PyCFunction) _wrap_flux_node___call__, METH_VARARGS | METH_KEYWORDS, (char *)"flux_node___call__(flux_node self, Time t) -> real"},
- { (char *)"flux_node_conc", (PyCFunction) _wrap_flux_node_conc, METH_VARARGS | METH_KEYWORDS, (char *)"flux_node_conc(flux_node self, Time t, solute Solute) -> real"},
+ { (char *)"flux_node_conc", (PyCFunction) _wrap_flux_node_conc, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "flux_node_conc(flux_node self, Time t, solute Solute) -> real\n"
+ "\n"
+ "virtual real\n"
+ "conc(cmf::math::Time t, const cmf::water::solute &Solute) const\n"
+ "\n"
+ "Returns the water quality of the flux_node, if it is not overridden\n"
+ "this is the mix of the incoming fluxes. \n"
+ ""},
{ (char *)"flux_node_position_set", _wrap_flux_node_position_set, METH_VARARGS, (char *)"flux_node_position_set(flux_node self, point position)"},
{ (char *)"flux_node_position_get", (PyCFunction)_wrap_flux_node_position_get, METH_O, (char *)"flux_node_position_get(flux_node self) -> point"},
- { (char *)"flux_node_is_empty", (PyCFunction)_wrap_flux_node_is_empty, METH_O, (char *)"flux_node_is_empty(flux_node self) -> double"},
- { (char *)"new_flux_node", (PyCFunction) _wrap_new_flux_node, METH_VARARGS | METH_KEYWORDS, (char *)"new_flux_node(project _project, point location) -> flux_node"},
+ { (char *)"flux_node_is_empty", (PyCFunction)_wrap_flux_node_is_empty, METH_O, (char *)"\n"
+ "flux_node_is_empty(flux_node self) -> double\n"
+ "\n"
+ "virtual\n"
+ "double is_empty() const\n"
+ "\n"
+ "Returns true if the node has no water. \n"
+ ""},
+ { (char *)"new_flux_node", (PyCFunction) _wrap_new_flux_node, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_flux_node(project _project, point location) -> flux_node\n"
+ "\n"
+ "flux_node(cmf::project &_project, cmf::geometry::point\n"
+ "location=cmf::geometry::point()) \n"
+ ""},
{ (char *)"flux_node_project_get", (PyCFunction)_wrap_flux_node_project_get, METH_O, (char *)"flux_node_project_get(flux_node self) -> project"},
{ (char *)"flux_node_potential_set", _wrap_flux_node_potential_set, METH_VARARGS, (char *)"flux_node_potential_set(flux_node self, real potential)"},
{ (char *)"flux_node_potential_get", (PyCFunction)_wrap_flux_node_potential_get, METH_O, (char *)"flux_node_potential_get(flux_node self) -> real"},
{ (char *)"flux_node_connections_get", (PyCFunction)_wrap_flux_node_connections_get, METH_O, (char *)"flux_node_connections_get(flux_node self) -> connection_list"},
{ (char *)"flux_node_swigregister", flux_node_swigregister, METH_VARARGS, NULL},
{ (char *)"flux_node_swiginit", flux_node_swiginit, METH_VARARGS, NULL},
- { (char *)"count_node_references", (PyCFunction) _wrap_count_node_references, METH_VARARGS | METH_KEYWORDS, (char *)"count_node_references(cmf::water::flux_node::ptr node) -> int"},
- { (char *)"get_higher_node", (PyCFunction) _wrap_get_higher_node, METH_VARARGS | METH_KEYWORDS, (char *)"get_higher_node(cmf::water::flux_node::ptr node1, cmf::water::flux_node::ptr node2) -> cmf::water::flux_node::ptr"},
- { (char *)"get_lower_node", (PyCFunction) _wrap_get_lower_node, METH_VARARGS | METH_KEYWORDS, (char *)"get_lower_node(cmf::water::flux_node::ptr node1, cmf::water::flux_node::ptr node2) -> cmf::water::flux_node::ptr"},
- { (char *)"waterbalance_integrator_integration_t", (PyCFunction)_wrap_waterbalance_integrator_integration_t, METH_O, (char *)"waterbalance_integrator_integration_t(waterbalance_integrator self) -> Time"},
- { (char *)"waterbalance_integrator_t0", (PyCFunction)_wrap_waterbalance_integrator_t0, METH_O, (char *)"waterbalance_integrator_t0(waterbalance_integrator self) -> Time"},
- { (char *)"waterbalance_integrator___get_node", (PyCFunction)_wrap_waterbalance_integrator___get_node, METH_O, (char *)"waterbalance_integrator___get_node(waterbalance_integrator self) -> cmf::water::flux_node::ptr"},
- { (char *)"waterbalance_integrator___set_node", (PyCFunction) _wrap_waterbalance_integrator___set_node, METH_VARARGS | METH_KEYWORDS, (char *)"waterbalance_integrator___set_node(waterbalance_integrator self, cmf::water::flux_node::ptr node)"},
- { (char *)"new_waterbalance_integrator", (PyCFunction) _wrap_new_waterbalance_integrator, METH_VARARGS | METH_KEYWORDS, (char *)"new_waterbalance_integrator(cmf::water::flux_node::ptr node) -> waterbalance_integrator"},
+ { (char *)"count_node_references", (PyCFunction) _wrap_count_node_references, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "count_node_references(cmf::water::flux_node::ptr node) -> int\n"
+ "\n"
+ "int\n"
+ "cmf::water::count_node_references(flux_node::ptr node) \n"
+ ""},
+ { (char *)"get_higher_node", (PyCFunction) _wrap_get_higher_node, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "get_higher_node(cmf::water::flux_node::ptr node1, cmf::water::flux_node::ptr node2) -> cmf::water::flux_node::ptr\n"
+ "\n"
+ "flux_node::ptr\n"
+ "cmf::water::get_higher_node(flux_node::ptr node1, flux_node::ptr\n"
+ "node2) \n"
+ ""},
+ { (char *)"get_lower_node", (PyCFunction) _wrap_get_lower_node, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "get_lower_node(cmf::water::flux_node::ptr node1, cmf::water::flux_node::ptr node2) -> cmf::water::flux_node::ptr\n"
+ "\n"
+ "flux_node::ptr\n"
+ "cmf::water::get_lower_node(flux_node::ptr node1, flux_node::ptr node2)\n"
+ "\n"
+ ""},
+ { (char *)"waterbalance_integrator_integration_t", (PyCFunction)_wrap_waterbalance_integrator_integration_t, METH_O, (char *)"\n"
+ "waterbalance_integrator_integration_t(waterbalance_integrator self) -> Time\n"
+ "\n"
+ "cmf::math::Time\n"
+ "integration_t() const\n"
+ "\n"
+ "Returns the duration of the integration. \n"
+ ""},
+ { (char *)"waterbalance_integrator_t0", (PyCFunction)_wrap_waterbalance_integrator_t0, METH_O, (char *)"\n"
+ "waterbalance_integrator_t0(waterbalance_integrator self) -> Time\n"
+ "\n"
+ "cmf::math::Time t0() const\n"
+ "\n"
+ "Returns the start time of the integration. \n"
+ ""},
+ { (char *)"waterbalance_integrator___get_node", (PyCFunction)_wrap_waterbalance_integrator___get_node, METH_O, (char *)"\n"
+ "waterbalance_integrator___get_node(waterbalance_integrator self) -> cmf::water::flux_node::ptr\n"
+ "\n"
+ "flux_node::ptr get_node() const\n"
+ "\n"
+ "Returns the node of this integrator. \n"
+ ""},
+ { (char *)"waterbalance_integrator___set_node", (PyCFunction) _wrap_waterbalance_integrator___set_node, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "waterbalance_integrator___set_node(waterbalance_integrator self, cmf::water::flux_node::ptr node)\n"
+ "\n"
+ "void set_node(cmf::water::flux_node::ptr node) \n"
+ ""},
+ { (char *)"new_waterbalance_integrator", (PyCFunction) _wrap_new_waterbalance_integrator, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_waterbalance_integrator(cmf::water::flux_node::ptr node) -> waterbalance_integrator\n"
+ "\n"
+ "waterbalance_integrator(cmf::water::flux_node::ptr node) \n"
+ ""},
{ (char *)"delete_waterbalance_integrator", (PyCFunction)_wrap_delete_waterbalance_integrator, METH_O, (char *)"delete_waterbalance_integrator(waterbalance_integrator self)"},
{ (char *)"waterbalance_integrator_swigregister", waterbalance_integrator_swigregister, METH_VARARGS, NULL},
{ (char *)"waterbalance_integrator_swiginit", waterbalance_integrator_swiginit, METH_VARARGS, NULL},
- { (char *)"flux_connection_left_node", (PyCFunction)_wrap_flux_connection_left_node, METH_O, (char *)"flux_connection_left_node(flux_connection self) -> cmf::water::flux_node::ptr"},
- { (char *)"flux_connection_right_node", (PyCFunction)_wrap_flux_connection_right_node, METH_O, (char *)"flux_connection_right_node(flux_connection self) -> cmf::water::flux_node::ptr"},
- { (char *)"flux_connection_kill_me", (PyCFunction)_wrap_flux_connection_kill_me, METH_O, (char *)"flux_connection_kill_me(flux_connection self) -> bool"},
- { (char *)"flux_connection_refresh", (PyCFunction) _wrap_flux_connection_refresh, METH_VARARGS | METH_KEYWORDS, (char *)"flux_connection_refresh(flux_connection self, Time t)"},
+ { (char *)"flux_connection_left_node", (PyCFunction)_wrap_flux_connection_left_node, METH_O, (char *)"\n"
+ "flux_connection_left_node(flux_connection self) -> cmf::water::flux_node::ptr\n"
+ "\n"
+ "flux_node::ptr left_node() const\n"
+ "\n"
+ "Returns the left node of this connection. \n"
+ ""},
+ { (char *)"flux_connection_right_node", (PyCFunction)_wrap_flux_connection_right_node, METH_O, (char *)"\n"
+ "flux_connection_right_node(flux_connection self) -> cmf::water::flux_node::ptr\n"
+ "\n"
+ "flux_node::ptr right_node() const\n"
+ "\n"
+ "returns the right node of this connection \n"
+ ""},
+ { (char *)"flux_connection_kill_me", (PyCFunction)_wrap_flux_connection_kill_me, METH_O, (char *)"\n"
+ "flux_connection_kill_me(flux_connection self) -> bool\n"
+ "\n"
+ "bool\n"
+ "kill_me()\n"
+ "\n"
+ "Deregisters this connection from its nodes. Returns true if only one\n"
+ "reference is left. \n"
+ ""},
+ { (char *)"flux_connection_refresh", (PyCFunction) _wrap_flux_connection_refresh, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "flux_connection_refresh(flux_connection self, Time t)\n"
+ "\n"
+ "void\n"
+ "refresh(cmf::math::Time t)\n"
+ "\n"
+ "Performes a new calculation of the flux. \n"
+ ""},
{ (char *)"flux_connection_connection_id_get", (PyCFunction)_wrap_flux_connection_connection_id_get, METH_O, (char *)"flux_connection_connection_id_get(flux_connection self) -> int const"},
{ (char *)"flux_connection___eq__", (PyCFunction) _wrap_flux_connection___eq__, METH_VARARGS | METH_KEYWORDS, (char *)"flux_connection___eq__(flux_connection self, flux_connection other) -> bool"},
{ (char *)"flux_connection_get_target", _wrap_flux_connection_get_target, METH_VARARGS, (char *)"\n"
"get_target(flux_node inquirer) -> cmf::water::flux_node::ptr\n"
"flux_connection_get_target(flux_connection self, int index) -> cmf::water::flux_node::ptr\n"
+ "\n"
+ "flux_node::ptr get_target(int index) const\n"
+ "\n"
+ "With index 0, the left node is returned, with index 1 the right node\n"
+ "of the connection. \n"
+ ""},
+ { (char *)"flux_connection_exchange_target", (PyCFunction) _wrap_flux_connection_exchange_target, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "flux_connection_exchange_target(flux_connection self, cmf::water::flux_node::ptr oldtarget, cmf::water::flux_node::ptr newTarget)\n"
+ "\n"
+ "void exchange_target(flux_node::ptr oldtarget, flux_node::ptr\n"
+ "newTarget) \n"
+ ""},
+ { (char *)"flux_connection_q", (PyCFunction) _wrap_flux_connection_q, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "flux_connection_q(flux_connection self, flux_node inquirer, Time t) -> real\n"
+ "\n"
+ "real q(const\n"
+ "flux_node &inquirer, cmf::math::Time t)\n"
+ "\n"
+ "Returns the current flux through a connection. Negative signs mean out\n"
+ "of the inquirer, positive are inflows to the inquirer. \n"
+ ""},
+ { (char *)"flux_connection_conc", (PyCFunction) _wrap_flux_connection_conc, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "flux_connection_conc(flux_connection self, Time t, solute _Solute) -> real\n"
+ "\n"
+ "real\n"
+ "conc(cmf::math::Time t, const cmf::water::solute &_Solute)\n"
+ "\n"
+ "Returns the concentration of the flux.\n"
+ "\n"
+ "If not overridden, it returns the concentration of the source of the\n"
+ "flux (direction depending) \n"
""},
- { (char *)"flux_connection_exchange_target", (PyCFunction) _wrap_flux_connection_exchange_target, METH_VARARGS | METH_KEYWORDS, (char *)"flux_connection_exchange_target(flux_connection self, cmf::water::flux_node::ptr oldtarget, cmf::water::flux_node::ptr newTarget)"},
- { (char *)"flux_connection_q", (PyCFunction) _wrap_flux_connection_q, METH_VARARGS | METH_KEYWORDS, (char *)"flux_connection_q(flux_connection self, flux_node inquirer, Time t) -> real"},
- { (char *)"flux_connection_conc", (PyCFunction) _wrap_flux_connection_conc, METH_VARARGS | METH_KEYWORDS, (char *)"flux_connection_conc(flux_connection self, Time t, solute _Solute) -> real"},
{ (char *)"flux_connection_type_get", (PyCFunction)_wrap_flux_connection_type_get, METH_O, (char *)"flux_connection_type_get(flux_connection self) -> std::string const &"},
{ (char *)"flux_connection_get_tracer_filter", _wrap_flux_connection_get_tracer_filter, METH_VARARGS, (char *)"\n"
"get_tracer_filter() -> real\n"
"flux_connection_get_tracer_filter(flux_connection self, solute S) -> real\n"
+ "\n"
+ "real get_tracer_filter(solute S)\n"
+ "\n"
+ "A value ranging from 0 to 1 to filter tracers out of the water flux.\n"
+ "\n"
""},
{ (char *)"flux_connection_set_tracer_filter", _wrap_flux_connection_set_tracer_filter, METH_VARARGS, (char *)"\n"
"set_tracer_filter(real value)\n"
"flux_connection_set_tracer_filter(flux_connection self, solute S, real value)\n"
+ "\n"
+ "void set_tracer_filter(solute S, real value) \n"
+ ""},
+ { (char *)"flux_connection_to_string", (PyCFunction)_wrap_flux_connection_to_string, METH_O, (char *)"\n"
+ "flux_connection_to_string(flux_connection self) -> std::string\n"
+ "\n"
+ "virtual std::string to_string() const \n"
+ ""},
+ { (char *)"flux_connection_short_string", (PyCFunction)_wrap_flux_connection_short_string, METH_O, (char *)"\n"
+ "flux_connection_short_string(flux_connection self) -> std::string\n"
+ "\n"
+ "virtual std::string short_string() const \n"
+ ""},
+ { (char *)"delete_flux_connection", (PyCFunction)_wrap_delete_flux_connection, METH_O, (char *)"\n"
+ "delete_flux_connection(flux_connection self)\n"
+ "\n"
+ "virtual ~flux_connection() \n"
""},
- { (char *)"flux_connection_to_string", (PyCFunction)_wrap_flux_connection_to_string, METH_O, (char *)"flux_connection_to_string(flux_connection self) -> std::string"},
- { (char *)"flux_connection_short_string", (PyCFunction)_wrap_flux_connection_short_string, METH_O, (char *)"flux_connection_short_string(flux_connection self) -> std::string"},
- { (char *)"delete_flux_connection", (PyCFunction)_wrap_delete_flux_connection, METH_O, (char *)"delete_flux_connection(flux_connection self)"},
{ (char *)"flux_connection_swigregister", flux_connection_swigregister, METH_VARARGS, NULL},
- { (char *)"replace_node", (PyCFunction) _wrap_replace_node, METH_VARARGS | METH_KEYWORDS, (char *)"replace_node(cmf::water::flux_node::ptr oldnode, cmf::water::flux_node::ptr newnode) -> int"},
- { (char *)"connection_list_append", (PyCFunction) _wrap_connection_list_append, METH_VARARGS | METH_KEYWORDS, (char *)"connection_list_append(connection_list self, cmf::water::flux_connection::ptr connection) -> bool"},
- { (char *)"connection_list_extend", (PyCFunction) _wrap_connection_list_extend, METH_VARARGS | METH_KEYWORDS, (char *)"connection_list_extend(connection_list self, connection_list connections)"},
- { (char *)"connection_list_contains", (PyCFunction) _wrap_connection_list_contains, METH_VARARGS | METH_KEYWORDS, (char *)"connection_list_contains(connection_list self, cmf::water::flux_connection::ptr connection) -> bool"},
- { (char *)"connection_list_remove", (PyCFunction) _wrap_connection_list_remove, METH_VARARGS | METH_KEYWORDS, (char *)"connection_list_remove(connection_list self, cmf::water::flux_connection::ptr connection) -> bool"},
- { (char *)"connection_list_do_action", (PyCFunction) _wrap_connection_list_do_action, METH_VARARGS | METH_KEYWORDS, (char *)"connection_list_do_action(connection_list self, Time t, bool use_OpenMP=True)"},
- { (char *)"connection_list_size", (PyCFunction)_wrap_connection_list_size, METH_O, (char *)"connection_list_size(connection_list self) -> size_t"},
- { (char *)"connection_list_at", (PyCFunction) _wrap_connection_list_at, METH_VARARGS | METH_KEYWORDS, (char *)"connection_list_at(connection_list self, size_t pos) -> cmf::water::flux_connection::ptr"},
+ { (char *)"replace_node", (PyCFunction) _wrap_replace_node, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "replace_node(cmf::water::flux_node::ptr oldnode, cmf::water::flux_node::ptr newnode) -> int\n"
+ "\n"
+ "int\n"
+ "cmf::water::replace_node(cmf::water::flux_node::ptr oldnode,\n"
+ "cmf::water::flux_node::ptr newnode) \n"
+ ""},
+ { (char *)"connection_list_append", (PyCFunction) _wrap_connection_list_append, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "connection_list_append(connection_list self, cmf::water::flux_connection::ptr connection) -> bool\n"
+ "\n"
+ "bool\n"
+ "append(cmf::water::flux_connection::ptr connection) \n"
+ ""},
+ { (char *)"connection_list_extend", (PyCFunction) _wrap_connection_list_extend, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "connection_list_extend(connection_list self, connection_list connections)\n"
+ "\n"
+ "void\n"
+ "extend(const connection_list &connections) \n"
+ ""},
+ { (char *)"connection_list_contains", (PyCFunction) _wrap_connection_list_contains, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "connection_list_contains(connection_list self, cmf::water::flux_connection::ptr connection) -> bool\n"
+ "\n"
+ "bool\n"
+ "contains(cmf::water::flux_connection::ptr connection) const \n"
+ ""},
+ { (char *)"connection_list_remove", (PyCFunction) _wrap_connection_list_remove, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "connection_list_remove(connection_list self, cmf::water::flux_connection::ptr connection) -> bool\n"
+ "\n"
+ "bool\n"
+ "remove(cmf::water::flux_connection::ptr connection) \n"
+ ""},
+ { (char *)"connection_list_do_action", (PyCFunction) _wrap_connection_list_do_action, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "connection_list_do_action(connection_list self, Time t, bool use_OpenMP=True)\n"
+ "\n"
+ "void\n"
+ "do_action(cmf::math::Time t, bool use_OpenMP=true) \n"
+ ""},
+ { (char *)"connection_list_size", (PyCFunction)_wrap_connection_list_size, METH_O, (char *)"\n"
+ "connection_list_size(connection_list self) -> size_t\n"
+ "\n"
+ "size_t\n"
+ "size() const \n"
+ ""},
+ { (char *)"connection_list_at", (PyCFunction) _wrap_connection_list_at, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "connection_list_at(connection_list self, size_t pos) -> cmf::water::flux_connection::ptr\n"
+ "\n"
+ "cmf::water::flux_connection::ptr at(size_t pos) const \n"
+ ""},
{ (char *)"connection_list_begin", _wrap_connection_list_begin, METH_VARARGS, (char *)"\n"
"begin() -> cmf::water::connection_list::iterator\n"
"connection_list_begin(connection_list self) -> cmf::water::connection_list::const_iterator\n"
+ "\n"
+ "const_iterator begin() const \n"
""},
{ (char *)"connection_list_end", _wrap_connection_list_end, METH_VARARGS, (char *)"\n"
"end() -> cmf::water::connection_list::iterator\n"
"connection_list_end(connection_list self) -> cmf::water::connection_list::const_iterator\n"
+ "\n"
+ "const_iterator end() const \n"
""},
{ (char *)"connection_list___len__", (PyCFunction)_wrap_connection_list___len__, METH_O, (char *)"connection_list___len__(connection_list self) -> size_t"},
{ (char *)"connection_list___contains__", (PyCFunction) _wrap_connection_list___contains__, METH_VARARGS | METH_KEYWORDS, (char *)"connection_list___contains__(connection_list self, cmf::water::flux_connection::ptr const & con) -> bool"},
@@ -75154,14 +76440,38 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"delete_connection_list", (PyCFunction)_wrap_delete_connection_list, METH_O, (char *)"delete_connection_list(connection_list self)"},
{ (char *)"connection_list_swigregister", connection_list_swigregister, METH_VARARGS, NULL},
{ (char *)"connection_list_swiginit", connection_list_swiginit, METH_VARARGS, NULL},
- { (char *)"flux_integrator_integration_t", (PyCFunction)_wrap_flux_integrator_integration_t, METH_O, (char *)"flux_integrator_integration_t(flux_integrator self) -> Time"},
- { (char *)"flux_integrator_t0", (PyCFunction)_wrap_flux_integrator_t0, METH_O, (char *)"flux_integrator_t0(flux_integrator self) -> Time"},
+ { (char *)"flux_integrator_integration_t", (PyCFunction)_wrap_flux_integrator_integration_t, METH_O, (char *)"\n"
+ "flux_integrator_integration_t(flux_integrator self) -> Time\n"
+ "\n"
+ "cmf::math::Time integration_t() const\n"
+ "\n"
+ "Returns the duration of the integration. \n"
+ ""},
+ { (char *)"flux_integrator_t0", (PyCFunction)_wrap_flux_integrator_t0, METH_O, (char *)"\n"
+ "flux_integrator_t0(flux_integrator self) -> Time\n"
+ "\n"
+ "cmf::math::Time t0() const\n"
+ "\n"
+ "Returns the start time of the integration. \n"
+ ""},
{ (char *)"flux_integrator_invert_set", _wrap_flux_integrator_invert_set, METH_VARARGS, (char *)"flux_integrator_invert_set(flux_integrator self, bool invert)"},
{ (char *)"flux_integrator_invert_get", (PyCFunction)_wrap_flux_integrator_invert_get, METH_O, (char *)"flux_integrator_invert_get(flux_integrator self) -> bool"},
- { (char *)"flux_integrator_connection", (PyCFunction)_wrap_flux_integrator_connection, METH_O, (char *)"flux_integrator_connection(flux_integrator self) -> cmf::water::flux_connection::ptr"},
+ { (char *)"flux_integrator_connection", (PyCFunction)_wrap_flux_integrator_connection, METH_O, (char *)"\n"
+ "flux_integrator_connection(flux_integrator self) -> cmf::water::flux_connection::ptr\n"
+ "\n"
+ "flux_connection::ptr connection() const\n"
+ "\n"
+ "Returns the flux_connection. \n"
+ ""},
{ (char *)"new_flux_integrator", _wrap_new_flux_integrator, METH_VARARGS, (char *)"\n"
"flux_integrator(flux_connection connection)\n"
"new_flux_integrator(cmf::water::flux_node::ptr left, cmf::water::flux_node::ptr right) -> flux_integrator\n"
+ "\n"
+ "flux_integrator(cmf::water::flux_node::ptr left,\n"
+ "cmf::water::flux_node::ptr right)\n"
+ "\n"
+ "Creates a flux_integrator from the endpoints of a connection. Throws\n"
+ "if there is no connection between the endpoints. \n"
""},
{ (char *)"delete_flux_integrator", (PyCFunction)_wrap_delete_flux_integrator, METH_O, (char *)"delete_flux_integrator(flux_integrator self)"},
{ (char *)"flux_integrator_swigregister", flux_integrator_swigregister, METH_VARARGS, NULL},
@@ -75171,54 +76481,128 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"linear_scale_slope_set", _wrap_linear_scale_slope_set, METH_VARARGS, (char *)"linear_scale_slope_set(linear_scale self, real slope)"},
{ (char *)"linear_scale_slope_get", (PyCFunction)_wrap_linear_scale_slope_get, METH_O, (char *)"linear_scale_slope_get(linear_scale self) -> real"},
{ (char *)"linear_scale___call__", (PyCFunction) _wrap_linear_scale___call__, METH_VARARGS | METH_KEYWORDS, (char *)"linear_scale___call__(linear_scale self, real value) -> real"},
- { (char *)"new_linear_scale", (PyCFunction) _wrap_new_linear_scale, METH_VARARGS | METH_KEYWORDS, (char *)"new_linear_scale(real _slope=1, real _displacement=0) -> linear_scale"},
+ { (char *)"new_linear_scale", (PyCFunction) _wrap_new_linear_scale, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_linear_scale(real _slope=1, real _displacement=0) -> linear_scale\n"
+ "\n"
+ "linear_scale(real _slope=1, real _displacement=0)\n"
+ "\n"
+ "Creates a linear scale (by default it is a unity scale, :math:`a=1; b=0`) \n"
+ ""},
{ (char *)"delete_linear_scale", (PyCFunction)_wrap_delete_linear_scale, METH_O, (char *)"delete_linear_scale(linear_scale self)"},
{ (char *)"linear_scale_swigregister", linear_scale_swigregister, METH_VARARGS, NULL},
{ (char *)"linear_scale_swiginit", linear_scale_swiginit, METH_VARARGS, NULL},
- { (char *)"DirichletBoundary_set_conc", (PyCFunction) _wrap_DirichletBoundary_set_conc, METH_VARARGS | METH_KEYWORDS, (char *)"DirichletBoundary_set_conc(DirichletBoundary self, solute _Solute, double value)"},
+ { (char *)"DirichletBoundary_set_conc", (PyCFunction) _wrap_DirichletBoundary_set_conc, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "DirichletBoundary_set_conc(DirichletBoundary self, solute _Solute, double value)\n"
+ "\n"
+ "virtual void set_conc(const cmf::water::solute &_Solute, double value)\n"
+ "\n"
+ ""},
{ (char *)"DirichletBoundary_is_source_set", _wrap_DirichletBoundary_is_source_set, METH_VARARGS, (char *)"DirichletBoundary_is_source_set(DirichletBoundary self, bool is_source)"},
{ (char *)"DirichletBoundary_is_source_get", (PyCFunction)_wrap_DirichletBoundary_is_source_get, METH_O, (char *)"DirichletBoundary_is_source_get(DirichletBoundary self) -> bool"},
- { (char *)"DirichletBoundary_RecalcFluxes", (PyCFunction) _wrap_DirichletBoundary_RecalcFluxes, METH_VARARGS | METH_KEYWORDS, (char *)"DirichletBoundary_RecalcFluxes(DirichletBoundary self, Time t) -> bool"},
- { (char *)"new_DirichletBoundary", (PyCFunction) _wrap_new_DirichletBoundary, METH_VARARGS | METH_KEYWORDS, (char *)"new_DirichletBoundary(project _p, real potential, point Location) -> DirichletBoundary"},
+ { (char *)"DirichletBoundary_RecalcFluxes", (PyCFunction) _wrap_DirichletBoundary_RecalcFluxes, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "DirichletBoundary_RecalcFluxes(DirichletBoundary self, Time t) -> bool\n"
+ "\n"
+ "virtual bool RecalcFluxes(cmf::math::Time t)\n"
+ "\n"
+ "Pure flux_nodes do not influence fluxes, therefore no recalculation of\n"
+ "fluxes is required by flux_node.\n"
+ "\n"
+ "WaterStorage overrides this, since state changes require an update of\n"
+ "the fluxes \n"
+ ""},
+ { (char *)"new_DirichletBoundary", (PyCFunction) _wrap_new_DirichletBoundary, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_DirichletBoundary(project _p, real potential, point Location) -> DirichletBoundary\n"
+ "\n"
+ "DirichletBoundary(cmf::project &_p, real potential,\n"
+ "cmf::geometry::point Location=cmf::geometry::point()) \n"
+ ""},
{ (char *)"delete_DirichletBoundary", (PyCFunction)_wrap_delete_DirichletBoundary, METH_O, (char *)"delete_DirichletBoundary(DirichletBoundary self)"},
{ (char *)"DirichletBoundary_swigregister", DirichletBoundary_swigregister, METH_VARARGS, NULL},
{ (char *)"DirichletBoundary_swiginit", DirichletBoundary_swiginit, METH_VARARGS, NULL},
- { (char *)"NeumannBoundary_get_flux", (PyCFunction)_wrap_NeumannBoundary_get_flux, METH_O, (char *)"NeumannBoundary_get_flux(NeumannBoundary self) -> timeseries"},
+ { (char *)"NeumannBoundary_get_flux", (PyCFunction)_wrap_NeumannBoundary_get_flux, METH_O, (char *)"\n"
+ "NeumannBoundary_get_flux(NeumannBoundary self) -> timeseries\n"
+ "\n"
+ "cmf::math::timeseries get_flux()\n"
+ "\n"
+ "The timeseries of the boundary flux. \n"
+ ""},
{ (char *)"NeumannBoundary_set_flux", _wrap_NeumannBoundary_set_flux, METH_VARARGS, (char *)"\n"
"set_flux(timeseries new_flux)\n"
"NeumannBoundary_set_flux(NeumannBoundary self, double new_flux)\n"
+ "\n"
+ "void\n"
+ "set_flux(double new_flux)\n"
+ "\n"
+ "Set a constant as the boundary flux. \n"
""},
{ (char *)"NeumannBoundary_flux_scale_set", _wrap_NeumannBoundary_flux_scale_set, METH_VARARGS, (char *)"NeumannBoundary_flux_scale_set(NeumannBoundary self, linear_scale flux_scale)"},
{ (char *)"NeumannBoundary_flux_scale_get", (PyCFunction)_wrap_NeumannBoundary_flux_scale_get, METH_O, (char *)"NeumannBoundary_flux_scale_get(NeumannBoundary self) -> linear_scale"},
{ (char *)"NeumannBoundary_concentration_set", _wrap_NeumannBoundary_concentration_set, METH_VARARGS, (char *)"NeumannBoundary_concentration_set(NeumannBoundary self, SoluteTimeseries concentration)"},
{ (char *)"NeumannBoundary_concentration_get", (PyCFunction)_wrap_NeumannBoundary_concentration_get, METH_O, (char *)"NeumannBoundary_concentration_get(NeumannBoundary self) -> SoluteTimeseries"},
{ (char *)"NeumannBoundary___call__", (PyCFunction) _wrap_NeumannBoundary___call__, METH_VARARGS | METH_KEYWORDS, (char *)"NeumannBoundary___call__(NeumannBoundary self, Time t) -> real"},
- { (char *)"NeumannBoundary_connect_to", (PyCFunction) _wrap_NeumannBoundary_connect_to, METH_VARARGS | METH_KEYWORDS, (char *)"NeumannBoundary_connect_to(NeumannBoundary self, cmf::water::flux_node::ptr target)"},
+ { (char *)"NeumannBoundary_connect_to", (PyCFunction) _wrap_NeumannBoundary_connect_to, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "NeumannBoundary_connect_to(NeumannBoundary self, cmf::water::flux_node::ptr target)\n"
+ "\n"
+ "void\n"
+ "connect_to(cmf::water::flux_node::ptr target) \n"
+ ""},
{ (char *)"new_NeumannBoundary", _wrap_new_NeumannBoundary, METH_VARARGS, (char *)"\n"
"NeumannBoundary(project _project, timeseries _flux, SoluteTimeseries _concentration, point loc)\n"
"new_NeumannBoundary(project _project, point loc) -> NeumannBoundary\n"
+ "\n"
+ "NeumannBoundary(cmf::project &_project, cmf::geometry::point\n"
+ "loc=cmf::geometry::point()) \n"
""},
{ (char *)"NeumannBoundary_create", (PyCFunction) _wrap_NeumannBoundary_create, METH_VARARGS | METH_KEYWORDS, (char *)"NeumannBoundary_create(cmf::water::flux_node::ptr target) -> cmf::water::NeumannBoundary::ptr"},
{ (char *)"delete_NeumannBoundary", (PyCFunction)_wrap_delete_NeumannBoundary, METH_O, (char *)"delete_NeumannBoundary(NeumannBoundary self)"},
{ (char *)"NeumannBoundary_swigregister", NeumannBoundary_swigregister, METH_VARARGS, NULL},
{ (char *)"NeumannBoundary_swiginit", NeumannBoundary_swiginit, METH_VARARGS, NULL},
- { (char *)"new_NeumannFlux", (PyCFunction) _wrap_new_NeumannFlux, METH_VARARGS | METH_KEYWORDS, (char *)"new_NeumannFlux(std::shared_ptr< cmf::water::NeumannBoundary > left, cmf::water::flux_node::ptr right) -> NeumannFlux"},
+ { (char *)"new_NeumannFlux", (PyCFunction) _wrap_new_NeumannFlux, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_NeumannFlux(std::shared_ptr< cmf::water::NeumannBoundary > left, cmf::water::flux_node::ptr right) -> NeumannFlux\n"
+ "\n"
+ "NeumannFlux(std::shared_ptr< NeumannBoundary > left,\n"
+ "cmf::water::flux_node::ptr right) \n"
+ ""},
{ (char *)"delete_NeumannFlux", (PyCFunction)_wrap_delete_NeumannFlux, METH_O, (char *)"delete_NeumannFlux(NeumannFlux self)"},
{ (char *)"NeumannFlux_swigregister", NeumannFlux_swigregister, METH_VARARGS, NULL},
{ (char *)"NeumannFlux_swiginit", NeumannFlux_swiginit, METH_VARARGS, NULL},
- { (char *)"new_WaterStorage", (PyCFunction) _wrap_new_WaterStorage, METH_VARARGS | METH_KEYWORDS, (char *)"new_WaterStorage(project project, std::string const & Name, double InitialState=0) -> WaterStorage"},
+ { (char *)"new_WaterStorage", (PyCFunction) _wrap_new_WaterStorage, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_WaterStorage(project project, std::string const & Name, double InitialState=0, double scale=1) -> WaterStorage\n"
+ "\n"
+ "WaterStorage(cmf::project &project, const std::string &Name=\"\",\n"
+ "double InitialState=0)\n"
+ "\n"
+ "creates a water storage (abstract class)\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "project: The project the waterstorage belongs to\n"
+ "\n"
+ "Name: Name of the water storage\n"
+ "\n"
+ "InitialState: Initial water content in m3 \n"
+ ""},
{ (char *)"WaterStorage_from_node", (PyCFunction) _wrap_WaterStorage_from_node, METH_VARARGS | METH_KEYWORDS, (char *)"WaterStorage_from_node(cmf::water::flux_node::ptr node) -> std::shared_ptr< cmf::water::WaterStorage >"},
{ (char *)"WaterStorage_Solute", _wrap_WaterStorage_Solute, METH_VARARGS, (char *)"\n"
"Solute(solute _Solute) -> SoluteStorage\n"
"WaterStorage_Solute(WaterStorage self, solute _Solute) -> SoluteStorage\n"
+ "\n"
+ "const\n"
+ "SoluteStorage& Solute(const cmf::water::solute &_Solute) const \n"
""},
{ (char *)"WaterStorage_conc", _wrap_WaterStorage_conc, METH_VARARGS, (char *)"\n"
"conc(solute _Solute) -> real\n"
"conc(Time t, solute _Solute) -> real\n"
"WaterStorage_conc(WaterStorage self, solute _Solute, real NewConcetration)\n"
+ "\n"
+ "void\n"
+ "conc(const cmf::water::solute &_Solute, real NewConcetration)\n"
+ "\n"
+ "Sets a new concentration. \n"
""},
{ (char *)"WaterStorage_cast", (PyCFunction) _wrap_WaterStorage_cast, METH_VARARGS | METH_KEYWORDS, (char *)"WaterStorage_cast(std::shared_ptr< cmf::water::flux_node > node) -> std::shared_ptr< cmf::water::WaterStorage >"},
- { (char *)"WaterStorage_create", (PyCFunction) _wrap_WaterStorage_create, METH_VARARGS | METH_KEYWORDS, (char *)"WaterStorage_create(project _project, real initial_state=0.0) -> std::shared_ptr< cmf::water::WaterStorage >"},
+ { (char *)"WaterStorage_create", (PyCFunction) _wrap_WaterStorage_create, METH_VARARGS | METH_KEYWORDS, (char *)"WaterStorage_create(project _project, real initial_state=0.0, real scale=1.0) -> std::shared_ptr< cmf::water::WaterStorage >"},
{ (char *)"WaterStorage_volume_set", _wrap_WaterStorage_volume_set, METH_VARARGS, (char *)"WaterStorage_volume_set(WaterStorage self, real volume)"},
{ (char *)"WaterStorage_volume_get", (PyCFunction)_wrap_WaterStorage_volume_get, METH_O, (char *)"WaterStorage_volume_get(WaterStorage self) -> real"},
{ (char *)"WaterStorage_statevariable_set", _wrap_WaterStorage_statevariable_set, METH_VARARGS, (char *)"WaterStorage_statevariable_set(WaterStorage self, char statevariable)"},
@@ -75226,18 +76610,47 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"delete_WaterStorage", (PyCFunction)_wrap_delete_WaterStorage, METH_O, (char *)"delete_WaterStorage(WaterStorage self)"},
{ (char *)"WaterStorage_swigregister", WaterStorage_swigregister, METH_VARARGS, NULL},
{ (char *)"WaterStorage_swiginit", WaterStorage_swiginit, METH_VARARGS, NULL},
- { (char *)"new_waterbalance_connection", (PyCFunction) _wrap_new_waterbalance_connection, METH_VARARGS | METH_KEYWORDS, (char *)"new_waterbalance_connection(cmf::water::flux_node::ptr source, cmf::water::flux_node::ptr target) -> waterbalance_connection"},
+ { (char *)"new_waterbalance_connection", (PyCFunction) _wrap_new_waterbalance_connection, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_waterbalance_connection(cmf::water::flux_node::ptr source, cmf::water::flux_node::ptr target) -> waterbalance_connection\n"
+ "\n"
+ "waterbalance_connection(flux_node::ptr source, flux_node::ptr target)\n"
+ "\n"
+ ""},
{ (char *)"delete_waterbalance_connection", (PyCFunction)_wrap_delete_waterbalance_connection, METH_O, (char *)"delete_waterbalance_connection(waterbalance_connection self)"},
{ (char *)"waterbalance_connection_swigregister", waterbalance_connection_swigregister, METH_VARARGS, NULL},
{ (char *)"waterbalance_connection_swiginit", waterbalance_connection_swiginit, METH_VARARGS, NULL},
{ (char *)"external_control_connection_flux_set", _wrap_external_control_connection_flux_set, METH_VARARGS, (char *)"external_control_connection_flux_set(external_control_connection self, real flux)"},
{ (char *)"external_control_connection_flux_get", (PyCFunction)_wrap_external_control_connection_flux_get, METH_O, (char *)"external_control_connection_flux_get(external_control_connection self) -> real"},
- { (char *)"new_external_control_connection", (PyCFunction) _wrap_new_external_control_connection, METH_VARARGS | METH_KEYWORDS, (char *)"new_external_control_connection(cmf::water::flux_node::ptr source, cmf::water::flux_node::ptr target, real flux_value=0) -> external_control_connection"},
+ { (char *)"new_external_control_connection", (PyCFunction) _wrap_new_external_control_connection, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_external_control_connection(cmf::water::flux_node::ptr source, cmf::water::flux_node::ptr target, real flux_value=0) -> external_control_connection\n"
+ "\n"
+ "external_control_connection(flux_node::ptr source, flux_node::ptr\n"
+ "target, real flux_value=0) \n"
+ ""},
{ (char *)"delete_external_control_connection", (PyCFunction)_wrap_delete_external_control_connection, METH_O, (char *)"delete_external_control_connection(external_control_connection self)"},
{ (char *)"external_control_connection_swigregister", external_control_connection_swigregister, METH_VARARGS, NULL},
{ (char *)"external_control_connection_swiginit", external_control_connection_swiginit, METH_VARARGS, NULL},
- { (char *)"set_flux", (PyCFunction) _wrap_set_flux, METH_VARARGS | METH_KEYWORDS, (char *)"set_flux(cmf::water::flux_node::ptr source, cmf::water::flux_node::ptr target, real flux_value)"},
- { (char *)"can_set_flux", (PyCFunction) _wrap_can_set_flux, METH_VARARGS | METH_KEYWORDS, (char *)"can_set_flux(cmf::water::flux_node::ptr source, cmf::water::flux_node::ptr target) -> bool"},
+ { (char *)"set_flux", (PyCFunction) _wrap_set_flux, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "set_flux(cmf::water::flux_node::ptr source, cmf::water::flux_node::ptr target, real flux_value)\n"
+ "\n"
+ "void\n"
+ "cmf::water::set_flux(flux_node::ptr source, flux_node::ptr target,\n"
+ "real flux_value)\n"
+ "\n"
+ "Sets a constant flux between two nodes, if an\n"
+ "external_control_connection exists. \n"
+ ""},
+ { (char *)"can_set_flux", (PyCFunction) _wrap_can_set_flux, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "can_set_flux(cmf::water::flux_node::ptr source, cmf::water::flux_node::ptr target) -> bool\n"
+ "\n"
+ "bool\n"
+ "cmf::water::can_set_flux(flux_node::ptr source, flux_node::ptr target)\n"
+ "\n"
+ "Checks if a constant flux between two nodes can be set.\n"
+ "\n"
+ "Returns true if the nodes are connected by an\n"
+ "external_control_connection \n"
+ ""},
{ (char *)"kinematic_wave_residencetime_set", _wrap_kinematic_wave_residencetime_set, METH_VARARGS, (char *)"kinematic_wave_residencetime_set(kinematic_wave self, real residencetime)"},
{ (char *)"kinematic_wave_residencetime_get", (PyCFunction)_wrap_kinematic_wave_residencetime_get, METH_O, (char *)"kinematic_wave_residencetime_get(kinematic_wave self) -> real"},
{ (char *)"kinematic_wave_exponent_set", _wrap_kinematic_wave_exponent_set, METH_VARARGS, (char *)"kinematic_wave_exponent_set(kinematic_wave self, real exponent)"},
@@ -75246,7 +76659,41 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"kinematic_wave_residual_get", (PyCFunction)_wrap_kinematic_wave_residual_get, METH_O, (char *)"kinematic_wave_residual_get(kinematic_wave self) -> real"},
{ (char *)"kinematic_wave_V0_set", _wrap_kinematic_wave_V0_set, METH_VARARGS, (char *)"kinematic_wave_V0_set(kinematic_wave self, real V0)"},
{ (char *)"kinematic_wave_V0_get", (PyCFunction)_wrap_kinematic_wave_V0_get, METH_O, (char *)"kinematic_wave_V0_get(kinematic_wave self) -> real"},
- { (char *)"new_kinematic_wave", (PyCFunction) _wrap_new_kinematic_wave, METH_VARARGS | METH_KEYWORDS, (char *)"new_kinematic_wave(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"},
+ { (char *)"new_kinematic_wave", (PyCFunction) _wrap_new_kinematic_wave, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_kinematic_wave(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\n"
+ "\n"
+ "kinematic_wave(WaterStorage::ptr source, flux_node::ptr target, real\n"
+ "residencetime, real exponent=1.0, real residual=0.0, real V0=1.0)\n"
+ "\n"
+ "Creates a kinematic wave connection.\n"
+ "\n"
+ "\n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " q = \\\\frac 1 {t_r} {\\\\left(\\\\frac{V - V_{residual}}{V_0}\n"
+ " \\\\right)^\\\\beta} \n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "source: Water storage from which the water flows out. Flux is a\n"
+ "function of source.volume\n"
+ "\n"
+ "target: Target node (boundary condition or storage). Does not\n"
+ "influence the strength of the flow\n"
+ "\n"
+ "residencetime: :math:`t_r [days]` The residence time of the water in this\n"
+ "storage\n"
+ "\n"
+ "exponent: :math:`\\\\beta [-]` An empirical exponent to shape the flux\n"
+ "function (default = 1 (linear function))\n"
+ "\n"
+ "residual: :math:`V_{residual} [m^3]` The volume of water not flowing out\n"
+ "(default = 0)\n"
+ "\n"
+ "V0: :math:`V_0` The reference volume to scale the exponent \n"
+ ""},
{ (char *)"delete_kinematic_wave", (PyCFunction)_wrap_delete_kinematic_wave, METH_O, (char *)"delete_kinematic_wave(kinematic_wave self)"},
{ (char *)"kinematic_wave_swigregister", kinematic_wave_swigregister, METH_VARARGS, NULL},
{ (char *)"kinematic_wave_swiginit", kinematic_wave_swiginit, METH_VARARGS, NULL},
@@ -75254,7 +76701,35 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"LinearStorageConnection_residencetime_get", (PyCFunction)_wrap_LinearStorageConnection_residencetime_get, METH_O, (char *)"LinearStorageConnection_residencetime_get(LinearStorageConnection self) -> real"},
{ (char *)"LinearStorageConnection_residual_set", _wrap_LinearStorageConnection_residual_set, METH_VARARGS, (char *)"LinearStorageConnection_residual_set(LinearStorageConnection self, real residual)"},
{ (char *)"LinearStorageConnection_residual_get", (PyCFunction)_wrap_LinearStorageConnection_residual_get, METH_O, (char *)"LinearStorageConnection_residual_get(LinearStorageConnection self) -> real"},
- { (char *)"new_LinearStorageConnection", (PyCFunction) _wrap_new_LinearStorageConnection, METH_VARARGS | METH_KEYWORDS, (char *)"new_LinearStorageConnection(cmf::water::WaterStorage::ptr source, cmf::water::flux_node::ptr target, real residencetime, real residual=0.0) -> LinearStorageConnection"},
+ { (char *)"new_LinearStorageConnection", (PyCFunction) _wrap_new_LinearStorageConnection, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_LinearStorageConnection(cmf::water::WaterStorage::ptr source, cmf::water::flux_node::ptr target, real residencetime, real residual=0.0) -> LinearStorageConnection\n"
+ "\n"
+ "LinearStorageConnection(WaterStorage::ptr source, flux_node::ptr\n"
+ "target, real residencetime, real residual=0.0)\n"
+ "\n"
+ "Creates a linear storage connection or Nash-box.\n"
+ "\n"
+ "\n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " q = \\\\frac{V - V_{residual}}{t_r}} \n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "source: Water storage from which the water flows out. Flux is a\n"
+ "function of source.volume\n"
+ "\n"
+ "target: Target node (boundary condition or storage). Does not\n"
+ "influence the strength of the flow\n"
+ "\n"
+ "residencetime: :math:`t_r [days]` The residence time of the water in this\n"
+ "storage\n"
+ "\n"
+ "residual: :math:`V_{residual} [m^3]` The volume of water not flowing out\n"
+ "(default = 0) \n"
+ ""},
{ (char *)"delete_LinearStorageConnection", (PyCFunction)_wrap_delete_LinearStorageConnection, METH_O, (char *)"delete_LinearStorageConnection(LinearStorageConnection self)"},
{ (char *)"LinearStorageConnection_swigregister", LinearStorageConnection_swigregister, METH_VARARGS, NULL},
{ (char *)"LinearStorageConnection_swiginit", LinearStorageConnection_swiginit, METH_VARARGS, NULL},
@@ -75266,7 +76741,41 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"PowerLawConnection_residual_get", (PyCFunction)_wrap_PowerLawConnection_residual_get, METH_O, (char *)"PowerLawConnection_residual_get(PowerLawConnection self) -> real"},
{ (char *)"PowerLawConnection_V0_set", _wrap_PowerLawConnection_V0_set, METH_VARARGS, (char *)"PowerLawConnection_V0_set(PowerLawConnection self, real V0)"},
{ (char *)"PowerLawConnection_V0_get", (PyCFunction)_wrap_PowerLawConnection_V0_get, METH_O, (char *)"PowerLawConnection_V0_get(PowerLawConnection self) -> real"},
- { (char *)"new_PowerLawConnection", (PyCFunction) _wrap_new_PowerLawConnection, METH_VARARGS | METH_KEYWORDS, (char *)"new_PowerLawConnection(cmf::water::WaterStorage::ptr source, cmf::water::flux_node::ptr target, real Q0, real V0, real beta=1.0, real residual=0.0) -> PowerLawConnection"},
+ { (char *)"new_PowerLawConnection", (PyCFunction) _wrap_new_PowerLawConnection, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_PowerLawConnection(cmf::water::WaterStorage::ptr source, cmf::water::flux_node::ptr target, real Q0, real V0, real beta=1.0, real residual=0.0) -> PowerLawConnection\n"
+ "\n"
+ "PowerLawConnection(WaterStorage::ptr source, flux_node::ptr target,\n"
+ "real Q0, real V0, real beta=1.0, real residual=0.0)\n"
+ "\n"
+ "Creates a kinematic wave connection.\n"
+ "\n"
+ "\n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " q(V) = \\\\frac Q_0 {\\\\left(\\\\frac{V - V_{residual}}{V_0}\n"
+ " \\\\right)^\\\\beta} \n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "source: Water storage from which the water flows out. Flux is a\n"
+ "function of source.volume\n"
+ "\n"
+ "target: Target node (boundary condition or storage). Does not\n"
+ "influence the strength of the flow\n"
+ "\n"
+ "Q0: Reference flow :math:`Q_0 = q(V_0)` Outflow when the source storage\n"
+ "equals the reference volume\n"
+ "\n"
+ "V0: Reference volume :math:`V_0` The reference volume to scale the exponent\n"
+ "\n"
+ "beta: :math:`\\\\beta [-]` An empirical exponent to shape the flux\n"
+ "function (default = 1 (linear function))\n"
+ "\n"
+ "residual: :math:`V_{residual} [m^3]` The volume of water not flowing out\n"
+ "(default = 0) \n"
+ ""},
{ (char *)"delete_PowerLawConnection", (PyCFunction)_wrap_delete_PowerLawConnection, METH_O, (char *)"delete_PowerLawConnection(PowerLawConnection self)"},
{ (char *)"PowerLawConnection_swigregister", PowerLawConnection_swigregister, METH_VARARGS, NULL},
{ (char *)"PowerLawConnection_swiginit", PowerLawConnection_swiginit, METH_VARARGS, NULL},
@@ -75282,7 +76791,34 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"bidirectional_kinematic_exchange_beta_suc_get", (PyCFunction)_wrap_bidirectional_kinematic_exchange_beta_suc_get, METH_O, (char *)"bidirectional_kinematic_exchange_beta_suc_get(bidirectional_kinematic_exchange self) -> real"},
{ (char *)"bidirectional_kinematic_exchange_beta_spill_set", _wrap_bidirectional_kinematic_exchange_beta_spill_set, METH_VARARGS, (char *)"bidirectional_kinematic_exchange_beta_spill_set(bidirectional_kinematic_exchange self, real beta_spill)"},
{ (char *)"bidirectional_kinematic_exchange_beta_spill_get", (PyCFunction)_wrap_bidirectional_kinematic_exchange_beta_spill_get, METH_O, (char *)"bidirectional_kinematic_exchange_beta_spill_get(bidirectional_kinematic_exchange self) -> real"},
- { (char *)"new_bidirectional_kinematic_exchange", (PyCFunction) _wrap_new_bidirectional_kinematic_exchange, METH_VARARGS | METH_KEYWORDS, (char *)"new_bidirectional_kinematic_exchange(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"},
+ { (char *)"new_bidirectional_kinematic_exchange", (PyCFunction) _wrap_new_bidirectional_kinematic_exchange, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_bidirectional_kinematic_exchange(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\n"
+ "\n"
+ "bidirectional_kinematic_exchange(WaterStorage::ptr source,\n"
+ "flux_node::ptr target, real Vminspill, real Vmaxsuc, real qspill, real\n"
+ "qsuc, real beta_spill, real beta_suc)\n"
+ "\n"
+ "Creates a kinematic wave connection.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "source: Water storage from which the water flows out. Flux is a\n"
+ "function of source.volume\n"
+ "\n"
+ "target: Target node (boundary condition or storage). Does not\n"
+ "influence the strength of the flow\n"
+ "\n"
+ "Vmaxsuc: Suction starts below this threshold volume of source\n"
+ "\n"
+ "Vminspill: Spilling starts above this threshold volume of source\n"
+ "\n"
+ "qspill: Spill flow at 2*Vminspill in m3/day\n"
+ "\n"
+ "qsuc: Suction flow at V=0 m3\n"
+ "\n"
+ "beta_suc: beta_spill: Exponent for spill / suction flow \n"
+ ""},
{ (char *)"delete_bidirectional_kinematic_exchange", (PyCFunction)_wrap_delete_bidirectional_kinematic_exchange, METH_O, (char *)"delete_bidirectional_kinematic_exchange(bidirectional_kinematic_exchange self)"},
{ (char *)"bidirectional_kinematic_exchange_swigregister", bidirectional_kinematic_exchange_swigregister, METH_VARARGS, NULL},
{ (char *)"bidirectional_kinematic_exchange_swiginit", bidirectional_kinematic_exchange_swiginit, METH_VARARGS, NULL},
@@ -75298,7 +76834,46 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"constraint_kinematic_wave_Vrmax_get", (PyCFunction)_wrap_constraint_kinematic_wave_Vrmax_get, METH_O, (char *)"constraint_kinematic_wave_Vrmax_get(constraint_kinematic_wave self) -> real"},
{ (char *)"constraint_kinematic_wave_gamma_set", _wrap_constraint_kinematic_wave_gamma_set, METH_VARARGS, (char *)"constraint_kinematic_wave_gamma_set(constraint_kinematic_wave self, real gamma)"},
{ (char *)"constraint_kinematic_wave_gamma_get", (PyCFunction)_wrap_constraint_kinematic_wave_gamma_get, METH_O, (char *)"constraint_kinematic_wave_gamma_get(constraint_kinematic_wave self) -> real"},
- { (char *)"new_constraint_kinematic_wave", (PyCFunction) _wrap_new_constraint_kinematic_wave, METH_VARARGS | METH_KEYWORDS, (char *)"new_constraint_kinematic_wave(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"},
+ { (char *)"new_constraint_kinematic_wave", (PyCFunction) _wrap_new_constraint_kinematic_wave, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_constraint_kinematic_wave(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\n"
+ "\n"
+ "constraint_kinematic_wave(WaterStorage::ptr source, WaterStorage::ptr\n"
+ "target, real residencetime=1.0, real exponent=1.0, real residual=0.0,\n"
+ "real V0=1.0, real Vrmax=1.0, real gamma=1.0)\n"
+ "\n"
+ "Creates a kinematic wave connection.\n"
+ "\n"
+ "\n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " q = \\\\frac 1 {t_r} {\\\\left(\\\\frac{V - V_{residual}}{V_0}\n"
+ " \\\\right)^\\\\beta} \n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "source: Water storage from which the water flows out. Flux is a\n"
+ "function of source.volume\n"
+ "\n"
+ "target: Target node (boundary condition or storage). Does not\n"
+ "influence the strength of the flow\n"
+ "\n"
+ "residencetime: :math:`t_r [days]` The residence time of the water in this\n"
+ "storage\n"
+ "\n"
+ "exponent: :math:`\\\\beta [-]` An empirical exponent to shape the flux\n"
+ "function (default = 1 (linear function))\n"
+ "\n"
+ "residual: :math:`V_{residual} [m^3]` The volume of water not flowing out\n"
+ "(default = 0)\n"
+ "\n"
+ "V0: :math:`V_0` The reference volume to scale the exponent\n"
+ "\n"
+ "Vrmax: :math:`V_{r,max}` Capacity of the target water storage in m3\n"
+ "\n"
+ "gamma: :math:`\\\\gamma` Target capacity constriction curve shape \n"
+ ""},
{ (char *)"delete_constraint_kinematic_wave", (PyCFunction)_wrap_delete_constraint_kinematic_wave, METH_O, (char *)"delete_constraint_kinematic_wave(constraint_kinematic_wave self)"},
{ (char *)"constraint_kinematic_wave_swigregister", constraint_kinematic_wave_swigregister, METH_VARARGS, NULL},
{ (char *)"constraint_kinematic_wave_swiginit", constraint_kinematic_wave_swiginit, METH_VARARGS, NULL},
@@ -75308,7 +76883,29 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"TechnicalFlux_MinState_get", (PyCFunction)_wrap_TechnicalFlux_MinState_get, METH_O, (char *)"TechnicalFlux_MinState_get(TechnicalFlux self) -> real"},
{ (char *)"TechnicalFlux_FluxDecreaseTime_set", _wrap_TechnicalFlux_FluxDecreaseTime_set, METH_VARARGS, (char *)"TechnicalFlux_FluxDecreaseTime_set(TechnicalFlux self, Time FluxDecreaseTime)"},
{ (char *)"TechnicalFlux_FluxDecreaseTime_get", (PyCFunction)_wrap_TechnicalFlux_FluxDecreaseTime_get, METH_O, (char *)"TechnicalFlux_FluxDecreaseTime_get(TechnicalFlux self) -> Time"},
- { (char *)"new_TechnicalFlux", (PyCFunction) _wrap_new_TechnicalFlux, METH_VARARGS | METH_KEYWORDS, (char *)"new_TechnicalFlux(cmf::water::WaterStorage::ptr source, cmf::water::flux_node::ptr target, real maximum_flux, real minimal_state=0, Time flux_decrease_time) -> TechnicalFlux"},
+ { (char *)"new_TechnicalFlux", (PyCFunction) _wrap_new_TechnicalFlux, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_TechnicalFlux(cmf::water::WaterStorage::ptr source, cmf::water::flux_node::ptr target, real maximum_flux, real minimal_state=0, Time flux_decrease_time) -> TechnicalFlux\n"
+ "\n"
+ "TechnicalFlux(cmf::water::WaterStorage::ptr source,\n"
+ "cmf::water::flux_node::ptr target, real maximum_flux, real\n"
+ "minimal_state=0, cmf::math::Time flux_decrease_time=cmf::math::h)\n"
+ "\n"
+ "Produces a constant but changeable flux from a source to a target, if\n"
+ "enough water is present in the source.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "source: The source of the water\n"
+ "\n"
+ "target: The target of the water\n"
+ "\n"
+ "maximum_flux: The requested flux :math:`q_{0}`\n"
+ "\n"
+ "minimal_state: Minimal volume of stored water in source\n"
+ "\n"
+ "flux_decrease_time: ( cmf::math::Time) \n"
+ ""},
{ (char *)"delete_TechnicalFlux", (PyCFunction)_wrap_delete_TechnicalFlux, METH_O, (char *)"delete_TechnicalFlux(TechnicalFlux self)"},
{ (char *)"TechnicalFlux_swigregister", TechnicalFlux_swigregister, METH_VARARGS, NULL},
{ (char *)"TechnicalFlux_swiginit", TechnicalFlux_swiginit, METH_VARARGS, NULL},
@@ -75318,7 +76915,28 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"generic_gradient_connection_A_get", (PyCFunction)_wrap_generic_gradient_connection_A_get, METH_O, (char *)"generic_gradient_connection_A_get(generic_gradient_connection self) -> real"},
{ (char *)"generic_gradient_connection_d_set", _wrap_generic_gradient_connection_d_set, METH_VARARGS, (char *)"generic_gradient_connection_d_set(generic_gradient_connection self, real d)"},
{ (char *)"generic_gradient_connection_d_get", (PyCFunction)_wrap_generic_gradient_connection_d_get, METH_O, (char *)"generic_gradient_connection_d_get(generic_gradient_connection self) -> real"},
- { (char *)"new_generic_gradient_connection", (PyCFunction) _wrap_new_generic_gradient_connection, METH_VARARGS | METH_KEYWORDS, (char *)"new_generic_gradient_connection(cmf::water::WaterStorage::ptr left, cmf::water::WaterStorage::ptr right, real K, real d=1.0, real A=1.0) -> generic_gradient_connection"},
+ { (char *)"new_generic_gradient_connection", (PyCFunction) _wrap_new_generic_gradient_connection, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_generic_gradient_connection(cmf::water::WaterStorage::ptr left, cmf::water::WaterStorage::ptr right, real K, real d=1.0, real A=1.0) -> generic_gradient_connection\n"
+ "\n"
+ "generic_gradient_connection(cmf::water::WaterStorage::ptr left,\n"
+ "cmf::water::WaterStorage::ptr right, real K, real d=1.0, real A=1.0)\n"
+ "\n"
+ "Creates a generic gradient based flux, if enough water is present in\n"
+ "the source.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "left: The left node of the connection\n"
+ "\n"
+ "right: The right node of the connection\n"
+ "\n"
+ "K: the conductivity of the connection in m/day\n"
+ "\n"
+ "d: the topographic lenght of the connection in m\n"
+ "\n"
+ "A: the area of the connection cross section in m2 \n"
+ ""},
{ (char *)"delete_generic_gradient_connection", (PyCFunction)_wrap_delete_generic_gradient_connection, METH_O, (char *)"delete_generic_gradient_connection(generic_gradient_connection self)"},
{ (char *)"generic_gradient_connection_swigregister", generic_gradient_connection_swigregister, METH_VARARGS, NULL},
{ (char *)"generic_gradient_connection_swiginit", generic_gradient_connection_swiginit, METH_VARARGS, NULL},
@@ -75326,65 +76944,481 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"statecontrol_connection_reaction_time_get", (PyCFunction)_wrap_statecontrol_connection_reaction_time_get, METH_O, (char *)"statecontrol_connection_reaction_time_get(statecontrol_connection self) -> Time"},
{ (char *)"statecontrol_connection_target_state_set", _wrap_statecontrol_connection_target_state_set, METH_VARARGS, (char *)"statecontrol_connection_target_state_set(statecontrol_connection self, real target_state)"},
{ (char *)"statecontrol_connection_target_state_get", (PyCFunction)_wrap_statecontrol_connection_target_state_get, METH_O, (char *)"statecontrol_connection_target_state_get(statecontrol_connection self) -> real"},
- { (char *)"new_statecontrol_connection", (PyCFunction) _wrap_new_statecontrol_connection, METH_VARARGS | METH_KEYWORDS, (char *)"new_statecontrol_connection(cmf::water::WaterStorage::ptr controlled_storage, cmf::water::flux_node::ptr other_end, real target_state, Time reaction_time) -> statecontrol_connection"},
+ { (char *)"new_statecontrol_connection", (PyCFunction) _wrap_new_statecontrol_connection, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_statecontrol_connection(cmf::water::WaterStorage::ptr controlled_storage, cmf::water::flux_node::ptr other_end, real target_state, Time reaction_time) -> statecontrol_connection\n"
+ "\n"
+ "statecontrol_connection(cmf::water::WaterStorage::ptr\n"
+ "controlled_storage, cmf::water::flux_node::ptr other_end, real\n"
+ "target_state, cmf::math::Time reaction_time)\n"
+ "\n"
+ "Creates a flux connection to control the state of a storage.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "controlled_storage: Water storage, to be controlled\n"
+ "\n"
+ "other_end: source of missing water or target of excessive water\n"
+ "\n"
+ "target_state: State the controlled storage should hold (\n"
+ ":math:`h_{target}`)\n"
+ "\n"
+ "reaction_time: Time to reach state ( :math:`t_c`) \n"
+ ""},
{ (char *)"delete_statecontrol_connection", (PyCFunction)_wrap_delete_statecontrol_connection, METH_O, (char *)"delete_statecontrol_connection(statecontrol_connection self)"},
{ (char *)"statecontrol_connection_swigregister", statecontrol_connection_swigregister, METH_VARARGS, NULL},
{ (char *)"statecontrol_connection_swiginit", statecontrol_connection_swiginit, METH_VARARGS, NULL},
- { (char *)"node_list_size", (PyCFunction)_wrap_node_list_size, METH_O, (char *)"node_list_size(node_list self) -> size_t"},
+ { (char *)"node_list_size", (PyCFunction)_wrap_node_list_size, METH_O, (char *)"\n"
+ "node_list_size(node_list self) -> size_t\n"
+ "\n"
+ "size_t size()\n"
+ "const\n"
+ "\n"
+ "The number of nodes. \n"
+ ""},
{ (char *)"new_node_list", _wrap_new_node_list, METH_VARARGS, (char *)"\n"
"node_list()\n"
"new_node_list(node_list forcopy) -> node_list\n"
+ "\n"
+ "node_list(const cmf::water::node_list &forcopy)\n"
+ "\n"
+ "Copy the node_list. \n"
""},
{ (char *)"node_list___iadd__", (PyCFunction) _wrap_node_list___iadd__, METH_VARARGS | METH_KEYWORDS, (char *)"node_list___iadd__(node_list self, node_list right) -> node_list"},
{ (char *)"node_list___add__", (PyCFunction) _wrap_node_list___add__, METH_VARARGS | METH_KEYWORDS, (char *)"node_list___add__(node_list self, node_list right) -> node_list"},
- { (char *)"node_list___get", (PyCFunction) _wrap_node_list___get, METH_VARARGS | METH_KEYWORDS, (char *)"node_list___get(node_list self, ptrdiff_t index) -> cmf::water::flux_node::ptr"},
- { (char *)"node_list___getslice", (PyCFunction) _wrap_node_list___getslice, METH_VARARGS | METH_KEYWORDS, (char *)"node_list___getslice(node_list self, ptrdiff_t begin, ptrdiff_t end, ptrdiff_t step=1) -> node_list"},
- { (char *)"node_list_append", (PyCFunction) _wrap_node_list_append, METH_VARARGS | METH_KEYWORDS, (char *)"node_list_append(node_list self, cmf::water::flux_node::ptr node)"},
- { (char *)"node_list_remove", (PyCFunction) _wrap_node_list_remove, METH_VARARGS | METH_KEYWORDS, (char *)"node_list_remove(node_list self, cmf::water::flux_node::ptr node) -> bool"},
- { (char *)"node_list_global_water_balance", (PyCFunction) _wrap_node_list_global_water_balance, METH_VARARGS | METH_KEYWORDS, (char *)"node_list_global_water_balance(node_list self, Time t) -> real"},
- { (char *)"node_list_water_balance", (PyCFunction) _wrap_node_list_water_balance, METH_VARARGS | METH_KEYWORDS, (char *)"node_list_water_balance(node_list self, Time t) -> cmf::math::num_array"},
- { (char *)"node_list_conc", (PyCFunction) _wrap_node_list_conc, METH_VARARGS | METH_KEYWORDS, (char *)"node_list_conc(node_list self, Time t, solute _Solute) -> cmf::math::num_array"},
- { (char *)"node_list_set_solute_source", (PyCFunction) _wrap_node_list_set_solute_source, METH_VARARGS | METH_KEYWORDS, (char *)"node_list_set_solute_source(node_list self, solute _Solute, cmf::math::num_array source_fluxes) -> ptrdiff_t"},
- { (char *)"node_list_get_fluxes_to", (PyCFunction) _wrap_node_list_get_fluxes_to, METH_VARARGS | METH_KEYWORDS, (char *)"node_list_get_fluxes_to(node_list self, node_list targets, Time t) -> cmf::math::num_array"},
- { (char *)"node_list_get_fluxes3d_to", (PyCFunction) _wrap_node_list_get_fluxes3d_to, METH_VARARGS | METH_KEYWORDS, (char *)"node_list_get_fluxes3d_to(node_list self, node_list targets, Time t) -> point_vector"},
- { (char *)"node_list_get_fluxes3d", (PyCFunction) _wrap_node_list_get_fluxes3d, METH_VARARGS | METH_KEYWORDS, (char *)"node_list_get_fluxes3d(node_list self, Time t) -> point_vector"},
- { (char *)"node_list_get_positions", (PyCFunction)_wrap_node_list_get_positions, METH_O, (char *)"node_list_get_positions(node_list self) -> point_vector"},
+ { (char *)"node_list___get", (PyCFunction) _wrap_node_list___get, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "node_list___get(node_list self, ptrdiff_t index) -> cmf::water::flux_node::ptr\n"
+ "\n"
+ "flux_node::ptr\n"
+ "get(ptrdiff_t index) const\n"
+ "\n"
+ "Returns a node in the node_list. \n"
+ ""},
+ { (char *)"node_list___getslice", (PyCFunction) _wrap_node_list___getslice, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "node_list___getslice(node_list self, ptrdiff_t begin, ptrdiff_t end, ptrdiff_t step=1) -> node_list\n"
+ "\n"
+ "node_list\n"
+ "getslice(ptrdiff_t begin, ptrdiff_t end, ptrdiff_t step=1) const\n"
+ "\n"
+ "Returns a slice of the node_list. \n"
+ ""},
+ { (char *)"node_list_append", (PyCFunction) _wrap_node_list_append, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "node_list_append(node_list self, cmf::water::flux_node::ptr node)\n"
+ "\n"
+ "void\n"
+ "append(flux_node::ptr node)\n"
+ "\n"
+ "Adds a flux node to the list. \n"
+ ""},
+ { (char *)"node_list_remove", (PyCFunction) _wrap_node_list_remove, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "node_list_remove(node_list self, cmf::water::flux_node::ptr node) -> bool\n"
+ "\n"
+ "bool\n"
+ "remove(flux_node::ptr node)\n"
+ "\n"
+ "Removes a flux node from the list, returns true if successful. \n"
+ ""},
+ { (char *)"node_list_global_water_balance", (PyCFunction) _wrap_node_list_global_water_balance, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "node_list_global_water_balance(node_list self, Time t) -> real\n"
+ "\n"
+ "real global_water_balance(cmf::math::Time t) const\n"
+ "\n"
+ "Returns the sum of the water balances of the nodes.\n"
+ "\n"
+ "\n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " \\\\sigma_{global} =\n"
+ " \\\\sum_{i=0}^N{\\\\sum_{j=0}^{C_i}{q_{ij}(t)}} \n"
+ "\n"
+ "Replaces slow Python code like: \n"
+ ""},
+ { (char *)"node_list_water_balance", (PyCFunction) _wrap_node_list_water_balance, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "node_list_water_balance(node_list self, Time t) -> cmf::math::num_array\n"
+ "\n"
+ "cmf::math::num_array water_balance(cmf::math::Time t) const\n"
+ "\n"
+ "Returns the water balance of each vector as a vector.\n"
+ "\n"
+ "\n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " \\\\sigma_i = \\\\sum_{j=0}^{C_i}{q_{ij}(t)} \n"
+ "\n"
+ "Replaces slow Python code like: \n"
+ ""},
+ { (char *)"node_list_conc", (PyCFunction) _wrap_node_list_conc, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "node_list_conc(node_list self, Time t, solute _Solute) -> cmf::math::num_array\n"
+ "\n"
+ "cmf::math::num_array conc(cmf::math::Time t, const cmf::water::solute\n"
+ "&_Solute) const\n"
+ "\n"
+ "Returns an array holding the concentration of all the flux nodes for\n"
+ "the given solute. \n"
+ ""},
+ { (char *)"node_list_set_solute_source", (PyCFunction) _wrap_node_list_set_solute_source, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "node_list_set_solute_source(node_list self, solute _Solute, cmf::math::num_array source_fluxes) -> ptrdiff_t\n"
+ "\n"
+ "ptrdiff_t set_solute_source(const cmf::water::solute &_Solute,\n"
+ "cmf::math::num_array source_fluxes)\n"
+ "\n"
+ "Sets the source flux of a solute storage associated with a node (node\n"
+ "has to be a water storage) \n"
+ ""},
+ { (char *)"node_list_get_fluxes_to", (PyCFunction) _wrap_node_list_get_fluxes_to, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "node_list_get_fluxes_to(node_list self, node_list targets, Time t) -> cmf::math::num_array\n"
+ "\n"
+ "cmf::math::num_array get_fluxes_to(const cmf::water::node_list\n"
+ "&targets, cmf::math::Time t) const\n"
+ "\n"
+ "A fast method to perform flux queries as a batch.\n"
+ "\n"
+ "The node lists left and right should have the same length.\n"
+ "\n"
+ "The vector containing the flux from left to right at the same position\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "targets: A node_list containing the source nodes\n"
+ "\n"
+ "t: The time for the fluxes\n"
+ "\n"
+ "Replaces slow Python code like: \n"
+ ""},
+ { (char *)"node_list_get_fluxes3d_to", (PyCFunction) _wrap_node_list_get_fluxes3d_to, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "node_list_get_fluxes3d_to(node_list self, node_list targets, Time t) -> point_vector\n"
+ "\n"
+ "cmf::geometry::point_vector get_fluxes3d_to(const\n"
+ "cmf::water::node_list &targets, cmf::math::Time t) const\n"
+ "\n"
+ "Returns the flux vectors to the nodes of a given target node_list. \n"
+ ""},
+ { (char *)"node_list_get_fluxes3d", (PyCFunction) _wrap_node_list_get_fluxes3d, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "node_list_get_fluxes3d(node_list self, Time t) -> point_vector\n"
+ "\n"
+ "cmf::geometry::point_vector get_fluxes3d(cmf::math::Time t) const\n"
+ "\n"
+ "Returns the current flow vector for each node. \n"
+ ""},
+ { (char *)"node_list_get_positions", (PyCFunction)_wrap_node_list_get_positions, METH_O, (char *)"\n"
+ "node_list_get_positions(node_list self) -> point_vector\n"
+ "\n"
+ "cmf::geometry::point_vector get_positions() const\n"
+ "\n"
+ "Returns the positions of the nodes. \n"
+ ""},
{ (char *)"node_list_potentials_set", _wrap_node_list_potentials_set, METH_VARARGS, (char *)"node_list_potentials_set(node_list self, cmf::math::num_array potentials)"},
{ (char *)"node_list_potentials_get", (PyCFunction)_wrap_node_list_potentials_get, METH_O, (char *)"node_list_potentials_get(node_list self) -> cmf::math::num_array"},
{ (char *)"delete_node_list", (PyCFunction)_wrap_delete_node_list, METH_O, (char *)"delete_node_list(node_list self)"},
{ (char *)"node_list_swigregister", node_list_swigregister, METH_VARARGS, NULL},
{ (char *)"node_list_swiginit", node_list_swiginit, METH_VARARGS, NULL},
- { (char *)"NeumannBoundary_list_get", (PyCFunction) _wrap_NeumannBoundary_list_get, METH_VARARGS | METH_KEYWORDS, (char *)"NeumannBoundary_list_get(NeumannBoundary_list self, ptrdiff_t index) -> cmf::water::NeumannBoundary::ptr"},
- { (char *)"NeumannBoundary_list_get_fluxes", (PyCFunction) _wrap_NeumannBoundary_list_get_fluxes, METH_VARARGS | METH_KEYWORDS, (char *)"NeumannBoundary_list_get_fluxes(NeumannBoundary_list self, Time t) -> cmf::math::num_array"},
- { (char *)"NeumannBoundary_list_append", (PyCFunction) _wrap_NeumannBoundary_list_append, METH_VARARGS | METH_KEYWORDS, (char *)"NeumannBoundary_list_append(NeumannBoundary_list self, cmf::water::NeumannBoundary::ptr nbc)"},
- { (char *)"NeumannBoundary_list_size", (PyCFunction)_wrap_NeumannBoundary_list_size, METH_O, (char *)"NeumannBoundary_list_size(NeumannBoundary_list self) -> size_t"},
+ { (char *)"NeumannBoundary_list_get", (PyCFunction) _wrap_NeumannBoundary_list_get, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "NeumannBoundary_list_get(NeumannBoundary_list self, ptrdiff_t index) -> cmf::water::NeumannBoundary::ptr\n"
+ "\n"
+ "NeumannBoundary::ptr get(ptrdiff_t index) const\n"
+ "\n"
+ "Returns the Neumann boundary condition at position index.\n"
+ "\n"
+ "From Python you can use [] \n"
+ ""},
+ { (char *)"NeumannBoundary_list_get_fluxes", (PyCFunction) _wrap_NeumannBoundary_list_get_fluxes, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "NeumannBoundary_list_get_fluxes(NeumannBoundary_list self, Time t) -> cmf::math::num_array\n"
+ "\n"
+ "cmf::math::num_array get_fluxes(cmf::math::Time t=cmf::math::Time())\n"
+ "const\n"
+ "\n"
+ "Returns the fluxes of the items as an array.\n"
+ "\n"
+ "get_fluxes and set_fluxes are wrapped with the Python property fluxes\n"
+ "\n"
+ ""},
+ { (char *)"NeumannBoundary_list_append", (PyCFunction) _wrap_NeumannBoundary_list_append, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "NeumannBoundary_list_append(NeumannBoundary_list self, cmf::water::NeumannBoundary::ptr nbc)\n"
+ "\n"
+ "void\n"
+ "append(NeumannBoundary::ptr nbc)\n"
+ "\n"
+ "Appends a neumann boundary to this list. \n"
+ ""},
+ { (char *)"NeumannBoundary_list_size", (PyCFunction)_wrap_NeumannBoundary_list_size, METH_O, (char *)"\n"
+ "NeumannBoundary_list_size(NeumannBoundary_list self) -> size_t\n"
+ "\n"
+ "size_t\n"
+ "size() const\n"
+ "\n"
+ "returns the number of stored boundary conditions \n"
+ ""},
{ (char *)"new_NeumannBoundary_list", _wrap_new_NeumannBoundary_list, METH_VARARGS, (char *)"\n"
"NeumannBoundary_list()\n"
"NeumannBoundary_list(node_list copy)\n"
"new_NeumannBoundary_list(NeumannBoundary_list copy) -> NeumannBoundary_list\n"
+ "\n"
+ "NeumannBoundary_list(const NeumannBoundary_list ©) \n"
+ ""},
+ { (char *)"NeumannBoundary_list_to_node_list", (PyCFunction)_wrap_NeumannBoundary_list_to_node_list, METH_O, (char *)"\n"
+ "NeumannBoundary_list_to_node_list(NeumannBoundary_list self) -> node_list\n"
+ "\n"
+ "cmf::water::node_list to_node_list() const\n"
+ "\n"
+ "Creates a node_list from this NeumannBoundary_list. \n"
+ ""},
+ { (char *)"NeumannBoundary_list_global_water_balance", (PyCFunction) _wrap_NeumannBoundary_list_global_water_balance, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "NeumannBoundary_list_global_water_balance(NeumannBoundary_list self, Time t) -> real\n"
+ "\n"
+ "real\n"
+ "global_water_balance(cmf::math::Time t) const\n"
+ "\n"
+ "Returns the sum of the water balances of the nodes\n"
+ "\n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " \\\\sigma_{global} =\n"
+ " \\\\sum_{i=0}^N{\\\\sum_{j=0}^{C_i}{q_{ij}(t)}} \n"
+ "\n"
+ ".\n"
+ "\n"
+ "Replaces slow Python code like: \n"
+ ""},
+ { (char *)"NeumannBoundary_list_water_balance", (PyCFunction) _wrap_NeumannBoundary_list_water_balance, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "NeumannBoundary_list_water_balance(NeumannBoundary_list self, Time t) -> cmf::math::num_array\n"
+ "\n"
+ "cmf::math::num_array water_balance(cmf::math::Time t) const\n"
+ "\n"
+ "Returns the water balance of each vector as a vector \n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " \\\\sigma_i\n"
+ " = \\\\sum_{j=0}^{C_i}{q_{ij}(t)} \n"
+ "\n"
+ ".\n"
+ "\n"
+ "Replaces slow Python code like: \n"
""},
- { (char *)"NeumannBoundary_list_to_node_list", (PyCFunction)_wrap_NeumannBoundary_list_to_node_list, METH_O, (char *)"NeumannBoundary_list_to_node_list(NeumannBoundary_list self) -> node_list"},
- { (char *)"NeumannBoundary_list_global_water_balance", (PyCFunction) _wrap_NeumannBoundary_list_global_water_balance, METH_VARARGS | METH_KEYWORDS, (char *)"NeumannBoundary_list_global_water_balance(NeumannBoundary_list self, Time t) -> real"},
- { (char *)"NeumannBoundary_list_water_balance", (PyCFunction) _wrap_NeumannBoundary_list_water_balance, METH_VARARGS | METH_KEYWORDS, (char *)"NeumannBoundary_list_water_balance(NeumannBoundary_list self, Time t) -> cmf::math::num_array"},
{ (char *)"NeumannBoundary_list_fluxes_set", _wrap_NeumannBoundary_list_fluxes_set, METH_VARARGS, (char *)"NeumannBoundary_list_fluxes_set(NeumannBoundary_list self, cmf::math::num_array fluxes)"},
{ (char *)"NeumannBoundary_list_fluxes_get", (PyCFunction)_wrap_NeumannBoundary_list_fluxes_get, METH_O, (char *)"NeumannBoundary_list_fluxes_get(NeumannBoundary_list self) -> cmf::math::num_array"},
{ (char *)"delete_NeumannBoundary_list", (PyCFunction)_wrap_delete_NeumannBoundary_list, METH_O, (char *)"delete_NeumannBoundary_list(NeumannBoundary_list self)"},
{ (char *)"NeumannBoundary_list_swigregister", NeumannBoundary_list_swigregister, METH_VARARGS, NULL},
{ (char *)"NeumannBoundary_list_swiginit", NeumannBoundary_list_swiginit, METH_VARARGS, NULL},
- { (char *)"SystemBridge_get_upper_node", (PyCFunction)_wrap_SystemBridge_get_upper_node, METH_O, (char *)"SystemBridge_get_upper_node(SystemBridge self) -> cmf::water::flux_node::ptr"},
- { (char *)"SystemBridge_get_lower_node", (PyCFunction)_wrap_SystemBridge_get_lower_node, METH_O, (char *)"SystemBridge_get_lower_node(SystemBridge self) -> cmf::water::flux_node::ptr"},
- { (char *)"SystemBridge_get_down_flux", (PyCFunction)_wrap_SystemBridge_get_down_flux, METH_O, (char *)"SystemBridge_get_down_flux(SystemBridge self) -> double"},
- { (char *)"SystemBridge_down_flux_integrator", (PyCFunction)_wrap_SystemBridge_down_flux_integrator, METH_O, (char *)"SystemBridge_down_flux_integrator(SystemBridge self) -> cmf::water::flux_integrator::ptr"},
+ { (char *)"SystemBridge_get_upper_node", (PyCFunction)_wrap_SystemBridge_get_upper_node, METH_O, (char *)"\n"
+ "SystemBridge_get_upper_node(SystemBridge self) -> cmf::water::flux_node::ptr\n"
+ "\n"
+ "flux_node::ptr get_upper_node() const\n"
+ "\n"
+ "Returns the upper node. \n"
+ ""},
+ { (char *)"SystemBridge_get_lower_node", (PyCFunction)_wrap_SystemBridge_get_lower_node, METH_O, (char *)"\n"
+ "SystemBridge_get_lower_node(SystemBridge self) -> cmf::water::flux_node::ptr\n"
+ "\n"
+ "flux_node::ptr get_lower_node() const\n"
+ "\n"
+ "Returns the lower node. \n"
+ ""},
+ { (char *)"SystemBridge_get_down_flux", (PyCFunction)_wrap_SystemBridge_get_down_flux, METH_O, (char *)"\n"
+ "SystemBridge_get_down_flux(SystemBridge self) -> double\n"
+ "\n"
+ "double get_down_flux() const\n"
+ "\n"
+ "Returns the currently integrated flux to the lower node. \n"
+ ""},
+ { (char *)"SystemBridge_down_flux_integrator", (PyCFunction)_wrap_SystemBridge_down_flux_integrator, METH_O, (char *)"\n"
+ "SystemBridge_down_flux_integrator(SystemBridge self) -> cmf::water::flux_integrator::ptr\n"
+ "\n"
+ "flux_integrator::ptr down_flux_integrator() const \n"
+ ""},
{ (char *)"delete_SystemBridge", (PyCFunction)_wrap_delete_SystemBridge, METH_O, (char *)"delete_SystemBridge(SystemBridge self)"},
{ (char *)"SystemBridge_swigregister", SystemBridge_swigregister, METH_VARARGS, NULL},
{ (char *)"delete_SystemBridgeConnection", (PyCFunction)_wrap_delete_SystemBridgeConnection, METH_O, (char *)"delete_SystemBridgeConnection(SystemBridgeConnection self)"},
{ (char *)"SystemBridgeConnection_swigregister", SystemBridgeConnection_swigregister, METH_VARARGS, NULL},
- { (char *)"system_bridge", (PyCFunction) _wrap_system_bridge, METH_VARARGS | METH_KEYWORDS, (char *)"system_bridge(project p, cmf::water::flux_node::ptr upper, cmf::water::flux_node::ptr lower) -> cmf::water::SystemBridge::ptr"},
- { (char *)"vapour_pressure", (PyCFunction) _wrap_vapour_pressure, METH_VARARGS | METH_KEYWORDS, (char *)"vapour_pressure(double T) -> double"},
- { (char *)"vpd_from_rH", (PyCFunction) _wrap_vpd_from_rH, METH_VARARGS | METH_KEYWORDS, (char *)"vpd_from_rH(double T, double rH) -> double"},
- { (char *)"rH_from_vpd", (PyCFunction) _wrap_rH_from_vpd, METH_VARARGS | METH_KEYWORDS, (char *)"rH_from_vpd(double T, double vpd) -> double"},
- { (char *)"global_radiation", (PyCFunction) _wrap_global_radiation, METH_VARARGS | METH_KEYWORDS, (char *)"global_radiation(Time t, double height, double sunshine_fraction, double longitude=8, double latitude=51, double time_zone=1, bool daily=False) -> double"},
- { (char *)"Pressure", (PyCFunction) _wrap_Pressure, METH_VARARGS | METH_KEYWORDS, (char *)"Pressure(double height) -> double"},
+ { (char *)"system_bridge", (PyCFunction) _wrap_system_bridge, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "system_bridge(project p, cmf::water::flux_node::ptr upper, cmf::water::flux_node::ptr lower) -> cmf::water::SystemBridge::ptr\n"
+ "\n"
+ "SystemBridge::ptr\n"
+ "cmf::water::system_bridge(cmf::project &p, flux_node::ptr upper,\n"
+ "flux_node::ptr lower)\n"
+ "\n"
+ "Creates a SystemBridge object.\n"
+ "\n"
+ "This is an advanced feature for tuning of the calculation time.\n"
+ "\n"
+ "A SystemBridge can be used to replace an existing connection between\n"
+ "nodes. After installation, the two nodes can more safely be added to\n"
+ "different integrator systems. One node (called upper) is connected\n"
+ "with the system bridge with the connection formerly connecting the\n"
+ "nodes, the second node (called lower) is connected to the system\n"
+ "bridge with as a Neumann boundary condition. The flux equals the\n"
+ "average flux of the connection upper <-> SystemBridge. Therefore, the\n"
+ "system bridge must become an integratable of the integrator system the\n"
+ "upper node belongs to. Use as an upper system (system upper node is\n"
+ "belonging to) the faster reacting system. For the connection between\n"
+ "upper and SystemBridge, the SystemBridge reacts as an Dirichlet\n"
+ "boundary condition, providing the potential of the lower node. \n"
+ ""},
+ { (char *)"vapour_pressure", (PyCFunction) _wrap_vapour_pressure, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "vapour_pressure(double T) -> double\n"
+ "\n"
+ "double\n"
+ "cmf::atmosphere::vapour_pressure(double T)\n"
+ "\n"
+ "Returns the saturated vapor pressure in Pa for temperature T [degC].\n"
+ "\n"
+ "The saturated vapor pressure :math:`e_s` is calculated follwing the\n"
+ "following formula \n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " e_s = 0.6108 \\\\exp{\\\\frac{17.27\n"
+ " T}{T+237.3}}\n"
+ "\n"
+ "The definition is\n"
+ "fromhttp://www.fao.org/docrep/X0490E/x0490e07.htm#concepts \n"
+ ""},
+ { (char *)"vpd_from_rH", (PyCFunction) _wrap_vpd_from_rH, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "vpd_from_rH(double T, double rH) -> double\n"
+ "\n"
+ "double\n"
+ "cmf::atmosphere::vpd_from_rH(double T, double rH)\n"
+ "\n"
+ "Returns the vapor pressure deficit in Pa for temperature T [degC] and\n"
+ "rel.\n"
+ "\n"
+ "humidity rH [%]\n"
+ "\n"
+ "The vapor pressure deficit :math:`e_s - e_a` is calculated from rel.\n"
+ "humidity as: \n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " e_s - e_a = (1-rH/100) * e_s(T)\n"
+ "\n"
+ "The definition\n"
+ "is fromhttp://www.fao.org/docrep/X0490E/x0490e07.htm#concepts\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "T: Air temperature in degC\n"
+ "\n"
+ "rH: Rel. humidity in %\n"
+ "\n"
+ ":math:`e_s(T)` is calculated using cmf::atmosphere::vapor_pressure(double)\n"
+ "\n"
+ ""},
+ { (char *)"rH_from_vpd", (PyCFunction) _wrap_rH_from_vpd, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "rH_from_vpd(double T, double vpd) -> double\n"
+ "\n"
+ "double\n"
+ "cmf::atmosphere::rH_from_vpd(double T, double vpd)\n"
+ "\n"
+ "Returns the rel.\n"
+ "\n"
+ "humidity in % for temperature T [degC] and vapor pressure deficit vpd\n"
+ "[Pa]\n"
+ "\n"
+ "the rel. humidity is calculated from the vapor pressure deficit :math:`vpd = e_s - e_a` as: \n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " rH = 100 * \\\\frac{e_a}{e_s(T)}, e_a = e_s(T) -\n"
+ " vpd\n"
+ "\n"
+ "The definition is\n"
+ "fromhttp://www.fao.org/docrep/X0490E/x0490e07.htm#concepts\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "T: Air temperature in degC\n"
+ "\n"
+ "vpd: Vapor pressure deficit in Pa\n"
+ "\n"
+ ":math:`e_s(T)` is calculated using cmf::atmosphere::vapor_pressure(double)\n"
+ "\n"
+ ""},
+ { (char *)"global_radiation", (PyCFunction) _wrap_global_radiation, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "global_radiation(Time t, double height, double sunshine_fraction, double longitude=8, double latitude=51, double time_zone=1, bool daily=False) -> double\n"
+ "\n"
+ "double\n"
+ "cmf::atmosphere::global_radiation(cmf::math::Time t, double height,\n"
+ "double sunshine_fraction, double longitude=8, double latitude=51,\n"
+ "double time_zone=1, bool daily=0)\n"
+ "\n"
+ "Calculates the global radiation in MJ/(m2 day) from the sun position\n"
+ "and the sunshine fraction.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "t: actual time step\n"
+ "\n"
+ "height: Height above sea level\n"
+ "\n"
+ "sunshine_fraction: Fraction of sunshine hours per potential sunshine\n"
+ "duration in h/h\n"
+ "\n"
+ "longitude: latitude: Geographical position in degree. Latitude is\n"
+ "only taken into acount for subdaily calculation\n"
+ "\n"
+ "time_zone: Offset by timezone from GMT, eg. central Europe=1 US west\n"
+ "coast = -8\n"
+ "\n"
+ "daily: If true, the average radiation for the whole day is given\n"
+ "(therefore latitude and time zone ignored), otherwise the average of\n"
+ "the current hour is returned\n"
+ "\n"
+ "The calculation of the global radiation\n"
+ "followshttp://www.fao.org/docrep/X0490E/x0490e07.htm#radiation.\n"
+ "\n"
+ "The following formula is used: \n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " \\\\phi &=&\n"
+ " \\\\frac{(\\\\mbox{geogr. Latitude})^\\\\circ \\\\pi}{180^\\\\circ}\n"
+ " \\\\mbox{ Latitude in }rad \\\\\\\\ \\\\delta &=& 0.409\n"
+ " \\\\sin\\\\left(\\\\frac{2\\\\pi}{365}DOY - 1.39\\\\right) \\\\mbox{\n"
+ " Declination, DOY is day of year}\\\\\\\\ \\\\omega_s &=&\n"
+ " \\\\arccos(-\\\\tan\\\\phi\\\\tan\\\\delta) \\\\mbox{ Sunset angle}\n"
+ " \\\\\\\\ G_{sc} &=& 0.0802 \\\\frac{MJ}{m^2min} \\\\mbox{Solar\n"
+ " constant} \\\\\\\\ d_r &=& 1+0.033\n"
+ " \\\\cos\\\\left(\\\\frac{2\\\\pi}{365}DOY\\\\right) \\\\mbox{Inverse\n"
+ " relative distance Earth-Sun} \\\\\\\\ b &=&\n"
+ " \\\\frac{2\\\\pi(DOY-81)}{364}\\\\\\\\ S_c &=&\n"
+ " 0.1645\\\\sin(2b)-0.1255\\\\cos(b)-0.025\\\\sin(b) \\\\mbox{ Seasonal\n"
+ " correction for solar time} \\\\\\\\ \\\\omega &=& \\\\frac {\\\\pi}\n"
+ " {12} \\\\left(t_h+\\\\frac{(\\\\mbox{geogr.\n"
+ " Longitude})^\\\\circ}{15}-\\\\mbox{Timezone}+S_c-12\\\\right)\n"
+ " \\\\mbox{ solar time in }rad \\\\\\\\ \\\\mbox{If daily} \\\\\\\\ R_a\n"
+ " &=& \\\\frac{24\\\\ 60}{\\\\pi}G_{sc}\\\\ d_r \\\\left(\\\\omega_s\n"
+ " \\\\sin\\\\phi \\\\sin\\\\delta + \\\\cos\\\\phi \\\\cos\\\\delta\n"
+ " \\\\sin\\\\omega_s\\\\right) \\\\mbox{Extraterrestrial radiation }\n"
+ " \\\\frac{MJ}{m^2 day} \\\\\\\\ \\\\mbox{If hourly} \\\\\\\\ R_a &=&\n"
+ " \\\\frac{12\\\\ 24\\\\ 60}{\\\\pi}G_{sc}\\\\ d_r\n"
+ " \\\\left(\\\\left(\\\\omega^+ -\\\\omega^-\\\\right) \\\\sin\\\\phi\n"
+ " \\\\sin\\\\delta + \\\\cos\\\\phi \\\\cos\\\\delta\n"
+ " \\\\left(\\\\sin\\\\omega^+ - \\\\sin\\\\omega^-\\\\right)\\\\right)\n"
+ " \\\\\\\\ && \\\\omega^+,\\\\omega^- = \\\\omega\n"
+ " \\\\pm\\\\frac{\\\\pi}{24} \\\\\\\\ \\\\frac n N &=&\n"
+ " \\\\mbox{Fractional sunshine duration} \\\\\\\\ R_s &=&\n"
+ " \\\\left(0.25+\\\\left(0.5+2\\\\\n"
+ " 10^{-5}z\\\\right)\\\\frac{n}{N}\\\\right)R_a \\\\mbox{Global\n"
+ " radiation in }\\\\frac{MJ}{m^2 day} \\\\\\\\ && z=\\\\mbox{Height\n"
+ " a.s.l. in }m \\\\\\\\ \n"
+ "\n"
+ "\n"
+ ""},
+ { (char *)"Pressure", (PyCFunction) _wrap_Pressure, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Pressure(double height) -> double\n"
+ "\n"
+ "double\n"
+ "cmf::atmosphere::Pressure(double height)\n"
+ "\n"
+ "Returns the average air pressure for a height (m a.s.l.) \n"
+ ""},
{ (char *)"Weather_T_set", _wrap_Weather_T_set, METH_VARARGS, (char *)"Weather_T_set(Weather self, double T)"},
{ (char *)"Weather_T_get", (PyCFunction)_wrap_Weather_T_get, METH_O, (char *)"Weather_T_get(Weather self) -> double"},
{ (char *)"Weather_Tmax_set", _wrap_Weather_Tmax_set, METH_VARARGS, (char *)"Weather_Tmax_set(Weather self, double Tmax)"},
@@ -75407,9 +77441,78 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"Weather_daylength_get", (PyCFunction)_wrap_Weather_daylength_get, METH_O, (char *)"Weather_daylength_get(Weather self) -> double"},
{ (char *)"Weather_instrument_height_set", _wrap_Weather_instrument_height_set, METH_VARARGS, (char *)"Weather_instrument_height_set(Weather self, double instrument_height)"},
{ (char *)"Weather_instrument_height_get", (PyCFunction)_wrap_Weather_instrument_height_get, METH_O, (char *)"Weather_instrument_height_get(Weather self) -> double"},
- { (char *)"Weather_Rn", (PyCFunction) _wrap_Weather_Rn, METH_VARARGS | METH_KEYWORDS, (char *)"Weather_Rn(Weather self, double albedo, bool daily=False) -> double"},
- { (char *)"new_Weather", (PyCFunction) _wrap_new_Weather, METH_VARARGS | METH_KEYWORDS, (char *)"new_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) -> Weather"},
- { (char *)"Weather_to_string", (PyCFunction)_wrap_Weather_to_string, METH_O, (char *)"Weather_to_string(Weather self) -> std::string"},
+ { (char *)"Weather_Rn", (PyCFunction) _wrap_Weather_Rn, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Weather_Rn(Weather self, double albedo, bool daily=False) -> double\n"
+ "\n"
+ "double Rn(double\n"
+ "albedo, bool daily=false) const\n"
+ "\n"
+ "Calculates the net radiation flux :math:`R_n \\\\left[\\\\frac{MJ}{m^2 day}\\\\right]`.\n"
+ "\n"
+ "\n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " R_{n} &=& R_{ns} - R_{nl} \\\\\\\\ \\\\mbox{ Net\n"
+ " short wave radiation: }R_{ns} &=& (1-\\\\alpha) R_s \\\\\\\\ \\\\mbox{\n"
+ " Net long wave radiation: }R_{nl} &=& R_{black}\\\\ \\\\beta_{v}\\\\\n"
+ " \\\\beta_{c} \\\\\\\\ \\\\mbox{Black body radiation: } R_{black} &=&\n"
+ " \\\\left\\\\{\\\\begin{array}{cl} \\\\sigma T^4 & \\\\mbox{for less\n"
+ " than daily time steps} \\\\\\\\ \\\\sigma \\\\frac {T_{max}^4 +\n"
+ " T_{min}^4} 2 & \\\\mbox{for daily time steps} \\\\end{array}\n"
+ " \\\\right. \\\\\\\\ T &=& \\\\mbox{Temperature }[K] \\\\\\\\ \\\\sigma\n"
+ " &=& 4.903\\\\ 10^{-9} \\\\frac{MJ}{K^4 m^2 day} \\\\mbox{ Stefan-\n"
+ " Boltzmann constant } \\\\\\\\ \\\\mbox{Long wave reflectance: }\n"
+ " \\\\\\\\ \\\\mbox{by water vapor: }\\\\beta_{v} &=& 0.34 - 0.14\n"
+ " \\\\sqrt{e_a} \\\\\\\\ \\\\mbox{ by clouds: }\\\\beta_{c} &=& 0.1 +\n"
+ " 0.9 \\\\frac n N \n"
+ "\n"
+ "\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "albedo: the albedo :math:`\\\\alpha` of the surface\n"
+ "\n"
+ "daily: If true, the net radiation for daily averages will be\n"
+ "calculated \n"
+ ""},
+ { (char *)"new_Weather", (PyCFunction) _wrap_new_Weather, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_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) -> Weather\n"
+ "\n"
+ "Weather(double T=15.0, double Tmax=17.0, double Tmin=13.0, double\n"
+ "rH=70.0, double wind=2.0, double sunshine=0.5, double Rs=15, double\n"
+ "daylength=12)\n"
+ "\n"
+ "Creates a \"weather\" from given data.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "T: actual Temperature in deg C\n"
+ "\n"
+ "Tmax: daily maximum Temperature in deg C\n"
+ "\n"
+ "Tmin: daily minimum Temperature in deg C\n"
+ "\n"
+ "rH: actual relative humidity in % [0..100]\n"
+ "\n"
+ "wind: actual wind speed in m/s\n"
+ "\n"
+ "sunshine: actual fraction of sunshine duration per potential sunshine\n"
+ "duration in h/h\n"
+ "\n"
+ "Rs: actual incoming shortwave global radiation in MJ/(m2 day)\n"
+ "\n"
+ "daylength: length of the day in h \n"
+ ""},
+ { (char *)"Weather_to_string", (PyCFunction)_wrap_Weather_to_string, METH_O, (char *)"\n"
+ "Weather_to_string(Weather self) -> std::string\n"
+ "\n"
+ "std::string to_string() const\n"
+ "\n"
+ "Returns a string representation. \n"
+ ""},
{ (char *)"Weather_set_snow_threshold", (PyCFunction) _wrap_Weather_set_snow_threshold, METH_VARARGS | METH_KEYWORDS, (char *)"Weather_set_snow_threshold(double new_threshold)"},
{ (char *)"Weather_get_snow_threshold", (PyCFunction)_wrap_Weather_get_snow_threshold, METH_NOARGS, (char *)"Weather_get_snow_threshold() -> double"},
{ (char *)"Weather___iadd__", (PyCFunction) _wrap_Weather___iadd__, METH_VARARGS | METH_KEYWORDS, (char *)"Weather___iadd__(Weather self, Weather w) -> Weather"},
@@ -75420,10 +77523,37 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"Weather_swigregister", Weather_swigregister, METH_VARARGS, NULL},
{ (char *)"Weather_swiginit", Weather_swiginit, METH_VARARGS, NULL},
{ (char *)"Meteorology___call__", (PyCFunction) _wrap_Meteorology___call__, METH_VARARGS | METH_KEYWORDS, (char *)"Meteorology___call__(Meteorology self, Time t) -> Weather"},
- { (char *)"Meteorology_get_weather", (PyCFunction) _wrap_Meteorology_get_weather, METH_VARARGS | METH_KEYWORDS, (char *)"Meteorology_get_weather(Meteorology self, Time t) -> Weather"},
- { (char *)"Meteorology_copy", (PyCFunction)_wrap_Meteorology_copy, METH_O, (char *)"Meteorology_copy(Meteorology self) -> Meteorology"},
- { (char *)"Meteorology_get_instrument_height", (PyCFunction)_wrap_Meteorology_get_instrument_height, METH_O, (char *)"Meteorology_get_instrument_height(Meteorology self) -> real"},
- { (char *)"delete_Meteorology", (PyCFunction)_wrap_delete_Meteorology, METH_O, (char *)"delete_Meteorology(Meteorology self)"},
+ { (char *)"Meteorology_get_weather", (PyCFunction) _wrap_Meteorology_get_weather, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Meteorology_get_weather(Meteorology self, Time t) -> Weather\n"
+ "\n"
+ "virtual cmf::atmosphere::Weather get_weather(cmf::math::Time t) const\n"
+ "=0\n"
+ "\n"
+ "Returns the Weather at time t. Pure virtual function. Must get\n"
+ "implemented by child functions. \n"
+ ""},
+ { (char *)"Meteorology_copy", (PyCFunction)_wrap_Meteorology_copy, METH_O, (char *)"\n"
+ "Meteorology_copy(Meteorology self) -> Meteorology\n"
+ "\n"
+ "virtual\n"
+ "Meteorology* copy() const =0\n"
+ "\n"
+ "Returns a copy of the meteorology object. Pure virtual function, needs\n"
+ "to be implemented. \n"
+ ""},
+ { (char *)"Meteorology_get_instrument_height", (PyCFunction)_wrap_Meteorology_get_instrument_height, METH_O, (char *)"\n"
+ "Meteorology_get_instrument_height(Meteorology self) -> real\n"
+ "\n"
+ "virtual real\n"
+ "get_instrument_height() const =0\n"
+ "\n"
+ "Returns the height of the instruments above canopy. \n"
+ ""},
+ { (char *)"delete_Meteorology", (PyCFunction)_wrap_delete_Meteorology, METH_O, (char *)"\n"
+ "delete_Meteorology(Meteorology self)\n"
+ "\n"
+ "virtual ~Meteorology() \n"
+ ""},
{ (char *)"Meteorology_swigregister", Meteorology_swigregister, METH_VARARGS, NULL},
{ (char *)"ConstantMeteorology_weather_set", _wrap_ConstantMeteorology_weather_set, METH_VARARGS, (char *)"ConstantMeteorology_weather_set(ConstantMeteorology self, Weather weather)"},
{ (char *)"ConstantMeteorology_weather_get", (PyCFunction)_wrap_ConstantMeteorology_weather_get, METH_O, (char *)"ConstantMeteorology_weather_get(ConstantMeteorology self) -> Weather"},
@@ -75431,8 +77561,19 @@ static PyMethodDef SwigMethods[] = {
"ConstantMeteorology()\n"
"ConstantMeteorology(Weather w)\n"
"new_ConstantMeteorology(ConstantMeteorology other) -> ConstantMeteorology\n"
+ "\n"
+ "ConstantMeteorology(const cmf::atmosphere::ConstantMeteorology &other)\n"
+ "\n"
+ "Copy constructor. \n"
+ ""},
+ { (char *)"ConstantMeteorology_copy", (PyCFunction)_wrap_ConstantMeteorology_copy, METH_O, (char *)"\n"
+ "ConstantMeteorology_copy(ConstantMeteorology self) -> ConstantMeteorology\n"
+ "\n"
+ "ConstantMeteorology* copy() const\n"
+ "\n"
+ "Creates a new instannce of the ConstantMeteorology with the same\n"
+ "weather. \n"
""},
- { (char *)"ConstantMeteorology_copy", (PyCFunction)_wrap_ConstantMeteorology_copy, METH_O, (char *)"ConstantMeteorology_copy(ConstantMeteorology self) -> ConstantMeteorology"},
{ (char *)"delete_ConstantMeteorology", (PyCFunction)_wrap_delete_ConstantMeteorology, METH_O, (char *)"delete_ConstantMeteorology(ConstantMeteorology self)"},
{ (char *)"ConstantMeteorology_swigregister", ConstantMeteorology_swigregister, METH_VARARGS, NULL},
{ (char *)"ConstantMeteorology_swiginit", ConstantMeteorology_swiginit, METH_VARARGS, NULL},
@@ -75450,15 +77591,63 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"MeteoStation_z_get", (PyCFunction)_wrap_MeteoStation_z_get, METH_O, (char *)"MeteoStation_z_get(MeteoStation self) -> double"},
{ (char *)"MeteoStation_Name_set", _wrap_MeteoStation_Name_set, METH_VARARGS, (char *)"MeteoStation_Name_set(MeteoStation self, std::string const & Name)"},
{ (char *)"MeteoStation_Name_get", (PyCFunction)_wrap_MeteoStation_Name_get, METH_O, (char *)"MeteoStation_Name_get(MeteoStation self) -> std::string const &"},
- { (char *)"MeteoStation_get_position", (PyCFunction)_wrap_MeteoStation_get_position, METH_O, (char *)"MeteoStation_get_position(MeteoStation self) -> point"},
+ { (char *)"MeteoStation_get_position", (PyCFunction)_wrap_MeteoStation_get_position, METH_O, (char *)"\n"
+ "MeteoStation_get_position(MeteoStation self) -> point\n"
+ "\n"
+ "cmf::geometry::point get_position() const \n"
+ ""},
{ (char *)"MeteoStation_daily_set", _wrap_MeteoStation_daily_set, METH_VARARGS, (char *)"MeteoStation_daily_set(MeteoStation self, bool daily)"},
{ (char *)"MeteoStation_daily_get", (PyCFunction)_wrap_MeteoStation_daily_get, METH_O, (char *)"MeteoStation_daily_get(MeteoStation self) -> bool"},
{ (char *)"MeteoStation_InstrumentHeight_set", _wrap_MeteoStation_InstrumentHeight_set, METH_VARARGS, (char *)"MeteoStation_InstrumentHeight_set(MeteoStation self, real InstrumentHeight)"},
{ (char *)"MeteoStation_InstrumentHeight_get", (PyCFunction)_wrap_MeteoStation_InstrumentHeight_get, METH_O, (char *)"MeteoStation_InstrumentHeight_get(MeteoStation self) -> real"},
- { (char *)"new_MeteoStation", (PyCFunction) _wrap_new_MeteoStation, METH_VARARGS | METH_KEYWORDS, (char *)"new_MeteoStation(MeteoStation other) -> MeteoStation"},
- { (char *)"MeteoStation_get_data", (PyCFunction) _wrap_MeteoStation_get_data, METH_VARARGS | METH_KEYWORDS, (char *)"MeteoStation_get_data(MeteoStation self, Time t, double height) -> Weather"},
- { (char *)"MeteoStation_use_for_cell", (PyCFunction) _wrap_MeteoStation_use_for_cell, METH_VARARGS | METH_KEYWORDS, (char *)"MeteoStation_use_for_cell(MeteoStation self, Cell c)"},
- { (char *)"MeteoStation_SetSunshineFraction", (PyCFunction) _wrap_MeteoStation_SetSunshineFraction, METH_VARARGS | METH_KEYWORDS, (char *)"MeteoStation_SetSunshineFraction(MeteoStation self, timeseries sunshine_duration)"},
+ { (char *)"new_MeteoStation", (PyCFunction) _wrap_new_MeteoStation, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_MeteoStation(MeteoStation other) -> MeteoStation\n"
+ "\n"
+ "MeteoStation(const cmf::atmosphere::MeteoStation &other)\n"
+ "\n"
+ "Copy c'tor. \n"
+ ""},
+ { (char *)"MeteoStation_get_data", (PyCFunction) _wrap_MeteoStation_get_data, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "MeteoStation_get_data(MeteoStation self, Time t, double height) -> Weather\n"
+ "\n"
+ "cmf::atmosphere::Weather get_data(cmf::math::Time t, double height)\n"
+ "const\n"
+ "\n"
+ "Returns the current Atmosphere state. Uses default values for missing\n"
+ "timeseries. \n"
+ ""},
+ { (char *)"MeteoStation_use_for_cell", (PyCFunction) _wrap_MeteoStation_use_for_cell, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "MeteoStation_use_for_cell(MeteoStation self, Cell c)\n"
+ "\n"
+ "void use_for_cell(cmf::upslope::Cell &c)\n"
+ "\n"
+ "Connects this meteostation as a meteo data provider with the cell. \n"
+ ""},
+ { (char *)"MeteoStation_SetSunshineFraction", (PyCFunction) _wrap_MeteoStation_SetSunshineFraction, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "MeteoStation_SetSunshineFraction(MeteoStation self, timeseries sunshine_duration)\n"
+ "\n"
+ "void\n"
+ "SetSunshineFraction(cmf::math::timeseries sunshine_duration)\n"
+ "\n"
+ "Calculates a timeseries of the sunshine fraction (to put into\n"
+ "Sunshine) from a timeseries of absolute sunshine duration.\n"
+ "\n"
+ "seehttp://www.fao.org/docrep/X0490E/x0490e07.htm#radiation\n"
+ "\n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " \\\\phi &=& \\\\frac{(\\\\mbox{geogr.\n"
+ " Latitude})^\\\\circ \\\\pi}{180^\\\\circ} \\\\mbox{ Latitude in }rad\n"
+ " \\\\\\\\ \\\\delta &=& 0.409 \\\\sin\\\\left(\\\\frac{2\\\\pi}{365}DOY\n"
+ " - 1.39\\\\right) \\\\mbox{ Declination, DOY is day of year}\\\\\\\\\n"
+ " \\\\omega_s &=& \\\\arccos(-\\\\tan\\\\phi\\\\tan\\\\delta) \\\\mbox{\n"
+ " Sunset angle in }rad \\\\\\\\ N &=& \\\\frac{24}{\\\\pi}\\\\omega_s\n"
+ " \\\\mbox{ potential duration of sunshine in }h \\\\\\\\ \\\\frac n N\n"
+ " &=& n\\\\mbox{ absolute sunshine duration in }h \n"
+ "\n"
+ "\n"
+ ""},
{ (char *)"MeteoStation_T_set", _wrap_MeteoStation_T_set, METH_VARARGS, (char *)"MeteoStation_T_set(MeteoStation self, timeseries T)"},
{ (char *)"MeteoStation_T_get", (PyCFunction)_wrap_MeteoStation_T_get, METH_O, (char *)"MeteoStation_T_get(MeteoStation self) -> timeseries"},
{ (char *)"MeteoStation_Tmax_set", _wrap_MeteoStation_Tmax_set, METH_VARARGS, (char *)"MeteoStation_Tmax_set(MeteoStation self, timeseries Tmax)"},
@@ -75486,51 +77675,200 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"delete_MeteoStation", (PyCFunction)_wrap_delete_MeteoStation, METH_O, (char *)"delete_MeteoStation(MeteoStation self)"},
{ (char *)"MeteoStation_swigregister", MeteoStation_swigregister, METH_VARARGS, NULL},
{ (char *)"MeteoStation_swiginit", MeteoStation_swiginit, METH_VARARGS, NULL},
- { (char *)"MeteoStationReference_get_station", (PyCFunction)_wrap_MeteoStationReference_get_station, METH_O, (char *)"MeteoStationReference_get_station(MeteoStationReference self) -> cmf::atmosphere::MeteoStation::ptr"},
- { (char *)"MeteoStationReference_get_position", (PyCFunction)_wrap_MeteoStationReference_get_position, METH_O, (char *)"MeteoStationReference_get_position(MeteoStationReference self) -> point"},
+ { (char *)"MeteoStationReference_get_station", (PyCFunction)_wrap_MeteoStationReference_get_station, METH_O, (char *)"\n"
+ "MeteoStationReference_get_station(MeteoStationReference self) -> cmf::atmosphere::MeteoStation::ptr\n"
+ "\n"
+ "MeteoStation::ptr get_station() const\n"
+ "\n"
+ "Returns the station referenced. \n"
+ ""},
+ { (char *)"MeteoStationReference_get_position", (PyCFunction)_wrap_MeteoStationReference_get_position, METH_O, (char *)"\n"
+ "MeteoStationReference_get_position(MeteoStationReference self) -> point\n"
+ "\n"
+ "cmf::geometry::point get_position() const\n"
+ "\n"
+ "Returns the position of the reference. \n"
+ ""},
{ (char *)"new_MeteoStationReference", _wrap_new_MeteoStationReference, METH_VARARGS, (char *)"\n"
"MeteoStationReference(cmf::atmosphere::MeteoStation::ptr station, point location)\n"
"new_MeteoStationReference(MeteoStationReference copy) -> MeteoStationReference\n"
+ "\n"
+ "MeteoStationReference(const MeteoStationReference ©) \n"
+ ""},
+ { (char *)"MeteoStationReference_copy", (PyCFunction)_wrap_MeteoStationReference_copy, METH_O, (char *)"\n"
+ "MeteoStationReference_copy(MeteoStationReference self) -> MeteoStationReference\n"
+ "\n"
+ "MeteoStationReference* copy() const\n"
+ "\n"
+ "Returns a copy of the meteorology object. Pure virtual function, needs\n"
+ "to be implemented. \n"
""},
- { (char *)"MeteoStationReference_copy", (PyCFunction)_wrap_MeteoStationReference_copy, METH_O, (char *)"MeteoStationReference_copy(MeteoStationReference self) -> MeteoStationReference"},
{ (char *)"delete_MeteoStationReference", (PyCFunction)_wrap_delete_MeteoStationReference, METH_O, (char *)"delete_MeteoStationReference(MeteoStationReference self)"},
{ (char *)"MeteoStationReference_swigregister", MeteoStationReference_swigregister, METH_VARARGS, NULL},
{ (char *)"MeteoStationReference_swiginit", MeteoStationReference_swiginit, METH_VARARGS, NULL},
- { (char *)"MeteoStationList___len__", (PyCFunction)_wrap_MeteoStationList___len__, METH_O, (char *)"MeteoStationList___len__(MeteoStationList self) -> size_t"},
+ { (char *)"MeteoStationList___len__", (PyCFunction)_wrap_MeteoStationList___len__, METH_O, (char *)"\n"
+ "MeteoStationList___len__(MeteoStationList self) -> size_t\n"
+ "\n"
+ "size_t size() const\n"
+ "\n"
+ "Returns the number of stations. \n"
+ ""},
{ (char *)"MeteoStationList___getitem__", _wrap_MeteoStationList___getitem__, METH_VARARGS, (char *)"\n"
"__getitem__(ptrdiff_t index) -> cmf::atmosphere::MeteoStation::ptr\n"
"MeteoStationList___getitem__(MeteoStationList self, std::string const & Name) -> cmf::atmosphere::MeteoStation::ptr\n"
""},
- { (char *)"MeteoStationList_calculate_Temp_lapse", (PyCFunction) _wrap_MeteoStationList_calculate_Temp_lapse, METH_VARARGS | METH_KEYWORDS, (char *)"MeteoStationList_calculate_Temp_lapse(MeteoStationList self, Time begin, Time step, Time end) -> double"},
- { (char *)"MeteoStationList_add_station", (PyCFunction) _wrap_MeteoStationList_add_station, METH_VARARGS | METH_KEYWORDS, (char *)"MeteoStationList_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"},
- { (char *)"MeteoStationList_remove_station", (PyCFunction) _wrap_MeteoStationList_remove_station, METH_VARARGS | METH_KEYWORDS, (char *)"MeteoStationList_remove_station(MeteoStationList self, ptrdiff_t index) -> ptrdiff_t"},
+ { (char *)"MeteoStationList_calculate_Temp_lapse", (PyCFunction) _wrap_MeteoStationList_calculate_Temp_lapse, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "MeteoStationList_calculate_Temp_lapse(MeteoStationList self, Time begin, Time step, Time end) -> double\n"
+ "\n"
+ "double\n"
+ "calculate_Temp_lapse(cmf::math::Time begin, cmf::math::Time step,\n"
+ "cmf::math::Time end)\n"
+ "\n"
+ "Calculates the temperature lapse from all stations in the list and\n"
+ "sets the T_lapse attribute of each station.\n"
+ "\n"
+ "Returns the average lapse over the whole period. \n"
+ ""},
+ { (char *)"MeteoStationList_add_station", (PyCFunction) _wrap_MeteoStationList_add_station, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "MeteoStationList_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\n"
+ "\n"
+ "MeteoStation::ptr add_station(std::string name, cmf::geometry::point\n"
+ "position, double latitude=51.0, double longitude=8.0, double tz=1.0,\n"
+ "cmf::math::Time startTime=cmf::math::Time(1, 1, 2001), cmf::math::Time\n"
+ "timestep=cmf::math::day)\n"
+ "\n"
+ "Creates a meteorological station at a certain position and adds it to\n"
+ "the list.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "name: Name of the station\n"
+ "\n"
+ "position: The location of the station in map coordinates\n"
+ "\n"
+ "latitude: Latitude of the study area (for solar radiation)\n"
+ "\n"
+ "longitude: Longitude of the study area (for solar time)\n"
+ "\n"
+ "tz: Time zone of the study area (e.g Germany +1,U.S. Pacific time -8\n"
+ "\n"
+ "startTime: Date of the beginning of the climatic data (may be changed\n"
+ "for each time series later)\n"
+ "\n"
+ "timestep: Frequency of climatic data (may be changed for each time\n"
+ "series later) \n"
+ ""},
+ { (char *)"MeteoStationList_remove_station", (PyCFunction) _wrap_MeteoStationList_remove_station, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "MeteoStationList_remove_station(MeteoStationList self, ptrdiff_t index) -> ptrdiff_t\n"
+ "\n"
+ "ptrdiff_t\n"
+ "remove_station(ptrdiff_t index)\n"
+ "\n"
+ "Removes a station and returns the number of remaining references to\n"
+ "the removed station. If the station is deleted, 0 is returned. \n"
+ ""},
{ (char *)"new_MeteoStationList", _wrap_new_MeteoStationList, METH_VARARGS, (char *)"\n"
"MeteoStationList()\n"
"new_MeteoStationList(MeteoStationList copy) -> MeteoStationList\n"
+ "\n"
+ "MeteoStationList(const MeteoStationList ©)\n"
+ "\n"
+ "Copy c'tor. \n"
+ ""},
+ { (char *)"MeteoStationList_reference_to_nearest", (PyCFunction) _wrap_MeteoStationList_reference_to_nearest, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "MeteoStationList_reference_to_nearest(MeteoStationList self, point position, double z_weight=0) -> MeteoStationReference\n"
+ "\n"
+ "MeteoStationReference reference_to_nearest(const cmf::geometry::point\n"
+ "&position, double z_weight=0) const\n"
+ "\n"
+ "Creates a MeteoStationReference from the nearest station to position\n"
+ "at position.\n"
+ "\n"
+ "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\n"
+ "station and :math:`l` is the locatable A Meteorology using the data of the\n"
+ "nearest station to position\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "position: The position (any locatable, like e.g. Cell possible) to\n"
+ "look for the station. The reference should be owned by the locatable\n"
+ "\n"
+ "z_weight: The weight of the height difference :math:`\\\\lambda_z` \n"
""},
- { (char *)"MeteoStationList_reference_to_nearest", (PyCFunction) _wrap_MeteoStationList_reference_to_nearest, METH_VARARGS | METH_KEYWORDS, (char *)"MeteoStationList_reference_to_nearest(MeteoStationList self, point position, double z_weight=0) -> MeteoStationReference"},
{ (char *)"delete_MeteoStationList", (PyCFunction)_wrap_delete_MeteoStationList, METH_O, (char *)"delete_MeteoStationList(MeteoStationList self)"},
{ (char *)"MeteoStationList_swigregister", MeteoStationList_swigregister, METH_VARARGS, NULL},
{ (char *)"MeteoStationList_swiginit", MeteoStationList_swiginit, METH_VARARGS, NULL},
{ (char *)"new_IDW_Meteorology", _wrap_new_IDW_Meteorology, METH_VARARGS, (char *)"\n"
"IDW_Meteorology(point position, MeteoStationList stations, double z_weight, double power)\n"
"new_IDW_Meteorology(IDW_Meteorology copy) -> IDW_Meteorology\n"
+ "\n"
+ "IDW_Meteorology(const IDW_Meteorology ©)\n"
+ "\n"
+ "Copy c'tor. \n"
+ ""},
+ { (char *)"IDW_Meteorology_copy", (PyCFunction)_wrap_IDW_Meteorology_copy, METH_O, (char *)"\n"
+ "IDW_Meteorology_copy(IDW_Meteorology self) -> IDW_Meteorology\n"
+ "\n"
+ "virtual IDW_Meteorology* copy() const\n"
+ "\n"
+ "Returns a copy of the meteorology object. Pure virtual function, needs\n"
+ "to be implemented. \n"
""},
- { (char *)"IDW_Meteorology_copy", (PyCFunction)_wrap_IDW_Meteorology_copy, METH_O, (char *)"IDW_Meteorology_copy(IDW_Meteorology self) -> IDW_Meteorology"},
{ (char *)"delete_IDW_Meteorology", (PyCFunction)_wrap_delete_IDW_Meteorology, METH_O, (char *)"delete_IDW_Meteorology(IDW_Meteorology self)"},
{ (char *)"IDW_Meteorology_swigregister", IDW_Meteorology_swigregister, METH_VARARGS, NULL},
{ (char *)"IDW_Meteorology_swiginit", IDW_Meteorology_swiginit, METH_VARARGS, NULL},
- { (char *)"aerodynamic_resistance_get_aerodynamic_resistance", (PyCFunction) _wrap_aerodynamic_resistance_get_aerodynamic_resistance, METH_VARARGS | METH_KEYWORDS, (char *)"aerodynamic_resistance_get_aerodynamic_resistance(aerodynamic_resistance self, double & r_ag, double & r_ac, Time t)"},
+ { (char *)"aerodynamic_resistance_get_aerodynamic_resistance", (PyCFunction) _wrap_aerodynamic_resistance_get_aerodynamic_resistance, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "aerodynamic_resistance_get_aerodynamic_resistance(aerodynamic_resistance self, double & r_ag, double & r_ac, Time t)\n"
+ "\n"
+ "virtual void get_aerodynamic_resistance(double &r_ag, double &r_ac,\n"
+ "cmf::math::Time t) const =0\n"
+ "\n"
+ "aerodynamic resistance from ground to atmosphere (r_ag) and from\n"
+ "canopy to atmosphere (r_ac) \n"
+ ""},
{ (char *)"delete_aerodynamic_resistance", (PyCFunction)_wrap_delete_aerodynamic_resistance, METH_O, (char *)"delete_aerodynamic_resistance(aerodynamic_resistance self)"},
{ (char *)"aerodynamic_resistance_swigregister", aerodynamic_resistance_swigregister, METH_VARARGS, NULL},
{ (char *)"RainSource___call__", (PyCFunction) _wrap_RainSource___call__, METH_VARARGS | METH_KEYWORDS, (char *)"RainSource___call__(RainSource self, Time t) -> real"},
- { (char *)"RainSource_get_intensity", (PyCFunction) _wrap_RainSource_get_intensity, METH_VARARGS | METH_KEYWORDS, (char *)"RainSource_get_intensity(RainSource self, Time t) -> real"},
+ { (char *)"RainSource_get_intensity", (PyCFunction) _wrap_RainSource_get_intensity, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "RainSource_get_intensity(RainSource self, Time t) -> real\n"
+ "\n"
+ "virtual real get_intensity(cmf::math::Time t) const =0\n"
+ "\n"
+ "Returns the actual rainfall intensity in mm/day. \n"
+ ""},
{ (char *)"delete_RainSource", (PyCFunction)_wrap_delete_RainSource, METH_O, (char *)"delete_RainSource(RainSource self)"},
{ (char *)"RainSource_swigregister", RainSource_swigregister, METH_VARARGS, NULL},
{ (char *)"ConstantRainSource_intensity_set", _wrap_ConstantRainSource_intensity_set, METH_VARARGS, (char *)"ConstantRainSource_intensity_set(ConstantRainSource self, real intensity)"},
{ (char *)"ConstantRainSource_intensity_get", (PyCFunction)_wrap_ConstantRainSource_intensity_get, METH_O, (char *)"ConstantRainSource_intensity_get(ConstantRainSource self) -> real"},
- { (char *)"new_ConstantRainSource", (PyCFunction) _wrap_new_ConstantRainSource, METH_VARARGS | METH_KEYWORDS, (char *)"new_ConstantRainSource(project _project, point location, real _intensity) -> ConstantRainSource"},
- { (char *)"ConstantRainSource_set_conc", (PyCFunction) _wrap_ConstantRainSource_set_conc, METH_VARARGS | METH_KEYWORDS, (char *)"ConstantRainSource_set_conc(ConstantRainSource self, solute Solute, real value)"},
+ { (char *)"new_ConstantRainSource", (PyCFunction) _wrap_new_ConstantRainSource, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_ConstantRainSource(project _project, point location, real _intensity) -> ConstantRainSource\n"
+ "\n"
+ "ConstantRainSource(cmf::project &_project, cmf::geometry::point\n"
+ "location, real _intensity)\n"
+ "\n"
+ "Creates a new ConstantRainSource.\n"
+ "\n"
+ "Consider using Cell::set_rainfall for internal creation of a constant\n"
+ "rain source, instead of direct use\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "_project: The project the rain source is belonging to.\n"
+ "\n"
+ "location: The location of the rain source\n"
+ "\n"
+ "_intensity: The constant rainfall intensity in mm/day \n"
+ ""},
+ { (char *)"ConstantRainSource_set_conc", (PyCFunction) _wrap_ConstantRainSource_set_conc, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "ConstantRainSource_set_conc(ConstantRainSource self, solute Solute, real value)\n"
+ "\n"
+ "void set_conc(const cmf::water::solute &Solute, real value)\n"
+ "\n"
+ "Sets the concentration of a solute in the rainfall. \n"
+ ""},
{ (char *)"delete_ConstantRainSource", (PyCFunction)_wrap_delete_ConstantRainSource, METH_O, (char *)"delete_ConstantRainSource(ConstantRainSource self)"},
{ (char *)"ConstantRainSource_swigregister", ConstantRainSource_swigregister, METH_VARARGS, NULL},
{ (char *)"ConstantRainSource_swiginit", ConstantRainSource_swiginit, METH_VARARGS, NULL},
@@ -75547,22 +77885,71 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"RainfallStation_name_get", (PyCFunction)_wrap_RainfallStation_name_get, METH_O, (char *)"RainfallStation_name_get(RainfallStation self) -> std::string const &"},
{ (char *)"RainfallStation_data_set", _wrap_RainfallStation_data_set, METH_VARARGS, (char *)"RainfallStation_data_set(RainfallStation self, timeseries data)"},
{ (char *)"RainfallStation_data_get", (PyCFunction)_wrap_RainfallStation_data_get, METH_O, (char *)"RainfallStation_data_get(RainfallStation self) -> timeseries"},
- { (char *)"RainfallStation___repr__", (PyCFunction)_wrap_RainfallStation___repr__, METH_O, (char *)"RainfallStation___repr__(RainfallStation self) -> std::string"},
+ { (char *)"RainfallStation___repr__", (PyCFunction)_wrap_RainfallStation___repr__, METH_O, (char *)"\n"
+ "RainfallStation___repr__(RainfallStation self) -> std::string\n"
+ "\n"
+ "std::string tostring() const\n"
+ "\n"
+ "Returns the name and the mean yearly rainfall. \n"
+ ""},
{ (char *)"RainfallStation_concentration_set", _wrap_RainfallStation_concentration_set, METH_VARARGS, (char *)"RainfallStation_concentration_set(RainfallStation self, SoluteTimeseries concentration)"},
{ (char *)"RainfallStation_concentration_get", (PyCFunction)_wrap_RainfallStation_concentration_get, METH_O, (char *)"RainfallStation_concentration_get(RainfallStation self) -> SoluteTimeseries"},
- { (char *)"RainfallStation_use_for_cell", (PyCFunction) _wrap_RainfallStation_use_for_cell, METH_VARARGS | METH_KEYWORDS, (char *)"RainfallStation_use_for_cell(RainfallStation self, Cell c)"},
- { (char *)"new_RainfallStation", (PyCFunction) _wrap_new_RainfallStation, METH_VARARGS | METH_KEYWORDS, (char *)"new_RainfallStation(RainfallStation copy) -> RainfallStation"},
+ { (char *)"RainfallStation_use_for_cell", (PyCFunction) _wrap_RainfallStation_use_for_cell, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "RainfallStation_use_for_cell(RainfallStation self, Cell c)\n"
+ "\n"
+ "void use_for_cell(cmf::upslope::Cell &c)\n"
+ "\n"
+ "Connects a cell with this rainfall station. \n"
+ ""},
+ { (char *)"new_RainfallStation", (PyCFunction) _wrap_new_RainfallStation, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_RainfallStation(RainfallStation copy) -> RainfallStation\n"
+ "\n"
+ "RainfallStation(const RainfallStation ©)\n"
+ "\n"
+ "copy c'tor \n"
+ ""},
{ (char *)"RainfallStation___call__", (PyCFunction) _wrap_RainfallStation___call__, METH_VARARGS | METH_KEYWORDS, (char *)"RainfallStation___call__(RainfallStation self, Time t) -> double"},
{ (char *)"delete_RainfallStation", (PyCFunction)_wrap_delete_RainfallStation, METH_O, (char *)"delete_RainfallStation(RainfallStation self)"},
{ (char *)"RainfallStation_swigregister", RainfallStation_swigregister, METH_VARARGS, NULL},
{ (char *)"RainfallStation_swiginit", RainfallStation_swiginit, METH_VARARGS, NULL},
- { (char *)"RainfallStationList___len__", (PyCFunction)_wrap_RainfallStationList___len__, METH_O, (char *)"RainfallStationList___len__(RainfallStationList self) -> size_t"},
+ { (char *)"RainfallStationList___len__", (PyCFunction)_wrap_RainfallStationList___len__, METH_O, (char *)"\n"
+ "RainfallStationList___len__(RainfallStationList self) -> size_t\n"
+ "\n"
+ "size_t size() const\n"
+ "\n"
+ "Returns the number of rainfall stations. \n"
+ ""},
{ (char *)"RainfallStationList___getitem__", _wrap_RainfallStationList___getitem__, METH_VARARGS, (char *)"\n"
"__getitem__(ptrdiff_t index) -> cmf::atmosphere::RainfallStation::ptr\n"
"RainfallStationList___getitem__(RainfallStationList self, ptrdiff_t index) -> cmf::atmosphere::RainfallStation::ptr const\n"
""},
- { (char *)"RainfallStationList_add", (PyCFunction) _wrap_RainfallStationList_add, METH_VARARGS | METH_KEYWORDS, (char *)"RainfallStationList_add(RainfallStationList self, std::string Name, timeseries Data, point Position) -> cmf::atmosphere::RainfallStation::ptr"},
- { (char *)"RainfallStationList_remove", (PyCFunction) _wrap_RainfallStationList_remove, METH_VARARGS | METH_KEYWORDS, (char *)"RainfallStationList_remove(RainfallStationList self, ptrdiff_t index)"},
+ { (char *)"RainfallStationList_add", (PyCFunction) _wrap_RainfallStationList_add, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "RainfallStationList_add(RainfallStationList self, std::string Name, timeseries Data, point Position) -> cmf::atmosphere::RainfallStation::ptr\n"
+ "\n"
+ "RainfallStation::ptr add(std::string Name, cmf::math::timeseries Data,\n"
+ "cmf::geometry::point Position)\n"
+ "\n"
+ "Creates a new RainfallStation and adds it to the list.\n"
+ "\n"
+ "Usage: The position of the rainfall station will be used as identifier\n"
+ "A new rainfall station\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "Name: Name of the station\n"
+ "\n"
+ "Data: Rainfall timeseries\n"
+ "\n"
+ "Position: Spatial position of the new station \n"
+ ""},
+ { (char *)"RainfallStationList_remove", (PyCFunction) _wrap_RainfallStationList_remove, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "RainfallStationList_remove(RainfallStationList self, ptrdiff_t index)\n"
+ "\n"
+ "void remove(ptrdiff_t index)\n"
+ "\n"
+ "Removes the station at index from this list. \n"
+ ""},
{ (char *)"new_RainfallStationList", (PyCFunction)_wrap_new_RainfallStationList, METH_NOARGS, (char *)"new_RainfallStationList() -> RainfallStationList"},
{ (char *)"delete_RainfallStationList", (PyCFunction)_wrap_delete_RainfallStationList, METH_O, (char *)"delete_RainfallStationList(RainfallStationList self)"},
{ (char *)"RainfallStationList_swigregister", RainfallStationList_swigregister, METH_VARARGS, NULL},
@@ -75598,19 +77985,47 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"Vegetation_CanopyPARExtinction_get", (PyCFunction)_wrap_Vegetation_CanopyPARExtinction_get, METH_O, (char *)"Vegetation_CanopyPARExtinction_get(Vegetation self) -> double"},
{ (char *)"Vegetation_LeafWidth_set", _wrap_Vegetation_LeafWidth_set, METH_VARARGS, (char *)"Vegetation_LeafWidth_set(Vegetation self, double LeafWidth)"},
{ (char *)"Vegetation_LeafWidth_get", (PyCFunction)_wrap_Vegetation_LeafWidth_get, METH_O, (char *)"Vegetation_LeafWidth_get(Vegetation self) -> double"},
- { (char *)"Vegetation_RootLength", (PyCFunction)_wrap_Vegetation_RootLength, METH_O, (char *)"Vegetation_RootLength(Vegetation self) -> double"},
+ { (char *)"Vegetation_RootLength", (PyCFunction)_wrap_Vegetation_RootLength, METH_O, (char *)"\n"
+ "Vegetation_RootLength(Vegetation self) -> double\n"
+ "\n"
+ "double RootLength()\n"
+ "const\n"
+ "\n"
+ "Returns the average root length in m/m2. \n"
+ ""},
{ (char *)"Vegetation_RootFraction", _wrap_Vegetation_RootFraction, METH_VARARGS, (char *)"\n"
"RootFraction(double upperBoundary, double lowerBoundary) -> double\n"
"Vegetation_RootFraction(Vegetation self, cmf::math::num_array const & thickness) -> cmf::math::num_array\n"
+ "\n"
+ "cmf::math::num_array RootFraction(const cmf::math::num_array\n"
+ "&thickness) const \n"
+ ""},
+ { (char *)"new_Vegetation", (PyCFunction) _wrap_new_Vegetation, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_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) -> Vegetation\n"
+ "\n"
+ "Vegetation(double\n"
+ "_LAI=2.88, double _Height=0.12, double _RootDepth=0.25, double\n"
+ "_StomatalResistance=100, double _albedo=0.23, double _CanopyClosure=1,\n"
+ "double _CanopyCapacityPerLAI=0.1, double _fraction_at_rootdepth=1.0)\n"
+ "\n"
""},
- { (char *)"new_Vegetation", (PyCFunction) _wrap_new_Vegetation, METH_VARARGS | METH_KEYWORDS, (char *)"new_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) -> Vegetation"},
{ (char *)"Vegetation___repr__", (PyCFunction)_wrap_Vegetation___repr__, METH_O, (char *)"Vegetation___repr__(Vegetation self) -> std::string"},
{ (char *)"delete_Vegetation", (PyCFunction)_wrap_delete_Vegetation, METH_O, (char *)"delete_Vegetation(Vegetation self)"},
{ (char *)"Vegetation_swigregister", Vegetation_swigregister, METH_VARARGS, NULL},
{ (char *)"Vegetation_swiginit", Vegetation_swiginit, METH_VARARGS, NULL},
- { (char *)"new_CellConnector", (PyCFunction) _wrap_new_CellConnector, METH_VARARGS | METH_KEYWORDS, (char *)"new_CellConnector(cmf::upslope::connectorfunction connector) -> CellConnector"},
+ { (char *)"new_CellConnector", (PyCFunction) _wrap_new_CellConnector, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_CellConnector(cmf::upslope::connectorfunction connector) -> CellConnector\n"
+ "\n"
+ "CellConnector(connectorfunction connector) \n"
+ ""},
{ (char *)"CellConnector___call__", (PyCFunction) _wrap_CellConnector___call__, METH_VARARGS | METH_KEYWORDS, (char *)"CellConnector___call__(CellConnector self, Cell cell1, Cell cell2, ptrdiff_t start_at_layer=0)"},
- { (char *)"CellConnector_connect", (PyCFunction) _wrap_CellConnector_connect, METH_VARARGS | METH_KEYWORDS, (char *)"CellConnector_connect(CellConnector self, Cell cell1, Cell cell2, ptrdiff_t start_at_layer=0)"},
+ { (char *)"CellConnector_connect", (PyCFunction) _wrap_CellConnector_connect, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "CellConnector_connect(CellConnector self, Cell cell1, Cell cell2, ptrdiff_t start_at_layer=0)\n"
+ "\n"
+ "void\n"
+ "connect(cmf::upslope::Cell &cell1, cmf::upslope::Cell &cell2,\n"
+ "ptrdiff_t start_at_layer=0) const \n"
+ ""},
{ (char *)"delete_CellConnector", (PyCFunction)_wrap_delete_CellConnector, METH_O, (char *)"delete_CellConnector(CellConnector self)"},
{ (char *)"CellConnector_swigregister", CellConnector_swigregister, METH_VARARGS, NULL},
{ (char *)"CellConnector_swiginit", CellConnector_swiginit, METH_VARARGS, NULL},
@@ -75620,55 +78035,296 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"Cell_y_get", (PyCFunction)_wrap_Cell_y_get, METH_O, (char *)"Cell_y_get(Cell self) -> double"},
{ (char *)"Cell_z_set", _wrap_Cell_z_set, METH_VARARGS, (char *)"Cell_z_set(Cell self, double z)"},
{ (char *)"Cell_z_get", (PyCFunction)_wrap_Cell_z_get, METH_O, (char *)"Cell_z_get(Cell self) -> double"},
- { (char *)"Cell_get_position", (PyCFunction)_wrap_Cell_get_position, METH_O, (char *)"Cell_get_position(Cell self) -> point"},
- { (char *)"Cell_m3_to_mm", (PyCFunction) _wrap_Cell_m3_to_mm, METH_VARARGS | METH_KEYWORDS, (char *)"Cell_m3_to_mm(Cell self, double volume) -> double"},
- { (char *)"Cell_mm_to_m3", (PyCFunction) _wrap_Cell_mm_to_m3, METH_VARARGS | METH_KEYWORDS, (char *)"Cell_mm_to_m3(Cell self, double depth) -> double"},
- { (char *)"Cell_InvalidateSatDepth", (PyCFunction)_wrap_Cell_InvalidateSatDepth, METH_O, (char *)"Cell_InvalidateSatDepth(Cell self)"},
+ { (char *)"Cell_get_position", (PyCFunction)_wrap_Cell_get_position, METH_O, (char *)"\n"
+ "Cell_get_position(Cell self) -> point\n"
+ "\n"
+ "cmf::geometry::point get_position() const\n"
+ "\n"
+ "Returns the location of the cell. \n"
+ ""},
+ { (char *)"Cell_m3_to_mm", (PyCFunction) _wrap_Cell_m3_to_mm, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Cell_m3_to_mm(Cell self, double volume) -> double\n"
+ "\n"
+ "double\n"
+ "m3_to_mm(double volume) const\n"
+ "\n"
+ "Converts a volume in m3 in mm for the cell area. \n"
+ ""},
+ { (char *)"Cell_mm_to_m3", (PyCFunction) _wrap_Cell_mm_to_m3, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Cell_mm_to_m3(Cell self, double depth) -> double\n"
+ "\n"
+ "double\n"
+ "mm_to_m3(double depth) const \n"
+ ""},
+ { (char *)"Cell_InvalidateSatDepth", (PyCFunction)_wrap_Cell_InvalidateSatDepth, METH_O, (char *)"\n"
+ "Cell_InvalidateSatDepth(Cell self)\n"
+ "\n"
+ "void\n"
+ "InvalidateSatDepth() const\n"
+ "\n"
+ "Marks the saturated depth as unvalid. This is done automatically, when\n"
+ "the state of a layer changes. \n"
+ ""},
{ (char *)"Cell_vegetation_set", _wrap_Cell_vegetation_set, METH_VARARGS, (char *)"Cell_vegetation_set(Cell self, Vegetation vegetation)"},
{ (char *)"Cell_vegetation_get", (PyCFunction)_wrap_Cell_vegetation_get, METH_O, (char *)"Cell_vegetation_get(Cell self) -> Vegetation"},
- { (char *)"Cell_set_aerodynamic_resistance", (PyCFunction) _wrap_Cell_set_aerodynamic_resistance, METH_VARARGS | METH_KEYWORDS, (char *)"Cell_set_aerodynamic_resistance(Cell self, cmf::atmosphere::aerodynamic_resistance::ptr Ra)"},
- { (char *)"Cell_set_weather", (PyCFunction) _wrap_Cell_set_weather, METH_VARARGS | METH_KEYWORDS, (char *)"Cell_set_weather(Cell self, Weather weather)"},
- { (char *)"Cell_set_rainfall", (PyCFunction) _wrap_Cell_set_rainfall, METH_VARARGS | METH_KEYWORDS, (char *)"Cell_set_rainfall(Cell self, double rainfall)"},
- { (char *)"Cell_get_rainfall", (PyCFunction) _wrap_Cell_get_rainfall, METH_VARARGS | METH_KEYWORDS, (char *)"Cell_get_rainfall(Cell self, Time t) -> double"},
- { (char *)"Cell___set_rain_source", (PyCFunction) _wrap_Cell___set_rain_source, METH_VARARGS | METH_KEYWORDS, (char *)"Cell___set_rain_source(Cell self, cmf::atmosphere::RainSource::ptr new_source)"},
- { (char *)"Cell___get_rain_source", (PyCFunction)_wrap_Cell___get_rain_source, METH_O, (char *)"Cell___get_rain_source(Cell self) -> cmf::atmosphere::RainSource::ptr"},
- { (char *)"Cell_set_uptakestress", (PyCFunction) _wrap_Cell_set_uptakestress, METH_VARARGS | METH_KEYWORDS, (char *)"Cell_set_uptakestress(Cell self, RootUptakeStessFunction stressfunction)"},
- { (char *)"Cell___get_evaporation", (PyCFunction)_wrap_Cell___get_evaporation, METH_O, (char *)"Cell___get_evaporation(Cell self) -> cmf::water::flux_node::ptr"},
- { (char *)"Cell___get_transpiration", (PyCFunction)_wrap_Cell___get_transpiration, METH_O, (char *)"Cell___get_transpiration(Cell self) -> cmf::water::flux_node::ptr"},
- { (char *)"Cell_get_surfacewater", (PyCFunction)_wrap_Cell_get_surfacewater, METH_O, (char *)"Cell_get_surfacewater(Cell self) -> cmf::water::flux_node::ptr"},
- { (char *)"Cell_surfacewater_as_storage", (PyCFunction)_wrap_Cell_surfacewater_as_storage, METH_O, (char *)"Cell_surfacewater_as_storage(Cell self)"},
+ { (char *)"Cell_set_aerodynamic_resistance", (PyCFunction) _wrap_Cell_set_aerodynamic_resistance, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Cell_set_aerodynamic_resistance(Cell self, cmf::atmosphere::aerodynamic_resistance::ptr Ra)\n"
+ "\n"
+ "void\n"
+ "set_aerodynamic_resistance(cmf::atmosphere::aerodynamic_resistance::ptr\n"
+ "Ra)\n"
+ "\n"
+ "Sets the method to calculate aerodynamic resistance against turbulent\n"
+ "sensible heat fluxes. \n"
+ ""},
+ { (char *)"Cell_set_weather", (PyCFunction) _wrap_Cell_set_weather, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Cell_set_weather(Cell self, Weather weather)\n"
+ "\n"
+ "void\n"
+ "set_weather(const cmf::atmosphere::Weather &weather)\n"
+ "\n"
+ "Sets the weather for this cell. Connectivity to a meteorological\n"
+ "station is lost. \n"
+ ""},
+ { (char *)"Cell_set_rainfall", (PyCFunction) _wrap_Cell_set_rainfall, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Cell_set_rainfall(Cell self, double rainfall)\n"
+ "\n"
+ "void\n"
+ "set_rainfall(double rainfall)\n"
+ "\n"
+ "Exchanges a timeseries of rainfall with a constant flux. \n"
+ ""},
+ { (char *)"Cell_get_rainfall", (PyCFunction) _wrap_Cell_get_rainfall, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Cell_get_rainfall(Cell self, Time t) -> double\n"
+ "\n"
+ "double\n"
+ "get_rainfall(cmf::math::Time t) const\n"
+ "\n"
+ "Returns the current rainfall flux in m3/day. \n"
+ ""},
+ { (char *)"Cell___set_rain_source", (PyCFunction) _wrap_Cell___set_rain_source, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Cell___set_rain_source(Cell self, cmf::atmosphere::RainSource::ptr new_source)\n"
+ "\n"
+ "void\n"
+ "set_rain_source(cmf::atmosphere::RainSource::ptr new_source)\n"
+ "\n"
+ "Changes the current source of rainfall. \n"
+ ""},
+ { (char *)"Cell___get_rain_source", (PyCFunction)_wrap_Cell___get_rain_source, METH_O, (char *)"\n"
+ "Cell___get_rain_source(Cell self) -> cmf::atmosphere::RainSource::ptr\n"
+ "\n"
+ "cmf::atmosphere::RainSource::ptr get_rain_source()\n"
+ "\n"
+ "Returns the current source for rainfall. \n"
+ ""},
+ { (char *)"Cell_set_uptakestress", (PyCFunction) _wrap_Cell_set_uptakestress, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Cell_set_uptakestress(Cell self, RootUptakeStessFunction stressfunction)\n"
+ "\n"
+ "void\n"
+ "set_uptakestress(const ET::RootUptakeStessFunction &stressfunction)\n"
+ "\n"
+ "Uses the given WaterStressFunction for all stressedET like connections\n"
+ "to the transpiration target. \n"
+ ""},
+ { (char *)"Cell___get_evaporation", (PyCFunction)_wrap_Cell___get_evaporation, METH_O, (char *)"\n"
+ "Cell___get_evaporation(Cell self) -> cmf::water::flux_node::ptr\n"
+ "\n"
+ "cmf::water::flux_node::ptr get_evaporation()\n"
+ "\n"
+ "Returns the end point of all evaporation of this cell (a\n"
+ "cmf::water::flux_node) \n"
+ ""},
+ { (char *)"Cell___get_transpiration", (PyCFunction)_wrap_Cell___get_transpiration, METH_O, (char *)"\n"
+ "Cell___get_transpiration(Cell self) -> cmf::water::flux_node::ptr\n"
+ "\n"
+ "cmf::water::flux_node::ptr get_transpiration()\n"
+ "\n"
+ "Returns the end point of all transpiration of this cell (a\n"
+ "cmf::water::flux_node) \n"
+ ""},
+ { (char *)"Cell_get_surfacewater", (PyCFunction)_wrap_Cell_get_surfacewater, METH_O, (char *)"\n"
+ "Cell_get_surfacewater(Cell self) -> cmf::water::flux_node::ptr\n"
+ "\n"
+ "cmf::water::flux_node::ptr get_surfacewater()\n"
+ "\n"
+ "returns the surface water of this cell. This is either a flux node or\n"
+ "a cmf::upslope::SurfaceWater \n"
+ ""},
+ { (char *)"Cell_surfacewater_as_storage", (PyCFunction)_wrap_Cell_surfacewater_as_storage, METH_O, (char *)"\n"
+ "Cell_surfacewater_as_storage(Cell self)\n"
+ "\n"
+ "void surfacewater_as_storage()\n"
+ "\n"
+ "Makes the surfacewater of this cell a cmf::upslope::SurfaceWater\n"
+ "storage. \n"
+ ""},
{ (char *)"Cell_add_storage", _wrap_Cell_add_storage, METH_VARARGS, (char *)"\n"
"add_storage(std::string Name, char storage_role, bool isopenwater=False) -> cmf::water::WaterStorage::ptr\n"
"Cell_add_storage(Cell self, cmf::water::WaterStorage::ptr storage) -> ptrdiff_t\n"
+ "\n"
+ "ptrdiff_t\n"
+ "add_storage(cmf::water::WaterStorage::ptr storage)\n"
+ "\n"
+ "Bounds an existing storage to the cell. \n"
+ ""},
+ { (char *)"Cell_remove_storage", (PyCFunction) _wrap_Cell_remove_storage, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Cell_remove_storage(Cell self, cmf::water::WaterStorage::ptr storage)\n"
+ "\n"
+ "void\n"
+ "remove_storage(cmf::water::WaterStorage::ptr storage) \n"
+ ""},
+ { (char *)"Cell_storage_count", (PyCFunction)_wrap_Cell_storage_count, METH_O, (char *)"\n"
+ "Cell_storage_count(Cell self) -> size_t\n"
+ "\n"
+ "size_t\n"
+ "storage_count() const \n"
+ ""},
+ { (char *)"Cell_get_storage", (PyCFunction) _wrap_Cell_get_storage, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Cell_get_storage(Cell self, ptrdiff_t index) -> cmf::water::WaterStorage::ptr\n"
+ "\n"
+ "cmf::water::WaterStorage::ptr get_storage(ptrdiff_t index) const \n"
+ ""},
+ { (char *)"Cell_get_canopy", (PyCFunction)_wrap_Cell_get_canopy, METH_O, (char *)"\n"
+ "Cell_get_canopy(Cell self) -> cmf::water::WaterStorage::ptr\n"
+ "\n"
+ "cmf::water::WaterStorage::ptr get_canopy() const \n"
+ ""},
+ { (char *)"Cell_get_snow", (PyCFunction)_wrap_Cell_get_snow, METH_O, (char *)"\n"
+ "Cell_get_snow(Cell self) -> cmf::water::WaterStorage::ptr\n"
+ "\n"
+ "cmf::water::WaterStorage::ptr get_snow() const \n"
+ ""},
+ { (char *)"Cell_snow_coverage", (PyCFunction)_wrap_Cell_snow_coverage, METH_O, (char *)"\n"
+ "Cell_snow_coverage(Cell self) -> real\n"
+ "\n"
+ "real\n"
+ "snow_coverage() const \n"
+ ""},
+ { (char *)"Cell_albedo", (PyCFunction)_wrap_Cell_albedo, METH_O, (char *)"\n"
+ "Cell_albedo(Cell self) -> real\n"
+ "\n"
+ "real albedo()\n"
+ "const \n"
""},
- { (char *)"Cell_remove_storage", (PyCFunction) _wrap_Cell_remove_storage, METH_VARARGS | METH_KEYWORDS, (char *)"Cell_remove_storage(Cell self, cmf::water::WaterStorage::ptr storage)"},
- { (char *)"Cell_storage_count", (PyCFunction)_wrap_Cell_storage_count, METH_O, (char *)"Cell_storage_count(Cell self) -> size_t"},
- { (char *)"Cell_get_storage", (PyCFunction) _wrap_Cell_get_storage, METH_VARARGS | METH_KEYWORDS, (char *)"Cell_get_storage(Cell self, ptrdiff_t index) -> cmf::water::WaterStorage::ptr"},
- { (char *)"Cell_get_canopy", (PyCFunction)_wrap_Cell_get_canopy, METH_O, (char *)"Cell_get_canopy(Cell self) -> cmf::water::WaterStorage::ptr"},
- { (char *)"Cell_get_snow", (PyCFunction)_wrap_Cell_get_snow, METH_O, (char *)"Cell_get_snow(Cell self) -> cmf::water::WaterStorage::ptr"},
- { (char *)"Cell_snow_coverage", (PyCFunction)_wrap_Cell_snow_coverage, METH_O, (char *)"Cell_snow_coverage(Cell self) -> real"},
- { (char *)"Cell_albedo", (PyCFunction)_wrap_Cell_albedo, METH_O, (char *)"Cell_albedo(Cell self) -> real"},
{ (char *)"Cell_surface_amplitude_set", _wrap_Cell_surface_amplitude_set, METH_VARARGS, (char *)"Cell_surface_amplitude_set(Cell self, real surface_amplitude)"},
{ (char *)"Cell_surface_amplitude_get", (PyCFunction)_wrap_Cell_surface_amplitude_get, METH_O, (char *)"Cell_surface_amplitude_get(Cell self) -> real"},
- { (char *)"Cell_surface_water_coverage", (PyCFunction)_wrap_Cell_surface_water_coverage, METH_O, (char *)"Cell_surface_water_coverage(Cell self) -> real"},
- { (char *)"Cell_heat_flux", (PyCFunction) _wrap_Cell_heat_flux, METH_VARARGS | METH_KEYWORDS, (char *)"Cell_heat_flux(Cell self, Time t) -> real"},
+ { (char *)"Cell_surface_water_coverage", (PyCFunction)_wrap_Cell_surface_water_coverage, METH_O, (char *)"\n"
+ "Cell_surface_water_coverage(Cell self) -> real\n"
+ "\n"
+ "real surface_water_coverage() const\n"
+ "\n"
+ "Returns the coverage of the surface water.\n"
+ "\n"
+ "The covered fraction (0..1) is simply modelled as a piecewise linear\n"
+ "function of the surface water depth. If the depth is above the\n"
+ "aggregate height, the coverage is 1, below it is given as \n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " c =\n"
+ " \\\\frac{h_{water}}{\\\\Delta h_{surface}}\n"
+ "\n"
+ "with c the coverage,\n"
+ ":math:`h_{water}` the depth of the surface water and :math:`\\\\Delta h_{surface}`\n"
+ "the amplitude of the surface roughness \n"
+ ""},
+ { (char *)"Cell_heat_flux", (PyCFunction) _wrap_Cell_heat_flux, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Cell_heat_flux(Cell self, Time t) -> real\n"
+ "\n"
+ "real\n"
+ "heat_flux(cmf::math::Time t) const\n"
+ "\n"
+ "Calculates the surface heat balance.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "t: Time step \n"
+ ""},
{ (char *)"Cell_Tground_set", _wrap_Cell_Tground_set, METH_VARARGS, (char *)"Cell_Tground_set(Cell self, real Tground)"},
{ (char *)"Cell_Tground_get", (PyCFunction)_wrap_Cell_Tground_get, METH_O, (char *)"Cell_Tground_get(Cell self) -> real"},
- { (char *)"Cell_leave_wetness", (PyCFunction)_wrap_Cell_leave_wetness, METH_O, (char *)"Cell_leave_wetness(Cell self) -> real"},
+ { (char *)"Cell_leave_wetness", (PyCFunction)_wrap_Cell_leave_wetness, METH_O, (char *)"\n"
+ "Cell_leave_wetness(Cell self) -> real\n"
+ "\n"
+ "real\n"
+ "leave_wetness() const\n"
+ "\n"
+ "Return the fraction of wet leaves in the canopy if a canopy water\n"
+ "storage exists.\n"
+ "\n"
+ "If no canopy storage is present, it returns 0.0 (=empty). The fraction\n"
+ "of wet leaves are calculated as the linear filling of the canopy\n"
+ "storage. \n"
+ ""},
{ (char *)"Cell_Id_set", _wrap_Cell_Id_set, METH_VARARGS, (char *)"Cell_Id_set(Cell self, ptrdiff_t Id)"},
{ (char *)"Cell_Id_get", (PyCFunction)_wrap_Cell_Id_get, METH_O, (char *)"Cell_Id_get(Cell self) -> ptrdiff_t"},
- { (char *)"Cell_get_weather", (PyCFunction) _wrap_Cell_get_weather, METH_VARARGS | METH_KEYWORDS, (char *)"Cell_get_weather(Cell self, Time t) -> Weather"},
- { (char *)"Cell_layer_count", (PyCFunction)_wrap_Cell_layer_count, METH_O, (char *)"Cell_layer_count(Cell self) -> size_t"},
- { (char *)"Cell_get_layer", (PyCFunction) _wrap_Cell_get_layer, METH_VARARGS | METH_KEYWORDS, (char *)"Cell_get_layer(Cell self, ptrdiff_t ndx) -> cmf::upslope::SoilLayer::ptr"},
+ { (char *)"Cell_get_weather", (PyCFunction) _wrap_Cell_get_weather, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Cell_get_weather(Cell self, Time t) -> Weather\n"
+ "\n"
+ "cmf::atmosphere::Weather get_weather(cmf::math::Time t) const\n"
+ "\n"
+ "Returns the current meteorological conditions of the cell at time t.\n"
+ "\n"
+ ""},
+ { (char *)"Cell_layer_count", (PyCFunction)_wrap_Cell_layer_count, METH_O, (char *)"\n"
+ "Cell_layer_count(Cell self) -> size_t\n"
+ "\n"
+ "size_t\n"
+ "layer_count() const\n"
+ "\n"
+ "Returns the number of layers of the cell. \n"
+ ""},
+ { (char *)"Cell_get_layer", (PyCFunction) _wrap_Cell_get_layer, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Cell_get_layer(Cell self, ptrdiff_t ndx) -> cmf::upslope::SoilLayer::ptr\n"
+ "\n"
+ "cmf::upslope::SoilLayer::ptr get_layer(ptrdiff_t ndx) const\n"
+ "\n"
+ "Returns the layer at position ndx.\n"
+ "\n"
+ "From python this function is masked as a sequence: \n"
+ ""},
{ (char *)"Cell_add_layer", _wrap_Cell_add_layer, METH_VARARGS, (char *)"\n"
"add_layer(real lowerboundary, RetentionCurve r_curve, real saturateddepth=10) -> cmf::upslope::SoilLayer::ptr\n"
"Cell_add_layer(Cell self, real lowerboundary) -> cmf::upslope::SoilLayer::ptr\n"
+ "\n"
+ "cmf::upslope::SoilLayer::ptr add_layer(real lowerboundary)\n"
+ "\n"
+ "Adds a rather conceptual layer to the cell. Use this version for\n"
+ "conceptual models. The retention curve resambles an empty bucket. \n"
+ ""},
+ { (char *)"Cell_remove_last_layer", (PyCFunction)_wrap_Cell_remove_last_layer, METH_O, (char *)"\n"
+ "Cell_remove_last_layer(Cell self)\n"
+ "\n"
+ "void\n"
+ "remove_last_layer()\n"
+ "\n"
+ "Remove the lowest layer from this cell. \n"
+ ""},
+ { (char *)"Cell_remove_layers", (PyCFunction)_wrap_Cell_remove_layers, METH_O, (char *)"\n"
+ "Cell_remove_layers(Cell self)\n"
+ "\n"
+ "void\n"
+ "remove_layers()\n"
+ "\n"
+ "Removes all layers from this cell. \n"
+ ""},
+ { (char *)"delete_Cell", (PyCFunction)_wrap_delete_Cell, METH_O, (char *)"\n"
+ "delete_Cell(Cell self)\n"
+ "\n"
+ "virtual ~Cell() \n"
+ ""},
+ { (char *)"new_Cell", (PyCFunction) _wrap_new_Cell, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_Cell(double x, double y, double z, double area, project _project) -> Cell\n"
+ "\n"
+ "Cell(double x,\n"
+ "double y, double z, double area, cmf::project &_project) \n"
+ ""},
+ { (char *)"Cell_to_string", (PyCFunction)_wrap_Cell_to_string, METH_O, (char *)"\n"
+ "Cell_to_string(Cell self) -> std::string\n"
+ "\n"
+ "std::string\n"
+ "to_string() const \n"
""},
- { (char *)"Cell_remove_last_layer", (PyCFunction)_wrap_Cell_remove_last_layer, METH_O, (char *)"Cell_remove_last_layer(Cell self)"},
- { (char *)"Cell_remove_layers", (PyCFunction)_wrap_Cell_remove_layers, METH_O, (char *)"Cell_remove_layers(Cell self)"},
- { (char *)"delete_Cell", (PyCFunction)_wrap_delete_Cell, METH_O, (char *)"delete_Cell(Cell self)"},
- { (char *)"new_Cell", (PyCFunction) _wrap_new_Cell, METH_VARARGS | METH_KEYWORDS, (char *)"new_Cell(double x, double y, double z, double area, project _project) -> Cell"},
- { (char *)"Cell_to_string", (PyCFunction)_wrap_Cell_to_string, METH_O, (char *)"Cell_to_string(Cell self) -> std::string"},
{ (char *)"Cell_topology_get", (PyCFunction)_wrap_Cell_topology_get, METH_O, (char *)"Cell_topology_get(Cell self) -> Topology"},
{ (char *)"Cell_meteorology_set", _wrap_Cell_meteorology_set, METH_VARARGS, (char *)"Cell_meteorology_set(Cell self, Meteorology meteorology)"},
{ (char *)"Cell_meteorology_get", (PyCFunction)_wrap_Cell_meteorology_get, METH_O, (char *)"Cell_meteorology_get(Cell self) -> Meteorology"},
@@ -75687,28 +78343,91 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"Topology_y_get", (PyCFunction)_wrap_Topology_y_get, METH_O, (char *)"Topology_y_get(Topology self) -> double &"},
{ (char *)"Topology_z_set", _wrap_Topology_z_set, METH_VARARGS, (char *)"Topology_z_set(Topology self, double & z)"},
{ (char *)"Topology_z_get", (PyCFunction)_wrap_Topology_z_get, METH_O, (char *)"Topology_z_get(Topology self) -> double &"},
- { (char *)"Topology_get_position", (PyCFunction)_wrap_Topology_get_position, METH_O, (char *)"Topology_get_position(Topology self) -> point"},
+ { (char *)"Topology_get_position", (PyCFunction)_wrap_Topology_get_position, METH_O, (char *)"\n"
+ "Topology_get_position(Topology self) -> point\n"
+ "\n"
+ "cmf::geometry::point get_position() const\n"
+ "\n"
+ "Returns the center of the cell. \n"
+ ""},
{ (char *)"Topology_flowwidth", _wrap_Topology_flowwidth, METH_VARARGS, (char *)"\n"
"flowwidth(Cell target) -> double\n"
"Topology_flowwidth(Topology self, Topology target) -> double\n"
+ "\n"
+ "double\n"
+ "flowwidth(Topology &target) \n"
""},
{ (char *)"Topology_AddNeighbor", _wrap_Topology_AddNeighbor, METH_VARARGS, (char *)"\n"
"AddNeighbor(Cell target, double flowwidth)\n"
"Topology_AddNeighbor(Topology self, Topology target, double flowwidth)\n"
+ "\n"
+ "void\n"
+ "AddNeighbor(Topology &target, double flowwidth) \n"
+ ""},
+ { (char *)"Topology_RemoveNeighbor", (PyCFunction) _wrap_Topology_RemoveNeighbor, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Topology_RemoveNeighbor(Topology self, Topology target)\n"
+ "\n"
+ "void\n"
+ "RemoveNeighbor(Topology &target)\n"
+ "\n"
+ "Removes the topological relation to the given cell. \n"
+ ""},
+ { (char *)"Topology_neighbor_count", (PyCFunction)_wrap_Topology_neighbor_count, METH_O, (char *)"\n"
+ "Topology_neighbor_count(Topology self) -> size_t\n"
+ "\n"
+ "size_t\n"
+ "neighbor_count() const\n"
+ "\n"
+ "Returns the number of neighbors. \n"
+ ""},
+ { (char *)"Topology_MainOutlet", (PyCFunction) _wrap_Topology_MainOutlet, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Topology_MainOutlet(Topology self, bool forceRecalc=False) -> Cell\n"
+ "\n"
+ "Cell*\n"
+ "MainOutlet(bool forceRecalc=false)\n"
+ "\n"
+ "Returns the mainoutlet (steepest lower neighbor) \n"
+ ""},
+ { (char *)"Topology_ContributingArea", (PyCFunction)_wrap_Topology_ContributingArea, METH_O, (char *)"\n"
+ "Topology_ContributingArea(Topology self) -> double\n"
+ "\n"
+ "double ContributingArea() const\n"
+ "\n"
+ "Get the contributing area (steepest path upwards) \n"
""},
- { (char *)"Topology_RemoveNeighbor", (PyCFunction) _wrap_Topology_RemoveNeighbor, METH_VARARGS | METH_KEYWORDS, (char *)"Topology_RemoveNeighbor(Topology self, Topology target)"},
- { (char *)"Topology_neighbor_count", (PyCFunction)_wrap_Topology_neighbor_count, METH_O, (char *)"Topology_neighbor_count(Topology self) -> size_t"},
- { (char *)"Topology_MainOutlet", (PyCFunction) _wrap_Topology_MainOutlet, METH_VARARGS | METH_KEYWORDS, (char *)"Topology_MainOutlet(Topology self, bool forceRecalc=False) -> Cell"},
- { (char *)"Topology_ContributingArea", (PyCFunction)_wrap_Topology_ContributingArea, METH_O, (char *)"Topology_ContributingArea(Topology self) -> double"},
{ (char *)"Topology_calculate_contributing_area", (PyCFunction) _wrap_Topology_calculate_contributing_area, METH_VARARGS | METH_KEYWORDS, (char *)"Topology_calculate_contributing_area(cell_vector arg2)"},
{ (char *)"Topology___eq__", (PyCFunction) _wrap_Topology___eq__, METH_VARARGS | METH_KEYWORDS, (char *)"Topology___eq__(Topology self, Topology cmp) -> bool"},
{ (char *)"delete_Topology", (PyCFunction)_wrap_delete_Topology, METH_O, (char *)"delete_Topology(Topology self)"},
{ (char *)"Topology_swigregister", Topology_swigregister, METH_VARARGS, NULL},
- { (char *)"new_neighbor_iterator", (PyCFunction) _wrap_new_neighbor_iterator, METH_VARARGS | METH_KEYWORDS, (char *)"new_neighbor_iterator(Cell cell) -> neighbor_iterator"},
- { (char *)"neighbor_iterator_cell", (PyCFunction)_wrap_neighbor_iterator_cell, METH_O, (char *)"neighbor_iterator_cell(neighbor_iterator self) -> Cell"},
- { (char *)"neighbor_iterator_flowwidth", (PyCFunction)_wrap_neighbor_iterator_flowwidth, METH_O, (char *)"neighbor_iterator_flowwidth(neighbor_iterator self) -> double"},
- { (char *)"neighbor_iterator_valid", (PyCFunction)_wrap_neighbor_iterator_valid, METH_O, (char *)"neighbor_iterator_valid(neighbor_iterator self) -> bool"},
- { (char *)"neighbor_iterator_next", (PyCFunction)_wrap_neighbor_iterator_next, METH_O, (char *)"neighbor_iterator_next(neighbor_iterator self) -> neighbor_iterator"},
+ { (char *)"new_neighbor_iterator", (PyCFunction) _wrap_new_neighbor_iterator, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_neighbor_iterator(Cell cell) -> neighbor_iterator\n"
+ "\n"
+ "neighbor_iterator(cmf::upslope::Cell *cell) \n"
+ ""},
+ { (char *)"neighbor_iterator_cell", (PyCFunction)_wrap_neighbor_iterator_cell, METH_O, (char *)"\n"
+ "neighbor_iterator_cell(neighbor_iterator self) -> Cell\n"
+ "\n"
+ "Cell&\n"
+ "cell() \n"
+ ""},
+ { (char *)"neighbor_iterator_flowwidth", (PyCFunction)_wrap_neighbor_iterator_flowwidth, METH_O, (char *)"\n"
+ "neighbor_iterator_flowwidth(neighbor_iterator self) -> double\n"
+ "\n"
+ "double flowwidth() \n"
+ ""},
+ { (char *)"neighbor_iterator_valid", (PyCFunction)_wrap_neighbor_iterator_valid, METH_O, (char *)"\n"
+ "neighbor_iterator_valid(neighbor_iterator self) -> bool\n"
+ "\n"
+ "bool\n"
+ "valid() const \n"
+ ""},
+ { (char *)"neighbor_iterator_next", (PyCFunction)_wrap_neighbor_iterator_next, METH_O, (char *)"\n"
+ "neighbor_iterator_next(neighbor_iterator self) -> neighbor_iterator\n"
+ "\n"
+ "neighbor_iterator& next()\n"
+ "\n"
+ "Points the iterator to the next neighbor. \n"
+ ""},
{ (char *)"neighbor_iterator___eq__", (PyCFunction) _wrap_neighbor_iterator___eq__, METH_VARARGS | METH_KEYWORDS, (char *)"neighbor_iterator___eq__(neighbor_iterator self, neighbor_iterator cmp) -> bool"},
{ (char *)"neighbor_iterator___neq__", (PyCFunction) _wrap_neighbor_iterator___neq__, METH_VARARGS | METH_KEYWORDS, (char *)"neighbor_iterator___neq__(neighbor_iterator self, neighbor_iterator cmp) -> bool"},
{ (char *)"delete_neighbor_iterator", (PyCFunction)_wrap_delete_neighbor_iterator, METH_O, (char *)"delete_neighbor_iterator(neighbor_iterator self)"},
@@ -75717,21 +78436,59 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"new_cell_vector", _wrap_new_cell_vector, METH_VARARGS, (char *)"\n"
"cell_vector()\n"
"new_cell_vector(cell_vector copy) -> cell_vector\n"
+ "\n"
+ "cell_vector(cell_const_iterator first, cell_const_iterator last) \n"
""},
{ (char *)"cell_vector___getitem__", _wrap_cell_vector___getitem__, METH_VARARGS, (char *)"\n"
"__getitem__(ptrdiff_t index) -> Cell\n"
"cell_vector___getitem__(cell_vector self, ptrdiff_t index) -> Cell\n"
""},
- { (char *)"cell_vector_append", (PyCFunction) _wrap_cell_vector_append, METH_VARARGS | METH_KEYWORDS, (char *)"cell_vector_append(cell_vector self, Cell cell)"},
+ { (char *)"cell_vector_append", (PyCFunction) _wrap_cell_vector_append, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "cell_vector_append(cell_vector self, Cell cell)\n"
+ "\n"
+ "void\n"
+ "append(cmf::upslope::Cell &cell) \n"
+ ""},
{ (char *)"cell_vector_remove", _wrap_cell_vector_remove, METH_VARARGS, (char *)"\n"
"remove(ptrdiff_t index)\n"
"cell_vector_remove(cell_vector self, Cell cell)\n"
+ "\n"
+ "void\n"
+ "remove(const cmf::upslope::Cell &cell) \n"
+ ""},
+ { (char *)"cell_vector_pop", (PyCFunction)_wrap_cell_vector_pop, METH_O, (char *)"\n"
+ "cell_vector_pop(cell_vector self) -> Cell\n"
+ "\n"
+ "Cell& pop()\n"
+ "\n"
+ "Returns and removes the last cell. \n"
+ ""},
+ { (char *)"cell_vector___len__", (PyCFunction)_wrap_cell_vector___len__, METH_O, (char *)"\n"
+ "cell_vector___len__(cell_vector self) -> size_t\n"
+ "\n"
+ "size_t size()\n"
+ "const \n"
+ ""},
+ { (char *)"cell_vector___getslice__", (PyCFunction) _wrap_cell_vector___getslice__, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "cell_vector___getslice__(cell_vector self, ptrdiff_t start, ptrdiff_t end, ptrdiff_t step=1) -> cell_vector\n"
+ "\n"
+ "cell_vector get_slice(ptrdiff_t start, ptrdiff_t end, ptrdiff_t\n"
+ "step=1) \n"
+ ""},
+ { (char *)"cell_vector_get_area", (PyCFunction)_wrap_cell_vector_get_area, METH_O, (char *)"\n"
+ "cell_vector_get_area(cell_vector self) -> double\n"
+ "\n"
+ "double\n"
+ "get_area() const\n"
+ "\n"
+ "Returns sum of the area of the cells. \n"
+ ""},
+ { (char *)"cell_vector___contains__", (PyCFunction) _wrap_cell_vector___contains__, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "cell_vector___contains__(cell_vector self, Cell cell) -> bool\n"
+ "\n"
+ "bool\n"
+ "contains(const cmf::upslope::Cell &cell) const \n"
""},
- { (char *)"cell_vector_pop", (PyCFunction)_wrap_cell_vector_pop, METH_O, (char *)"cell_vector_pop(cell_vector self) -> Cell"},
- { (char *)"cell_vector___len__", (PyCFunction)_wrap_cell_vector___len__, METH_O, (char *)"cell_vector___len__(cell_vector self) -> size_t"},
- { (char *)"cell_vector___getslice__", (PyCFunction) _wrap_cell_vector___getslice__, METH_VARARGS | METH_KEYWORDS, (char *)"cell_vector___getslice__(cell_vector self, ptrdiff_t start, ptrdiff_t end, ptrdiff_t step=1) -> cell_vector"},
- { (char *)"cell_vector_get_area", (PyCFunction)_wrap_cell_vector_get_area, METH_O, (char *)"cell_vector_get_area(cell_vector self) -> double"},
- { (char *)"cell_vector___contains__", (PyCFunction) _wrap_cell_vector___contains__, METH_VARARGS | METH_KEYWORDS, (char *)"cell_vector___contains__(cell_vector self, Cell cell) -> bool"},
{ (char *)"cell_vector_lowest_get", (PyCFunction)_wrap_cell_vector_lowest_get, METH_O, (char *)"cell_vector_lowest_get(cell_vector self) -> Cell"},
{ (char *)"cell_vector_highest_get", (PyCFunction)_wrap_cell_vector_highest_get, METH_O, (char *)"cell_vector_highest_get(cell_vector self) -> Cell"},
{ (char *)"delete_cell_vector", (PyCFunction)_wrap_delete_cell_vector, METH_O, (char *)"delete_cell_vector(cell_vector self)"},
@@ -75753,7 +78510,23 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"subcatchment_inflowcells_get", (PyCFunction)_wrap_subcatchment_inflowcells_get, METH_O, (char *)"subcatchment_inflowcells_get(subcatchment self) -> cell_vector"},
{ (char *)"subcatchment_cells_set", _wrap_subcatchment_cells_set, METH_VARARGS, (char *)"subcatchment_cells_set(subcatchment self, cell_vector cells)"},
{ (char *)"subcatchment_cells_get", (PyCFunction)_wrap_subcatchment_cells_get, METH_O, (char *)"subcatchment_cells_get(subcatchment self) -> cell_vector"},
- { (char *)"new_subcatchment", (PyCFunction) _wrap_new_subcatchment, METH_VARARGS | METH_KEYWORDS, (char *)"new_subcatchment(Cell pourpoint, double area_threshold=1e308) -> subcatchment"},
+ { (char *)"new_subcatchment", (PyCFunction) _wrap_new_subcatchment, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_subcatchment(Cell pourpoint, double area_threshold=1e308) -> subcatchment\n"
+ "\n"
+ "subcatchment(cmf::upslope::Cell &pourpoint, double\n"
+ "area_threshold=1e308)\n"
+ "\n"
+ "Creates a subcatchment from a pourpoint cell.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "pourpoint: The pourpoint (outlet of the subcatchment)\n"
+ "\n"
+ "area_threshold: Minimum contributing area size to form a\n"
+ "subcatchment. When area_threshold > area(cells), all upslope cells of\n"
+ "pourpoint are used. \n"
+ ""},
{ (char *)"delete_subcatchment", (PyCFunction)_wrap_delete_subcatchment, METH_O, (char *)"delete_subcatchment(subcatchment self)"},
{ (char *)"subcatchment_swigregister", subcatchment_swigregister, METH_VARARGS, NULL},
{ (char *)"subcatchment_swiginit", subcatchment_swiginit, METH_VARARGS, NULL},
@@ -75764,51 +78537,153 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"RetentionCurve_K", _wrap_RetentionCurve_K, METH_VARARGS, (char *)"\n"
"K(real wetness) -> real\n"
"RetentionCurve_K(RetentionCurve self, cmf::math::num_array const & wetness) -> cmf::math::num_array\n"
+ "\n"
+ "cmf::math::num_array K(const cmf::math::num_array &wetness) const \n"
+ ""},
+ { (char *)"RetentionCurve_Wetness_eff", (PyCFunction) _wrap_RetentionCurve_Wetness_eff, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "RetentionCurve_Wetness_eff(RetentionCurve self, real wetness, real pF_r=4.2) -> real\n"
+ "\n"
+ "virtual real Wetness_eff(real wetness, real pF_r=4.2) const\n"
+ "\n"
+ "Returns the effective wetness, using a residual pF value \n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " w_{eff}\n"
+ " =\n"
+ " \\\\frac{w_{act}-w\\\\left(pF_r\\\\right)}{1-w\\\\left(pF_r\\\\right)}\n"
+ "\n"
+ ".\n"
+ "\n"
+ ""},
+ { (char *)"RetentionCurve_Porosity", (PyCFunction) _wrap_RetentionCurve_Porosity, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "RetentionCurve_Porosity(RetentionCurve self, real depth=0.0) -> real\n"
+ "\n"
+ "virtual real Porosity(real depth=0.0) const =0\n"
+ "\n"
+ "Returns the porosity at a certain depth. \n"
+ ""},
+ { (char *)"RetentionCurve_VoidVolume", (PyCFunction) _wrap_RetentionCurve_VoidVolume, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "RetentionCurve_VoidVolume(RetentionCurve self, real upperDepth, real lowerDepth, real Area) -> real\n"
+ "\n"
+ "virtual real VoidVolume(real upperDepth, real lowerDepth, real Area)\n"
+ "const\n"
+ "\n"
+ "Returns the void volume of a soil column. \n"
+ ""},
+ { (char *)"RetentionCurve_FillHeight", (PyCFunction) _wrap_RetentionCurve_FillHeight, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "RetentionCurve_FillHeight(RetentionCurve self, real lowerDepth, real Area, real Volume) -> real\n"
+ "\n"
+ "virtual real FillHeight(real lowerDepth, real Area, real Volume) const\n"
+ "\n"
+ "Returns the thickness of a soil column with a certain pore volume. \n"
""},
- { (char *)"RetentionCurve_Wetness_eff", (PyCFunction) _wrap_RetentionCurve_Wetness_eff, METH_VARARGS | METH_KEYWORDS, (char *)"RetentionCurve_Wetness_eff(RetentionCurve self, real wetness, real pF_r=4.2) -> real"},
- { (char *)"RetentionCurve_Porosity", (PyCFunction) _wrap_RetentionCurve_Porosity, METH_VARARGS | METH_KEYWORDS, (char *)"RetentionCurve_Porosity(RetentionCurve self, real depth=0.0) -> real"},
- { (char *)"RetentionCurve_VoidVolume", (PyCFunction) _wrap_RetentionCurve_VoidVolume, METH_VARARGS | METH_KEYWORDS, (char *)"RetentionCurve_VoidVolume(RetentionCurve self, real upperDepth, real lowerDepth, real Area) -> real"},
- { (char *)"RetentionCurve_FillHeight", (PyCFunction) _wrap_RetentionCurve_FillHeight, METH_VARARGS | METH_KEYWORDS, (char *)"RetentionCurve_FillHeight(RetentionCurve self, real lowerDepth, real Area, real Volume) -> real"},
{ (char *)"RetentionCurve_Diffusivity", _wrap_RetentionCurve_Diffusivity, METH_VARARGS, (char *)"\n"
"Diffusivity(real wetness) -> real\n"
"RetentionCurve_Diffusivity(RetentionCurve self, cmf::math::num_array & wetness) -> cmf::math::num_array\n"
+ "\n"
+ "cmf::math::num_array Diffusivity(cmf::math::num_array &wetness) \n"
""},
{ (char *)"RetentionCurve_Wetness", _wrap_RetentionCurve_Wetness, METH_VARARGS, (char *)"\n"
"Wetness(real suction) -> real\n"
"RetentionCurve_Wetness(RetentionCurve self, cmf::math::num_array const & suction) -> cmf::math::num_array\n"
+ "\n"
+ "cmf::math::num_array Wetness(const cmf::math::num_array &suction)\n"
+ "const \n"
""},
{ (char *)"RetentionCurve_theta", _wrap_RetentionCurve_theta, METH_VARARGS, (char *)"\n"
"theta(real wetness) -> real\n"
"RetentionCurve_theta(RetentionCurve self, cmf::math::num_array const & wetness) -> cmf::math::num_array\n"
+ "\n"
+ "cmf::math::num_array theta(const cmf::math::num_array &wetness) const\n"
+ "\n"
""},
{ (char *)"RetentionCurve_dPsiM_dW", _wrap_RetentionCurve_dPsiM_dW, METH_VARARGS, (char *)"\n"
"dPsiM_dW(real wetness) -> real\n"
"RetentionCurve_dPsiM_dW(RetentionCurve self, cmf::math::num_array const & wetness) -> cmf::math::num_array\n"
+ "\n"
+ "cmf::math::num_array dPsiM_dW(const cmf::math::num_array &wetness)\n"
+ "const \n"
""},
{ (char *)"RetentionCurve_Wetness_pF", _wrap_RetentionCurve_Wetness_pF, METH_VARARGS, (char *)"\n"
"Wetness_pF(real pF) -> real\n"
"RetentionCurve_Wetness_pF(RetentionCurve self, cmf::math::num_array const & pF) -> cmf::math::num_array\n"
+ "\n"
+ "cmf::math::num_array Wetness_pF(const cmf::math::num_array &pF) const\n"
+ "\n"
""},
{ (char *)"RetentionCurve_MatricPotential", _wrap_RetentionCurve_MatricPotential, METH_VARARGS, (char *)"\n"
"MatricPotential(real wetness) -> real\n"
"RetentionCurve_MatricPotential(RetentionCurve self, cmf::math::num_array const & wetness) -> cmf::math::num_array\n"
+ "\n"
+ "cmf::math::num_array MatricPotential(const cmf::math::num_array\n"
+ "&wetness) const \n"
+ ""},
+ { (char *)"RetentionCurve_copy", (PyCFunction)_wrap_RetentionCurve_copy, METH_O, (char *)"\n"
+ "RetentionCurve_copy(RetentionCurve self) -> RetentionCurve\n"
+ "\n"
+ "virtual\n"
+ "RetentionCurve* copy() const =0 \n"
""},
- { (char *)"RetentionCurve_copy", (PyCFunction)_wrap_RetentionCurve_copy, METH_O, (char *)"RetentionCurve_copy(RetentionCurve self) -> RetentionCurve"},
{ (char *)"delete_RetentionCurve", (PyCFunction)_wrap_delete_RetentionCurve, METH_O, (char *)"delete_RetentionCurve(RetentionCurve self)"},
{ (char *)"RetentionCurve_swigregister", RetentionCurve_swigregister, METH_VARARGS, NULL},
{ (char *)"BrooksCoreyRetentionCurve_Ksat_set", _wrap_BrooksCoreyRetentionCurve_Ksat_set, METH_VARARGS, (char *)"BrooksCoreyRetentionCurve_Ksat_set(BrooksCoreyRetentionCurve self, real Ksat)"},
{ (char *)"BrooksCoreyRetentionCurve_Ksat_get", (PyCFunction)_wrap_BrooksCoreyRetentionCurve_Ksat_get, METH_O, (char *)"BrooksCoreyRetentionCurve_Ksat_get(BrooksCoreyRetentionCurve self) -> real"},
- { (char *)"BrooksCoreyRetentionCurve_SetPorosity", (PyCFunction) _wrap_BrooksCoreyRetentionCurve_SetPorosity, METH_VARARGS | METH_KEYWORDS, (char *)"BrooksCoreyRetentionCurve_SetPorosity(BrooksCoreyRetentionCurve self, real porosity, real porosity_decay=0)"},
- { (char *)"BrooksCoreyRetentionCurve_Transmissivity", (PyCFunction) _wrap_BrooksCoreyRetentionCurve_Transmissivity, METH_VARARGS | METH_KEYWORDS, (char *)"BrooksCoreyRetentionCurve_Transmissivity(BrooksCoreyRetentionCurve self, real upperDepth, real lowerDepth, real theta) -> real"},
+ { (char *)"BrooksCoreyRetentionCurve_SetPorosity", (PyCFunction) _wrap_BrooksCoreyRetentionCurve_SetPorosity, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "BrooksCoreyRetentionCurve_SetPorosity(BrooksCoreyRetentionCurve self, real porosity, real porosity_decay=0)\n"
+ "\n"
+ "void\n"
+ "SetPorosity(real porosity, real porosity_decay=0)\n"
+ "\n"
+ "Sets the porosity (Volume of pores per volume of soil) and the\n"
+ "exponential porosity decline with depth. \n"
+ ""},
+ { (char *)"BrooksCoreyRetentionCurve_Transmissivity", (PyCFunction) _wrap_BrooksCoreyRetentionCurve_Transmissivity, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "BrooksCoreyRetentionCurve_Transmissivity(BrooksCoreyRetentionCurve self, real upperDepth, real lowerDepth, real theta) -> real\n"
+ "\n"
+ "real\n"
+ "Transmissivity(real upperDepth, real lowerDepth, real theta) const \n"
+ ""},
{ (char *)"BrooksCoreyRetentionCurve_wetness_X_set", _wrap_BrooksCoreyRetentionCurve_wetness_X_set, METH_VARARGS, (char *)"BrooksCoreyRetentionCurve_wetness_X_set(BrooksCoreyRetentionCurve self, real wetness_X)"},
{ (char *)"BrooksCoreyRetentionCurve_wetness_X_get", (PyCFunction)_wrap_BrooksCoreyRetentionCurve_wetness_X_get, METH_O, (char *)"BrooksCoreyRetentionCurve_wetness_X_get(BrooksCoreyRetentionCurve self) -> real"},
{ (char *)"BrooksCoreyRetentionCurve_Psi_X_set", _wrap_BrooksCoreyRetentionCurve_Psi_X_set, METH_VARARGS, (char *)"BrooksCoreyRetentionCurve_Psi_X_set(BrooksCoreyRetentionCurve self, real Psi_X)"},
{ (char *)"BrooksCoreyRetentionCurve_Psi_X_get", (PyCFunction)_wrap_BrooksCoreyRetentionCurve_Psi_X_get, METH_O, (char *)"BrooksCoreyRetentionCurve_Psi_X_get(BrooksCoreyRetentionCurve self) -> real"},
{ (char *)"BrooksCoreyRetentionCurve_residual_theta_set", _wrap_BrooksCoreyRetentionCurve_residual_theta_set, METH_VARARGS, (char *)"BrooksCoreyRetentionCurve_residual_theta_set(BrooksCoreyRetentionCurve self, real residual_theta)"},
{ (char *)"BrooksCoreyRetentionCurve_residual_theta_get", (PyCFunction)_wrap_BrooksCoreyRetentionCurve_residual_theta_get, METH_O, (char *)"BrooksCoreyRetentionCurve_residual_theta_get(BrooksCoreyRetentionCurve self) -> real"},
- { (char *)"new_BrooksCoreyRetentionCurve", (PyCFunction) _wrap_new_BrooksCoreyRetentionCurve, METH_VARARGS | METH_KEYWORDS, (char *)"new_BrooksCoreyRetentionCurve(real ksat=15, real porosity=0.5, real _b=5, real theta_x=0.2, real psi_x, real porosity_decay=0) -> BrooksCoreyRetentionCurve"},
+ { (char *)"new_BrooksCoreyRetentionCurve", (PyCFunction) _wrap_new_BrooksCoreyRetentionCurve, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_BrooksCoreyRetentionCurve(real ksat=15, real porosity=0.5, real _b=5, real theta_x=0.2, real psi_x, real porosity_decay=0) -> BrooksCoreyRetentionCurve\n"
+ "\n"
+ "BrooksCoreyRetentionCurve(real ksat=15, real porosity=0.5, real _b=5,\n"
+ "real theta_x=0.2, real psi_x=pF_to_waterhead(2.5), real\n"
+ "porosity_decay=0)\n"
+ "\n"
+ "Creates a brooks corey retention curve.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "ksat: Saturated conductivity :math:`\\\\frac{m}{day}`\n"
+ "\n"
+ "porosity: :math:`\\\\frac{m^3 Pores}{m^3 Soil}`\n"
+ "\n"
+ "_b: Shape of the retention curve (if you do not know how to\n"
+ "parameterize this, take a look at the other constructor)\n"
+ "\n"
+ "theta_x: :math:`\\\\theta_X` Water content at a specific suction pressure\n"
+ "\n"
+ "psi_x: Suction pressure for :math:`\\\\theta_X` in m water column, use the\n"
+ "conversion functions pF_to_waterhead, pressure_to_waterhead to convert\n"
+ "pressure in to waterhead height (default pF=2.5)\n"
+ "\n"
+ "porosity_decay: Relative decay of porosity with depth, e.g. 0.1 means\n"
+ "conductivity gets 10% smaller per meter \n"
+ ""},
{ (char *)"BrooksCoreyRetentionCurve_CreateFrom2Points", (PyCFunction) _wrap_BrooksCoreyRetentionCurve_CreateFrom2Points, METH_VARARGS | METH_KEYWORDS, (char *)"BrooksCoreyRetentionCurve_CreateFrom2Points(real ksat, real porosity, real theta1, real theta2, real psi_1, real psi_2) -> BrooksCoreyRetentionCurve"},
- { (char *)"BrooksCoreyRetentionCurve_copy", (PyCFunction)_wrap_BrooksCoreyRetentionCurve_copy, METH_O, (char *)"BrooksCoreyRetentionCurve_copy(BrooksCoreyRetentionCurve self) -> BrooksCoreyRetentionCurve"},
+ { (char *)"BrooksCoreyRetentionCurve_copy", (PyCFunction)_wrap_BrooksCoreyRetentionCurve_copy, METH_O, (char *)"\n"
+ "BrooksCoreyRetentionCurve_copy(BrooksCoreyRetentionCurve self) -> BrooksCoreyRetentionCurve\n"
+ "\n"
+ "virtual BrooksCoreyRetentionCurve* copy() const \n"
+ ""},
{ (char *)"BrooksCoreyRetentionCurve_b_set", _wrap_BrooksCoreyRetentionCurve_b_set, METH_VARARGS, (char *)"BrooksCoreyRetentionCurve_b_set(BrooksCoreyRetentionCurve self, real b)"},
{ (char *)"BrooksCoreyRetentionCurve_b_get", (PyCFunction)_wrap_BrooksCoreyRetentionCurve_b_get, METH_O, (char *)"BrooksCoreyRetentionCurve_b_get(BrooksCoreyRetentionCurve self) -> real"},
{ (char *)"delete_BrooksCoreyRetentionCurve", (PyCFunction)_wrap_delete_BrooksCoreyRetentionCurve, METH_O, (char *)"delete_BrooksCoreyRetentionCurve(BrooksCoreyRetentionCurve self)"},
@@ -75830,10 +78705,57 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"VanGenuchtenMualem_theta_r_get", (PyCFunction)_wrap_VanGenuchtenMualem_theta_r_get, METH_O, (char *)"VanGenuchtenMualem_theta_r_get(VanGenuchtenMualem self) -> real"},
{ (char *)"VanGenuchtenMualem_w0_set", _wrap_VanGenuchtenMualem_w0_set, METH_VARARGS, (char *)"VanGenuchtenMualem_w0_set(VanGenuchtenMualem self, real w0)"},
{ (char *)"VanGenuchtenMualem_w0_get", (PyCFunction)_wrap_VanGenuchtenMualem_w0_get, METH_O, (char *)"VanGenuchtenMualem_w0_get(VanGenuchtenMualem self) -> real"},
- { (char *)"VanGenuchtenMualem_Transmissivity", (PyCFunction) _wrap_VanGenuchtenMualem_Transmissivity, METH_VARARGS | METH_KEYWORDS, (char *)"VanGenuchtenMualem_Transmissivity(VanGenuchtenMualem self, real upperDepth, real lowerDepth, real wetness) -> real"},
- { (char *)"VanGenuchtenMualem_fit_w0", (PyCFunction) _wrap_VanGenuchtenMualem_fit_w0, METH_VARARGS | METH_KEYWORDS, (char *)"VanGenuchtenMualem_fit_w0(VanGenuchtenMualem self, real w1=1.01, real Psi_p=1.0, real tolerance=0.05) -> real"},
- { (char *)"VanGenuchtenMualem_copy", (PyCFunction)_wrap_VanGenuchtenMualem_copy, METH_O, (char *)"VanGenuchtenMualem_copy(VanGenuchtenMualem self) -> VanGenuchtenMualem"},
- { (char *)"new_VanGenuchtenMualem", (PyCFunction) _wrap_new_VanGenuchtenMualem, METH_VARARGS | METH_KEYWORDS, (char *)"new_VanGenuchtenMualem(real Ksat=15, real phi=0.5, real alpha=0.2178, real n=1.211, real m=-1) -> VanGenuchtenMualem"},
+ { (char *)"VanGenuchtenMualem_Transmissivity", (PyCFunction) _wrap_VanGenuchtenMualem_Transmissivity, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "VanGenuchtenMualem_Transmissivity(VanGenuchtenMualem self, real upperDepth, real lowerDepth, real wetness) -> real\n"
+ "\n"
+ "virtual real\n"
+ "Transmissivity(real upperDepth, real lowerDepth, real wetness) const\n"
+ "\n"
+ ""},
+ { (char *)"VanGenuchtenMualem_fit_w0", (PyCFunction) _wrap_VanGenuchtenMualem_fit_w0, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "VanGenuchtenMualem_fit_w0(VanGenuchtenMualem self, real w1=1.01, real Psi_p=1.0, real tolerance=0.05) -> real\n"
+ "\n"
+ "real\n"
+ "fit_w0(real w1=1.01, real Psi_p=1.0, real tolerance=0.05)\n"
+ "\n"
+ "Fits the break point wetness w0, to ensure a specific oversaturation\n"
+ "at a given hydrostatic potential.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "w1: The oversaturation wetness to archieve (>1), default = 1.01\n"
+ "\n"
+ "Psi_p: the hydrostatic potential for w1, default = +1.0 m\n"
+ "\n"
+ "tolerance: \n"
+ ""},
+ { (char *)"VanGenuchtenMualem_copy", (PyCFunction)_wrap_VanGenuchtenMualem_copy, METH_O, (char *)"\n"
+ "VanGenuchtenMualem_copy(VanGenuchtenMualem self) -> VanGenuchtenMualem\n"
+ "\n"
+ "VanGenuchtenMualem* copy() const \n"
+ ""},
+ { (char *)"new_VanGenuchtenMualem", (PyCFunction) _wrap_new_VanGenuchtenMualem, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_VanGenuchtenMualem(real Ksat=15, real phi=0.5, real alpha=0.2178, real n=1.211, real m=-1) -> VanGenuchtenMualem\n"
+ "\n"
+ "VanGenuchtenMualem(real Ksat=15, real phi=0.5, real alpha=0.2178, real\n"
+ "n=1.211, real m=-1)\n"
+ "\n"
+ "Creates a van Genuchten-Mualem retention curve.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "Ksat: Saturated conductivity in :math:`\\\\frac m{day}`\n"
+ "\n"
+ "phi: Porosity in :math:`\\\\frac{m^3 Pores}{m^3 Soil}`\n"
+ "\n"
+ "alpha: Van Genuchten :math:`\\\\alpha` in :math:`\\\\frac 1{cm}`\n"
+ "\n"
+ "n: Van Genuchten n\n"
+ "\n"
+ "m: Van Genuchten m parameter, if negative m is calculated as :math:`1-\\\\frac 1 n` \n"
+ ""},
{ (char *)"delete_VanGenuchtenMualem", (PyCFunction)_wrap_delete_VanGenuchtenMualem, METH_O, (char *)"delete_VanGenuchtenMualem(VanGenuchtenMualem self)"},
{ (char *)"VanGenuchtenMualem_swigregister", VanGenuchtenMualem_swigregister, METH_VARARGS, NULL},
{ (char *)"VanGenuchtenMualem_swiginit", VanGenuchtenMualem_swiginit, METH_VARARGS, NULL},
@@ -75849,24 +78771,109 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"LinearRetention_porosity_decay_get", (PyCFunction)_wrap_LinearRetention_porosity_decay_get, METH_O, (char *)"LinearRetention_porosity_decay_get(LinearRetention self) -> real"},
{ (char *)"LinearRetention_beta_set", _wrap_LinearRetention_beta_set, METH_VARARGS, (char *)"LinearRetention_beta_set(LinearRetention self, real beta)"},
{ (char *)"LinearRetention_beta_get", (PyCFunction)_wrap_LinearRetention_beta_get, METH_O, (char *)"LinearRetention_beta_get(LinearRetention self) -> real"},
- { (char *)"LinearRetention_Transmissivity", (PyCFunction) _wrap_LinearRetention_Transmissivity, METH_VARARGS | METH_KEYWORDS, (char *)"LinearRetention_Transmissivity(LinearRetention self, real upperDepth, real lowerDepth, real wetness) -> real"},
- { (char *)"LinearRetention_copy", (PyCFunction)_wrap_LinearRetention_copy, METH_O, (char *)"LinearRetention_copy(LinearRetention self) -> LinearRetention"},
- { (char *)"new_LinearRetention", (PyCFunction) _wrap_new_LinearRetention, METH_VARARGS | METH_KEYWORDS, (char *)"new_LinearRetention(real ksat, real phi, real thickness, real residual_wetness=0.1) -> LinearRetention"},
+ { (char *)"LinearRetention_Transmissivity", (PyCFunction) _wrap_LinearRetention_Transmissivity, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "LinearRetention_Transmissivity(LinearRetention self, real upperDepth, real lowerDepth, real wetness) -> real\n"
+ "\n"
+ "virtual real Transmissivity(real upperDepth, real lowerDepth, real\n"
+ "wetness) const \n"
+ ""},
+ { (char *)"LinearRetention_copy", (PyCFunction)_wrap_LinearRetention_copy, METH_O, (char *)"\n"
+ "LinearRetention_copy(LinearRetention self) -> LinearRetention\n"
+ "\n"
+ "LinearRetention* copy() const \n"
+ ""},
+ { (char *)"new_LinearRetention", (PyCFunction) _wrap_new_LinearRetention, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_LinearRetention(real ksat, real phi, real thickness, real residual_wetness=0.1) -> LinearRetention\n"
+ "\n"
+ "LinearRetention(real ksat, real phi, real thickness, real\n"
+ "residual_wetness=0.1) \n"
+ ""},
{ (char *)"delete_LinearRetention", (PyCFunction)_wrap_delete_LinearRetention, METH_O, (char *)"delete_LinearRetention(LinearRetention self)"},
{ (char *)"LinearRetention_swigregister", LinearRetention_swigregister, METH_VARARGS, NULL},
{ (char *)"LinearRetention_swiginit", LinearRetention_swiginit, METH_VARARGS, NULL},
{ (char *)"SoilLayer_Position_get", (PyCFunction)_wrap_SoilLayer_Position_get, METH_O, (char *)"SoilLayer_Position_get(SoilLayer self) -> ptrdiff_t const"},
{ (char *)"SoilLayer_cell_get", (PyCFunction)_wrap_SoilLayer_cell_get, METH_O, (char *)"SoilLayer_cell_get(SoilLayer self) -> Cell"},
- { (char *)"SoilLayer___get_upper", (PyCFunction)_wrap_SoilLayer___get_upper, METH_O, (char *)"SoilLayer___get_upper(SoilLayer self) -> cmf::upslope::SoilLayer::ptr"},
- { (char *)"SoilLayer___get_lower", (PyCFunction)_wrap_SoilLayer___get_lower, METH_O, (char *)"SoilLayer___get_lower(SoilLayer self) -> cmf::upslope::SoilLayer::ptr"},
- { (char *)"SoilLayer_get_soil", (PyCFunction)_wrap_SoilLayer_get_soil, METH_O, (char *)"SoilLayer_get_soil(SoilLayer self) -> RetentionCurve"},
- { (char *)"SoilLayer_set_soil", (PyCFunction) _wrap_SoilLayer_set_soil, METH_VARARGS | METH_KEYWORDS, (char *)"SoilLayer_set_soil(SoilLayer self, RetentionCurve r_curve)"},
- { (char *)"SoilLayer_get_K", (PyCFunction) _wrap_SoilLayer_get_K, METH_VARARGS | METH_KEYWORDS, (char *)"SoilLayer_get_K(SoilLayer self, point direction) -> real"},
+ { (char *)"SoilLayer___get_upper", (PyCFunction)_wrap_SoilLayer___get_upper, METH_O, (char *)"\n"
+ "SoilLayer___get_upper(SoilLayer self) -> cmf::upslope::SoilLayer::ptr\n"
+ "\n"
+ "ptr\n"
+ "get_upper() const \n"
+ ""},
+ { (char *)"SoilLayer___get_lower", (PyCFunction)_wrap_SoilLayer___get_lower, METH_O, (char *)"\n"
+ "SoilLayer___get_lower(SoilLayer self) -> cmf::upslope::SoilLayer::ptr\n"
+ "\n"
+ "ptr\n"
+ "get_lower() const \n"
+ ""},
+ { (char *)"SoilLayer_get_soil", (PyCFunction)_wrap_SoilLayer_get_soil, METH_O, (char *)"\n"
+ "SoilLayer_get_soil(SoilLayer self) -> RetentionCurve\n"
+ "\n"
+ "virtual\n"
+ "cmf::upslope::RetentionCurve& get_soil() const\n"
+ "\n"
+ "Returns the soil properties of the water storage. \n"
+ ""},
+ { (char *)"SoilLayer_set_soil", (PyCFunction) _wrap_SoilLayer_set_soil, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "SoilLayer_set_soil(SoilLayer self, RetentionCurve r_curve)\n"
+ "\n"
+ "virtual\n"
+ "void set_soil(const cmf::upslope::RetentionCurve &r_curve) \n"
+ ""},
+ { (char *)"SoilLayer_get_K", (PyCFunction) _wrap_SoilLayer_get_K, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "SoilLayer_get_K(SoilLayer self, point direction) -> real\n"
+ "\n"
+ "virtual real\n"
+ "get_K(cmf::geometry::point direction) const\n"
+ "\n"
+ "Returns the actual anisotropic conductivity along a direction :math:`K = (k_f \\\\cdot d) K`. \n"
+ ""},
{ (char *)"SoilLayer_anisotropic_kf_set", _wrap_SoilLayer_anisotropic_kf_set, METH_VARARGS, (char *)"SoilLayer_anisotropic_kf_set(SoilLayer self, point anisotropic_kf)"},
{ (char *)"SoilLayer_anisotropic_kf_get", (PyCFunction)_wrap_SoilLayer_anisotropic_kf_get, METH_O, (char *)"SoilLayer_anisotropic_kf_get(SoilLayer self) -> point"},
- { (char *)"SoilLayer_get_capacity", (PyCFunction)_wrap_SoilLayer_get_capacity, METH_O, (char *)"SoilLayer_get_capacity(SoilLayer self) -> real"},
- { (char *)"SoilLayer_get_saturated_depth", (PyCFunction)_wrap_SoilLayer_get_saturated_depth, METH_O, (char *)"SoilLayer_get_saturated_depth(SoilLayer self) -> real"},
- { (char *)"SoilLayer_get_flow_crosssection", (PyCFunction) _wrap_SoilLayer_get_flow_crosssection, METH_VARARGS | METH_KEYWORDS, (char *)"SoilLayer_get_flow_crosssection(SoilLayer self, SoilLayer target, bool HorizontalLayers=False) -> real"},
+ { (char *)"SoilLayer_get_capacity", (PyCFunction)_wrap_SoilLayer_get_capacity, METH_O, (char *)"\n"
+ "SoilLayer_get_capacity(SoilLayer self) -> real\n"
+ "\n"
+ "virtual\n"
+ "real get_capacity() const\n"
+ "\n"
+ "Returns the capacity of the water storage in m3. \n"
+ ""},
+ { (char *)"SoilLayer_get_saturated_depth", (PyCFunction)_wrap_SoilLayer_get_saturated_depth, METH_O, (char *)"\n"
+ "SoilLayer_get_saturated_depth(SoilLayer self) -> real\n"
+ "\n"
+ "virtual real get_saturated_depth() const\n"
+ "\n"
+ "Returns the depth for saturation \n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " z_{sat,this} =\n"
+ " \\\\left\\\\{z_{cell}-\\\\Psi_{tot} \\\\mbox{ if } W<1 \\\\\\\\\n"
+ " z_{sat,upper layer} \\\\right. \n"
+ "\n"
+ ". \n"
+ ""},
+ { (char *)"SoilLayer_get_flow_crosssection", (PyCFunction) _wrap_SoilLayer_get_flow_crosssection, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "SoilLayer_get_flow_crosssection(SoilLayer self, SoilLayer target, bool HorizontalLayers=False) -> real\n"
+ "\n"
+ "real get_flow_crosssection(const cmf::upslope::SoilLayer &target,\n"
+ "bool HorizontalLayers=false) const\n"
+ "\n"
+ "Calculates the shared crosssectional area of this and another soil\n"
+ "water storage.\n"
+ "\n"
+ "If both layers belong to the same cell, the area of the cell is\n"
+ "returned, if they belong to different cells the area of the vertical\n"
+ "shared boundary is returned get_area in m2\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "target: The other soil water storage\n"
+ "\n"
+ "HorizontalLayers: If true, the layers are assumed to be parallel to\n"
+ "the gravitational potential, otherwise they are assumed to be parallel\n"
+ "to the ground topography \n"
+ ""},
{ (char *)"SoilLayer_cast", (PyCFunction) _wrap_SoilLayer_cast, METH_VARARGS | METH_KEYWORDS, (char *)"SoilLayer_cast(cmf::water::flux_node::ptr node) -> cmf::upslope::SoilLayer::ptr"},
{ (char *)"SoilLayer_gravitational_potential_get", (PyCFunction)_wrap_SoilLayer_gravitational_potential_get, METH_O, (char *)"SoilLayer_gravitational_potential_get(SoilLayer self) -> real"},
{ (char *)"SoilLayer_matrix_potential_get", (PyCFunction)_wrap_SoilLayer_matrix_potential_get, METH_O, (char *)"SoilLayer_matrix_potential_get(SoilLayer self) -> real"},
@@ -75890,23 +78897,113 @@ static PyMethodDef SwigMethods[] = {
"layer_list(layer_list for_copy)\n"
"layer_list()\n"
"new_layer_list(node_list for_copy) -> layer_list\n"
+ "\n"
+ "layer_list(const cmf::water::node_list &for_copy)\n"
+ "\n"
+ "Creates a list of all soil layers from a node_list. \n"
+ ""},
+ { (char *)"layer_list_pop", (PyCFunction)_wrap_layer_list_pop, METH_O, (char *)"\n"
+ "layer_list_pop(layer_list self) -> cmf::upslope::SoilLayer::ptr\n"
+ "\n"
+ "SoilLayer::ptr\n"
+ "pop()\n"
+ "\n"
+ "Deletes the last layer from the list and returns it. \n"
+ ""},
+ { (char *)"layer_list_append", (PyCFunction) _wrap_layer_list_append, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "layer_list_append(layer_list self, cmf::upslope::SoilLayer::ptr l) -> layer_list\n"
+ "\n"
+ "layer_list&\n"
+ "append(SoilLayer::ptr l)\n"
+ "\n"
+ "Appends a soil layer to the list. \n"
""},
- { (char *)"layer_list_pop", (PyCFunction)_wrap_layer_list_pop, METH_O, (char *)"layer_list_pop(layer_list self) -> cmf::upslope::SoilLayer::ptr"},
- { (char *)"layer_list_append", (PyCFunction) _wrap_layer_list_append, METH_VARARGS | METH_KEYWORDS, (char *)"layer_list_append(layer_list self, cmf::upslope::SoilLayer::ptr l) -> layer_list"},
{ (char *)"layer_list_extend", _wrap_layer_list_extend, METH_VARARGS, (char *)"\n"
"extend(layer_list ll) -> layer_list\n"
"layer_list_extend(layer_list self, node_list nl) -> layer_list\n"
+ "\n"
+ "layer_list&\n"
+ "extend(const cmf::water::node_list &nl)\n"
+ "\n"
+ "Appends all soil layers from a node_list to this. \n"
+ ""},
+ { (char *)"layer_list_get_slice", (PyCFunction) _wrap_layer_list_get_slice, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "layer_list_get_slice(layer_list self, size_t first=0, size_t last=1000000, size_t step=1) -> layer_list\n"
+ "\n"
+ "layer_list get_slice(size_t first=0, size_t last=1000000, size_t\n"
+ "step=1) \n"
+ ""},
+ { (char *)"layer_list_clear", (PyCFunction)_wrap_layer_list_clear, METH_O, (char *)"\n"
+ "layer_list_clear(layer_list self)\n"
+ "\n"
+ "void clear()\n"
+ "\n"
+ "Clears the list. \n"
+ ""},
+ { (char *)"layer_list_size", (PyCFunction)_wrap_layer_list_size, METH_O, (char *)"\n"
+ "layer_list_size(layer_list self) -> size_t\n"
+ "\n"
+ "size_t size()\n"
+ "const\n"
+ "\n"
+ "Number of layers in the list. \n"
+ ""},
+ { (char *)"layer_list_set_wetness", (PyCFunction) _wrap_layer_list_set_wetness, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "layer_list_set_wetness(layer_list self, cmf::math::num_array const & Value, size_t offset=0)\n"
+ "\n"
+ "void\n"
+ "set_wetness(const cmf::math::num_array &Value, size_t offset=0)\n"
+ "\n"
+ "Sets the wetness in m3/m3 of layers [offset : arraysize]. \n"
+ ""},
+ { (char *)"layer_list_set_potential", (PyCFunction) _wrap_layer_list_set_potential, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "layer_list_set_potential(layer_list self, cmf::math::num_array const & Value, size_t offset=0)\n"
+ "\n"
+ "void\n"
+ "set_potential(const cmf::math::num_array &Value, size_t offset=0)\n"
+ "\n"
+ "Sets the potential (head) in m of layers [offset : arraysize]. \n"
+ ""},
+ { (char *)"layer_list_set_volume", (PyCFunction) _wrap_layer_list_set_volume, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "layer_list_set_volume(layer_list self, cmf::math::num_array const & Value, size_t offset=0)\n"
+ "\n"
+ "void\n"
+ "set_volume(const cmf::math::num_array &Value, size_t offset=0)\n"
+ "\n"
+ "Sets the Volume in m3 of layers [offset : arraysize]. \n"
+ ""},
+ { (char *)"layer_list_get_percolation", (PyCFunction) _wrap_layer_list_get_percolation, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "layer_list_get_percolation(layer_list self, Time t) -> cmf::math::num_array\n"
+ "\n"
+ "cmf::math::num_array get_percolation(cmf::math::Time t) const\n"
+ "\n"
+ "Returns the flux to each layer from the upper layer, or, in case of\n"
+ "the first layer from the surface water. \n"
+ ""},
+ { (char *)"layer_list_set_theta", (PyCFunction) _wrap_layer_list_set_theta, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "layer_list_set_theta(layer_list self, cmf::math::num_array const & Value, size_t offset=0)\n"
+ "\n"
+ "void\n"
+ "set_theta(const cmf::math::num_array &Value, size_t offset=0)\n"
+ "\n"
+ "Sets the volumetric water content of the soil. \n"
+ ""},
+ { (char *)"layer_list_set_ice_fraction", (PyCFunction) _wrap_layer_list_set_ice_fraction, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "layer_list_set_ice_fraction(layer_list self, cmf::math::num_array const & Value, size_t offset=0)\n"
+ "\n"
+ "void set_ice_fraction(const cmf::math::num_array &Value, size_t\n"
+ "offset=0)\n"
+ "\n"
+ "Sets the fraction of the ice content of the soil water. \n"
+ ""},
+ { (char *)"layer_list_set_rootfraction", (PyCFunction) _wrap_layer_list_set_rootfraction, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "layer_list_set_rootfraction(layer_list self, cmf::math::num_array const & Value, size_t offset=0)\n"
+ "\n"
+ "void set_rootfraction(const cmf::math::num_array &Value, size_t\n"
+ "offset=0)\n"
+ "\n"
+ "Sets the fraction of roots in each layer. \n"
""},
- { (char *)"layer_list_get_slice", (PyCFunction) _wrap_layer_list_get_slice, METH_VARARGS | METH_KEYWORDS, (char *)"layer_list_get_slice(layer_list self, size_t first=0, size_t last=1000000, size_t step=1) -> layer_list"},
- { (char *)"layer_list_clear", (PyCFunction)_wrap_layer_list_clear, METH_O, (char *)"layer_list_clear(layer_list self)"},
- { (char *)"layer_list_size", (PyCFunction)_wrap_layer_list_size, METH_O, (char *)"layer_list_size(layer_list self) -> size_t"},
- { (char *)"layer_list_set_wetness", (PyCFunction) _wrap_layer_list_set_wetness, METH_VARARGS | METH_KEYWORDS, (char *)"layer_list_set_wetness(layer_list self, cmf::math::num_array const & Value, size_t offset=0)"},
- { (char *)"layer_list_set_potential", (PyCFunction) _wrap_layer_list_set_potential, METH_VARARGS | METH_KEYWORDS, (char *)"layer_list_set_potential(layer_list self, cmf::math::num_array const & Value, size_t offset=0)"},
- { (char *)"layer_list_set_volume", (PyCFunction) _wrap_layer_list_set_volume, METH_VARARGS | METH_KEYWORDS, (char *)"layer_list_set_volume(layer_list self, cmf::math::num_array const & Value, size_t offset=0)"},
- { (char *)"layer_list_get_percolation", (PyCFunction) _wrap_layer_list_get_percolation, METH_VARARGS | METH_KEYWORDS, (char *)"layer_list_get_percolation(layer_list self, Time t) -> cmf::math::num_array"},
- { (char *)"layer_list_set_theta", (PyCFunction) _wrap_layer_list_set_theta, METH_VARARGS | METH_KEYWORDS, (char *)"layer_list_set_theta(layer_list self, cmf::math::num_array const & Value, size_t offset=0)"},
- { (char *)"layer_list_set_ice_fraction", (PyCFunction) _wrap_layer_list_set_ice_fraction, METH_VARARGS | METH_KEYWORDS, (char *)"layer_list_set_ice_fraction(layer_list self, cmf::math::num_array const & Value, size_t offset=0)"},
- { (char *)"layer_list_set_rootfraction", (PyCFunction) _wrap_layer_list_set_rootfraction, METH_VARARGS | METH_KEYWORDS, (char *)"layer_list_set_rootfraction(layer_list self, cmf::math::num_array const & Value, size_t offset=0)"},
{ (char *)"layer_list_gravitational_potential_get", (PyCFunction)_wrap_layer_list_gravitational_potential_get, METH_O, (char *)"layer_list_gravitational_potential_get(layer_list self) -> cmf::math::num_array"},
{ (char *)"layer_list_matrix_potential_get", (PyCFunction)_wrap_layer_list_matrix_potential_get, METH_O, (char *)"layer_list_matrix_potential_get(layer_list self) -> cmf::math::num_array"},
{ (char *)"layer_list_wetness_get", (PyCFunction)_wrap_layer_list_wetness_get, METH_O, (char *)"layer_list_wetness_get(layer_list self) -> cmf::math::num_array"},
@@ -75929,17 +79026,94 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"MacroPore_porefraction_min_get", (PyCFunction)_wrap_MacroPore_porefraction_min_get, METH_O, (char *)"MacroPore_porefraction_min_get(MacroPore self) -> real"},
{ (char *)"MacroPore_porefraction_max_set", _wrap_MacroPore_porefraction_max_set, METH_VARARGS, (char *)"MacroPore_porefraction_max_set(MacroPore self, real porefraction_max)"},
{ (char *)"MacroPore_porefraction_max_get", (PyCFunction)_wrap_MacroPore_porefraction_max_get, METH_O, (char *)"MacroPore_porefraction_max_get(MacroPore self) -> real"},
- { (char *)"MacroPore___get_layer", (PyCFunction)_wrap_MacroPore___get_layer, METH_O, (char *)"MacroPore___get_layer(MacroPore self) -> cmf::upslope::SoilLayer::ptr"},
- { (char *)"MacroPore_get_porefraction", (PyCFunction)_wrap_MacroPore_get_porefraction, METH_O, (char *)"MacroPore_get_porefraction(MacroPore self) -> real"},
+ { (char *)"MacroPore___get_layer", (PyCFunction)_wrap_MacroPore___get_layer, METH_O, (char *)"\n"
+ "MacroPore___get_layer(MacroPore self) -> cmf::upslope::SoilLayer::ptr\n"
+ "\n"
+ "SoilLayer::ptr get_layer() const\n"
+ "\n"
+ "Gets the soil layer (matrix water storage) for this macropore storage.\n"
+ "\n"
+ ""},
+ { (char *)"MacroPore_get_porefraction", (PyCFunction)_wrap_MacroPore_get_porefraction, METH_O, (char *)"\n"
+ "MacroPore_get_porefraction(MacroPore self) -> real\n"
+ "\n"
+ "real get_porefraction() const\n"
+ "\n"
+ "The fraction of the macro pores in m3/m3. This adds to the porosity of\n"
+ "the layer. \n"
+ ""},
{ (char *)"MacroPore_density_set", _wrap_MacroPore_density_set, METH_VARARGS, (char *)"MacroPore_density_set(MacroPore self, real density)"},
{ (char *)"MacroPore_density_get", (PyCFunction)_wrap_MacroPore_density_get, METH_O, (char *)"MacroPore_density_get(MacroPore self) -> real"},
{ (char *)"MacroPore_Ksat_set", _wrap_MacroPore_Ksat_set, METH_VARARGS, (char *)"MacroPore_Ksat_set(MacroPore self, real Ksat)"},
{ (char *)"MacroPore_Ksat_get", (PyCFunction)_wrap_MacroPore_Ksat_get, METH_O, (char *)"MacroPore_Ksat_get(MacroPore self) -> real"},
{ (char *)"MacroPore_crack_wetness_set", _wrap_MacroPore_crack_wetness_set, METH_VARARGS, (char *)"MacroPore_crack_wetness_set(MacroPore self, real crack_wetness)"},
{ (char *)"MacroPore_crack_wetness_get", (PyCFunction)_wrap_MacroPore_crack_wetness_get, METH_O, (char *)"MacroPore_crack_wetness_get(MacroPore self) -> real"},
- { (char *)"MacroPore_get_K", (PyCFunction) _wrap_MacroPore_get_K, METH_VARARGS | METH_KEYWORDS, (char *)"MacroPore_get_K(MacroPore self, point direction) -> real"},
- { (char *)"MacroPore_get_crackwidth", (PyCFunction)_wrap_MacroPore_get_crackwidth, METH_O, (char *)"MacroPore_get_crackwidth(MacroPore self) -> real"},
- { (char *)"MacroPore_get_flowwidth", (PyCFunction)_wrap_MacroPore_get_flowwidth, METH_O, (char *)"MacroPore_get_flowwidth(MacroPore self) -> real"},
+ { (char *)"MacroPore_get_K", (PyCFunction) _wrap_MacroPore_get_K, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "MacroPore_get_K(MacroPore self, point direction) -> real\n"
+ "\n"
+ "virtual real\n"
+ "get_K(cmf::geometry::point direction) const\n"
+ "\n"
+ "Returns the actual anisotropic conductivity along a direction :math:`K = (k_f \\\\cdot d) K`. \n"
+ ""},
+ { (char *)"MacroPore_get_crackwidth", (PyCFunction)_wrap_MacroPore_get_crackwidth, METH_O, (char *)"\n"
+ "MacroPore_get_crackwidth(MacroPore self) -> real\n"
+ "\n"
+ "virtual real get_crackwidth() const\n"
+ "\n"
+ "Returns the crack width for a prismatic crackstructure.\n"
+ "\n"
+ "For a prismatic crack structure, the porefraction in m3/m3 equals the\n"
+ "vertical crack area in m2/m2. The length of equally spaced cracks is\n"
+ "in one direction the inverse of the density and twice the length for\n"
+ "two directions. \n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " l_{crack} [m/m^2]= 2 \\\\frac {1}{d[m]}\n"
+ "\n"
+ "If\n"
+ "we again ignore the fact that the spacing of the cracking crossings is\n"
+ "counted double, the crack width is: \n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " w_{crack}[m] =\n"
+ " \\\\frac{A_{crack}[m^2/m^2]}{l_{crack}[m/m^2]} \n"
+ "\n"
+ "Combining both\n"
+ "eq. above: \n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " w_{crack}[m] = A_{crack}[m^2/m^2]\\\\frac{d[m]}{2}\n"
+ "\n"
+ "\n"
+ "\n"
+ ""},
+ { (char *)"MacroPore_get_flowwidth", (PyCFunction)_wrap_MacroPore_get_flowwidth, METH_O, (char *)"\n"
+ "MacroPore_get_flowwidth(MacroPore self) -> real\n"
+ "\n"
+ "real\n"
+ "get_flowwidth() const\n"
+ "\n"
+ "The approximate length of the aggregate boundaries.\n"
+ "\n"
+ "\n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " l = \\\\frac{2}{d_{macro}} A\n"
+ "\n"
+ "where: :math:`l` is the length of\n"
+ "the aggregate boundaries (in m)\n"
+ "\n"
+ ":math:`2` is the number of directions\n"
+ "\n"
+ ":math:`d_{macro}` is the mean distance between macropores (density) in m\n"
+ "\n"
+ ":math:`A` is the area of the cell \n"
+ ""},
{ (char *)"MacroPore_K_shape_set", _wrap_MacroPore_K_shape_set, METH_VARARGS, (char *)"MacroPore_K_shape_set(MacroPore self, real K_shape)"},
{ (char *)"MacroPore_K_shape_get", (PyCFunction)_wrap_MacroPore_K_shape_get, METH_O, (char *)"MacroPore_K_shape_get(MacroPore self) -> real"},
{ (char *)"MacroPore_create", (PyCFunction) _wrap_MacroPore_create, METH_VARARGS | METH_KEYWORDS, (char *)"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"},
@@ -75952,11 +79126,34 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"MacroPore_swigregister", MacroPore_swigregister, METH_VARARGS, NULL},
{ (char *)"delete_BaseMacroFlow", (PyCFunction)_wrap_delete_BaseMacroFlow, METH_O, (char *)"delete_BaseMacroFlow(BaseMacroFlow self)"},
{ (char *)"BaseMacroFlow_swigregister", BaseMacroFlow_swigregister, METH_VARARGS, NULL},
- { (char *)"new_GradientMacroFlow", (PyCFunction) _wrap_new_GradientMacroFlow, METH_VARARGS | METH_KEYWORDS, (char *)"new_GradientMacroFlow(cmf::upslope::MacroPore::ptr left, cmf::water::flux_node::ptr right) -> GradientMacroFlow"},
+ { (char *)"new_GradientMacroFlow", (PyCFunction) _wrap_new_GradientMacroFlow, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_GradientMacroFlow(cmf::upslope::MacroPore::ptr left, cmf::water::flux_node::ptr right) -> GradientMacroFlow\n"
+ "\n"
+ "GradientMacroFlow(cmf::upslope::MacroPore::ptr left,\n"
+ "cmf::water::flux_node::ptr right) \n"
+ ""},
{ (char *)"delete_GradientMacroFlow", (PyCFunction)_wrap_delete_GradientMacroFlow, METH_O, (char *)"delete_GradientMacroFlow(GradientMacroFlow self)"},
{ (char *)"GradientMacroFlow_swigregister", GradientMacroFlow_swigregister, METH_VARARGS, NULL},
{ (char *)"GradientMacroFlow_swiginit", GradientMacroFlow_swiginit, METH_VARARGS, NULL},
- { (char *)"new_KinematicMacroFlow", (PyCFunction) _wrap_new_KinematicMacroFlow, METH_VARARGS | METH_KEYWORDS, (char *)"new_KinematicMacroFlow(cmf::water::WaterStorage::ptr left, cmf::water::flux_node::ptr right, real beta=1.) -> KinematicMacroFlow"},
+ { (char *)"new_KinematicMacroFlow", (PyCFunction) _wrap_new_KinematicMacroFlow, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_KinematicMacroFlow(cmf::water::WaterStorage::ptr left, cmf::water::flux_node::ptr right, real beta=1.) -> KinematicMacroFlow\n"
+ "\n"
+ "KinematicMacroFlow(cmf::water::WaterStorage::ptr left,\n"
+ "cmf::water::flux_node::ptr right, real beta=1.)\n"
+ "\n"
+ "Creates the connection.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "left: right: the nodes between the connection should be created.\n"
+ "\n"
+ "beta: a conceptional curve shape parameter for the relation between\n"
+ "storage and outflow\n"
+ "\n"
+ "Either left or right needs to be a MacroPore, left needs to be a water\n"
+ "storage \n"
+ ""},
{ (char *)"delete_KinematicMacroFlow", (PyCFunction)_wrap_delete_KinematicMacroFlow, METH_O, (char *)"delete_KinematicMacroFlow(KinematicMacroFlow self)"},
{ (char *)"KinematicMacroFlow_swigregister", KinematicMacroFlow_swigregister, METH_VARARGS, NULL},
{ (char *)"KinematicMacroFlow_swiginit", KinematicMacroFlow_swiginit, METH_VARARGS, NULL},
@@ -75964,11 +79161,34 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"JarvisMacroFlow_beta_get", (PyCFunction)_wrap_JarvisMacroFlow_beta_get, METH_O, (char *)"JarvisMacroFlow_beta_get(JarvisMacroFlow self) -> real"},
{ (char *)"JarvisMacroFlow_porefraction_r_set", _wrap_JarvisMacroFlow_porefraction_r_set, METH_VARARGS, (char *)"JarvisMacroFlow_porefraction_r_set(JarvisMacroFlow self, real porefraction_r)"},
{ (char *)"JarvisMacroFlow_porefraction_r_get", (PyCFunction)_wrap_JarvisMacroFlow_porefraction_r_get, METH_O, (char *)"JarvisMacroFlow_porefraction_r_get(JarvisMacroFlow self) -> real"},
- { (char *)"new_JarvisMacroFlow", (PyCFunction) _wrap_new_JarvisMacroFlow, METH_VARARGS | METH_KEYWORDS, (char *)"new_JarvisMacroFlow(cmf::water::WaterStorage::ptr left, cmf::water::flux_node::ptr right, real beta=1., real porefraction_r=0.0) -> JarvisMacroFlow"},
+ { (char *)"new_JarvisMacroFlow", (PyCFunction) _wrap_new_JarvisMacroFlow, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_JarvisMacroFlow(cmf::water::WaterStorage::ptr left, cmf::water::flux_node::ptr right, real beta=1., real porefraction_r=0.0) -> JarvisMacroFlow\n"
+ "\n"
+ "JarvisMacroFlow(cmf::water::WaterStorage::ptr left,\n"
+ "cmf::water::flux_node::ptr right, real beta=1., real\n"
+ "porefraction_r=0.0)\n"
+ "\n"
+ "Constructs the connection.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "left: right: the connected macropores\n"
+ "\n"
+ "beta: User defined parameter for the swelling reaction\n"
+ "\n"
+ "porefraction_r: Porefraction at which flow starts. For swelling soils\n"
+ "that are closing completely th \n"
+ ""},
{ (char *)"delete_JarvisMacroFlow", (PyCFunction)_wrap_delete_JarvisMacroFlow, METH_O, (char *)"delete_JarvisMacroFlow(JarvisMacroFlow self)"},
{ (char *)"JarvisMacroFlow_swigregister", JarvisMacroFlow_swigregister, METH_VARARGS, NULL},
{ (char *)"JarvisMacroFlow_swiginit", JarvisMacroFlow_swiginit, METH_VARARGS, NULL},
- { (char *)"new_GradientMacroMicroExchange", (PyCFunction) _wrap_new_GradientMacroMicroExchange, METH_VARARGS | METH_KEYWORDS, (char *)"new_GradientMacroMicroExchange(cmf::upslope::SoilLayer::ptr left, cmf::upslope::MacroPore::ptr right) -> GradientMacroMicroExchange"},
+ { (char *)"new_GradientMacroMicroExchange", (PyCFunction) _wrap_new_GradientMacroMicroExchange, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_GradientMacroMicroExchange(cmf::upslope::SoilLayer::ptr left, cmf::upslope::MacroPore::ptr right) -> GradientMacroMicroExchange\n"
+ "\n"
+ "GradientMacroMicroExchange(cmf::upslope::SoilLayer::ptr left,\n"
+ "cmf::upslope::MacroPore::ptr right) \n"
+ ""},
{ (char *)"delete_GradientMacroMicroExchange", (PyCFunction)_wrap_delete_GradientMacroMicroExchange, METH_O, (char *)"delete_GradientMacroMicroExchange(GradientMacroMicroExchange self)"},
{ (char *)"GradientMacroMicroExchange_swigregister", GradientMacroMicroExchange_swigregister, METH_VARARGS, NULL},
{ (char *)"GradientMacroMicroExchange_swiginit", GradientMacroMicroExchange_swiginit, METH_VARARGS, NULL},
@@ -75976,7 +79196,12 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"DiffusiveMacroMicroExchange_omega_get", (PyCFunction)_wrap_DiffusiveMacroMicroExchange_omega_get, METH_O, (char *)"DiffusiveMacroMicroExchange_omega_get(DiffusiveMacroMicroExchange self) -> real"},
{ (char *)"DiffusiveMacroMicroExchange_pFrmi_set", _wrap_DiffusiveMacroMicroExchange_pFrmi_set, METH_VARARGS, (char *)"DiffusiveMacroMicroExchange_pFrmi_set(DiffusiveMacroMicroExchange self, real pFrmi)"},
{ (char *)"DiffusiveMacroMicroExchange_pFrmi_get", (PyCFunction)_wrap_DiffusiveMacroMicroExchange_pFrmi_get, METH_O, (char *)"DiffusiveMacroMicroExchange_pFrmi_get(DiffusiveMacroMicroExchange self) -> real"},
- { (char *)"new_DiffusiveMacroMicroExchange", (PyCFunction) _wrap_new_DiffusiveMacroMicroExchange, METH_VARARGS | METH_KEYWORDS, (char *)"new_DiffusiveMacroMicroExchange(cmf::upslope::MacroPore::ptr left, cmf::upslope::SoilLayer::ptr right, real omega, real pFrmi=4.2) -> DiffusiveMacroMicroExchange"},
+ { (char *)"new_DiffusiveMacroMicroExchange", (PyCFunction) _wrap_new_DiffusiveMacroMicroExchange, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_DiffusiveMacroMicroExchange(cmf::upslope::MacroPore::ptr left, cmf::upslope::SoilLayer::ptr right, real omega, real pFrmi=4.2) -> DiffusiveMacroMicroExchange\n"
+ "\n"
+ "DiffusiveMacroMicroExchange(cmf::upslope::MacroPore::ptr left,\n"
+ "cmf::upslope::SoilLayer::ptr right, real omega, real pFrmi=4.2) \n"
+ ""},
{ (char *)"delete_DiffusiveMacroMicroExchange", (PyCFunction)_wrap_delete_DiffusiveMacroMicroExchange, METH_O, (char *)"delete_DiffusiveMacroMicroExchange(DiffusiveMacroMicroExchange self)"},
{ (char *)"DiffusiveMacroMicroExchange_swigregister", DiffusiveMacroMicroExchange_swigregister, METH_VARARGS, NULL},
{ (char *)"DiffusiveMacroMicroExchange_swiginit", DiffusiveMacroMicroExchange_swiginit, METH_VARARGS, NULL},
@@ -75984,44 +79209,197 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"MACROlikeMacroMicroExchange_Gf_get", (PyCFunction)_wrap_MACROlikeMacroMicroExchange_Gf_get, METH_O, (char *)"MACROlikeMacroMicroExchange_Gf_get(MACROlikeMacroMicroExchange self) -> real"},
{ (char *)"MACROlikeMacroMicroExchange_gamma_w_set", _wrap_MACROlikeMacroMicroExchange_gamma_w_set, METH_VARARGS, (char *)"MACROlikeMacroMicroExchange_gamma_w_set(MACROlikeMacroMicroExchange self, real gamma_w)"},
{ (char *)"MACROlikeMacroMicroExchange_gamma_w_get", (PyCFunction)_wrap_MACROlikeMacroMicroExchange_gamma_w_get, METH_O, (char *)"MACROlikeMacroMicroExchange_gamma_w_get(MACROlikeMacroMicroExchange self) -> real"},
- { (char *)"new_MACROlikeMacroMicroExchange", (PyCFunction) _wrap_new_MACROlikeMacroMicroExchange, METH_VARARGS | METH_KEYWORDS, (char *)"new_MACROlikeMacroMicroExchange(cmf::upslope::SoilLayer::ptr left, cmf::upslope::MacroPore::ptr right, real _gamma_w=0.4, real _Gf=3) -> MACROlikeMacroMicroExchange"},
+ { (char *)"new_MACROlikeMacroMicroExchange", (PyCFunction) _wrap_new_MACROlikeMacroMicroExchange, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_MACROlikeMacroMicroExchange(cmf::upslope::SoilLayer::ptr left, cmf::upslope::MacroPore::ptr right, real _gamma_w=0.4, real _Gf=3) -> MACROlikeMacroMicroExchange\n"
+ "\n"
+ "MACROlikeMacroMicroExchange(cmf::upslope::SoilLayer::ptr left,\n"
+ "cmf::upslope::MacroPore::ptr right, real _gamma_w=0.4, real _Gf=3) \n"
+ ""},
{ (char *)"delete_MACROlikeMacroMicroExchange", (PyCFunction)_wrap_delete_MACROlikeMacroMicroExchange, METH_O, (char *)"delete_MACROlikeMacroMicroExchange(MACROlikeMacroMicroExchange self)"},
{ (char *)"MACROlikeMacroMicroExchange_swigregister", MACROlikeMacroMicroExchange_swigregister, METH_VARARGS, NULL},
{ (char *)"MACROlikeMacroMicroExchange_swiginit", MACROlikeMacroMicroExchange_swiginit, METH_VARARGS, NULL},
- { (char *)"IVolumeHeightFunction_h", (PyCFunction) _wrap_IVolumeHeightFunction_h, METH_VARARGS | METH_KEYWORDS, (char *)"IVolumeHeightFunction_h(IVolumeHeightFunction self, double V) -> double"},
- { (char *)"IVolumeHeightFunction_A", (PyCFunction) _wrap_IVolumeHeightFunction_A, METH_VARARGS | METH_KEYWORDS, (char *)"IVolumeHeightFunction_A(IVolumeHeightFunction self, double V) -> double"},
- { (char *)"IVolumeHeightFunction_V", (PyCFunction) _wrap_IVolumeHeightFunction_V, METH_VARARGS | METH_KEYWORDS, (char *)"IVolumeHeightFunction_V(IVolumeHeightFunction self, double h) -> double"},
- { (char *)"IVolumeHeightFunction_copy", (PyCFunction)_wrap_IVolumeHeightFunction_copy, METH_O, (char *)"IVolumeHeightFunction_copy(IVolumeHeightFunction self) -> IVolumeHeightFunction"},
- { (char *)"IVolumeHeightFunction_q", (PyCFunction) _wrap_IVolumeHeightFunction_q, METH_VARARGS | METH_KEYWORDS, (char *)"IVolumeHeightFunction_q(IVolumeHeightFunction self, double h, double slope) -> double"},
+ { (char *)"IVolumeHeightFunction_h", (PyCFunction) _wrap_IVolumeHeightFunction_h, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "IVolumeHeightFunction_h(IVolumeHeightFunction self, double V) -> double\n"
+ "\n"
+ "virtual\n"
+ "double h(double V) const =0\n"
+ "\n"
+ "Returns the depth of a given volume. \n"
+ ""},
+ { (char *)"IVolumeHeightFunction_A", (PyCFunction) _wrap_IVolumeHeightFunction_A, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "IVolumeHeightFunction_A(IVolumeHeightFunction self, double V) -> double\n"
+ "\n"
+ "virtual\n"
+ "double A(double V) const =0\n"
+ "\n"
+ "Returns the area of the surface for a given volume. \n"
+ ""},
+ { (char *)"IVolumeHeightFunction_V", (PyCFunction) _wrap_IVolumeHeightFunction_V, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "IVolumeHeightFunction_V(IVolumeHeightFunction self, double h) -> double\n"
+ "\n"
+ "virtual\n"
+ "double V(double h) const =0 \n"
+ ""},
+ { (char *)"IVolumeHeightFunction_copy", (PyCFunction)_wrap_IVolumeHeightFunction_copy, METH_O, (char *)"\n"
+ "IVolumeHeightFunction_copy(IVolumeHeightFunction self) -> IVolumeHeightFunction\n"
+ "\n"
+ "virtual IVolumeHeightFunction* copy() const =0 \n"
+ ""},
+ { (char *)"IVolumeHeightFunction_q", (PyCFunction) _wrap_IVolumeHeightFunction_q, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "IVolumeHeightFunction_q(IVolumeHeightFunction self, double h, double slope) -> double\n"
+ "\n"
+ "virtual\n"
+ "double q(double h, double slope) const \n"
+ ""},
{ (char *)"delete_IVolumeHeightFunction", (PyCFunction)_wrap_delete_IVolumeHeightFunction, METH_O, (char *)"delete_IVolumeHeightFunction(IVolumeHeightFunction self)"},
{ (char *)"IVolumeHeightFunction_swigregister", IVolumeHeightFunction_swigregister, METH_VARARGS, NULL},
{ (char *)"Prism_Area_set", _wrap_Prism_Area_set, METH_VARARGS, (char *)"Prism_Area_set(Prism self, double Area)"},
{ (char *)"Prism_Area_get", (PyCFunction)_wrap_Prism_Area_get, METH_O, (char *)"Prism_Area_get(Prism self) -> double"},
{ (char *)"Prism_RoughThickness_set", _wrap_Prism_RoughThickness_set, METH_VARARGS, (char *)"Prism_RoughThickness_set(Prism self, double RoughThickness)"},
{ (char *)"Prism_RoughThickness_get", (PyCFunction)_wrap_Prism_RoughThickness_get, METH_O, (char *)"Prism_RoughThickness_get(Prism self) -> double"},
- { (char *)"new_Prism", (PyCFunction) _wrap_new_Prism, METH_VARARGS | METH_KEYWORDS, (char *)"new_Prism(double base_area, double thickness_of_rough_ground=0.01) -> Prism"},
- { (char *)"Prism_copy", (PyCFunction)_wrap_Prism_copy, METH_O, (char *)"Prism_copy(Prism self) -> Prism"},
+ { (char *)"new_Prism", (PyCFunction) _wrap_new_Prism, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_Prism(double base_area, double thickness_of_rough_ground=0.01) -> Prism\n"
+ "\n"
+ "Prism(double\n"
+ "base_area, double thickness_of_rough_ground=0.01) \n"
+ ""},
+ { (char *)"Prism_copy", (PyCFunction)_wrap_Prism_copy, METH_O, (char *)"\n"
+ "Prism_copy(Prism self) -> Prism\n"
+ "\n"
+ "Prism* copy() const\n"
+ "\n"
+ ""},
{ (char *)"delete_Prism", (PyCFunction)_wrap_delete_Prism, METH_O, (char *)"delete_Prism(Prism self)"},
{ (char *)"Prism_swigregister", Prism_swigregister, METH_VARARGS, NULL},
{ (char *)"Prism_swiginit", Prism_swiginit, METH_VARARGS, NULL},
{ (char *)"new_volume_height_function", _wrap_new_volume_height_function, METH_VARARGS, (char *)"\n"
"volume_height_function(volume_height_function for_copy)\n"
"new_volume_height_function(IVolumeHeightFunction for_copy) -> volume_height_function\n"
+ "\n"
+ "volume_height_function(const IVolumeHeightFunction &for_copy)\n"
+ "\n"
+ "Wrapper for any IVolumeHeightFunction. \n"
+ ""},
+ { (char *)"volume_height_function_copy", (PyCFunction)_wrap_volume_height_function_copy, METH_O, (char *)"\n"
+ "volume_height_function_copy(volume_height_function self) -> volume_height_function\n"
+ "\n"
+ "volume_height_function* copy() const \n"
""},
- { (char *)"volume_height_function_copy", (PyCFunction)_wrap_volume_height_function_copy, METH_O, (char *)"volume_height_function_copy(volume_height_function self) -> volume_height_function"},
{ (char *)"delete_volume_height_function", (PyCFunction)_wrap_delete_volume_height_function, METH_O, (char *)"delete_volume_height_function(volume_height_function self)"},
{ (char *)"volume_height_function_swigregister", volume_height_function_swigregister, METH_VARARGS, NULL},
{ (char *)"volume_height_function_swiginit", volume_height_function_swiginit, METH_VARARGS, NULL},
- { (char *)"IChannel_get_nManning", (PyCFunction)_wrap_IChannel_get_nManning, METH_O, (char *)"IChannel_get_nManning(IChannel self) -> double"},
- { (char *)"IChannel_set_nManning", (PyCFunction) _wrap_IChannel_set_nManning, METH_VARARGS | METH_KEYWORDS, (char *)"IChannel_set_nManning(IChannel self, double val)"},
- { (char *)"IChannel_get_length", (PyCFunction)_wrap_IChannel_get_length, METH_O, (char *)"IChannel_get_length(IChannel self) -> double"},
- { (char *)"IChannel_typecode", (PyCFunction)_wrap_IChannel_typecode, METH_O, (char *)"IChannel_typecode(IChannel self) -> char"},
- { (char *)"IChannel_get_channel_width", (PyCFunction) _wrap_IChannel_get_channel_width, METH_VARARGS | METH_KEYWORDS, (char *)"IChannel_get_channel_width(IChannel self, double depth) -> double"},
- { (char *)"IChannel_get_wetted_perimeter", (PyCFunction) _wrap_IChannel_get_wetted_perimeter, METH_VARARGS | METH_KEYWORDS, (char *)"IChannel_get_wetted_perimeter(IChannel self, double depth) -> double"},
- { (char *)"IChannel_get_depth", (PyCFunction) _wrap_IChannel_get_depth, METH_VARARGS | METH_KEYWORDS, (char *)"IChannel_get_depth(IChannel self, double area) -> double"},
- { (char *)"IChannel_get_flux_crossection", (PyCFunction) _wrap_IChannel_get_flux_crossection, METH_VARARGS | METH_KEYWORDS, (char *)"IChannel_get_flux_crossection(IChannel self, double depth) -> double"},
- { (char *)"IChannel_copy", (PyCFunction)_wrap_IChannel_copy, METH_O, (char *)"IChannel_copy(IChannel self) -> IChannel"},
- { (char *)"IChannel_qManning", (PyCFunction) _wrap_IChannel_qManning, METH_VARARGS | METH_KEYWORDS, (char *)"IChannel_qManning(IChannel self, double A, double slope) -> double"},
+ { (char *)"IChannel_get_nManning", (PyCFunction)_wrap_IChannel_get_nManning, METH_O, (char *)"\n"
+ "IChannel_get_nManning(IChannel self) -> double\n"
+ "\n"
+ "virtual\n"
+ "double get_nManning() const =0 \n"
+ ""},
+ { (char *)"IChannel_set_nManning", (PyCFunction) _wrap_IChannel_set_nManning, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "IChannel_set_nManning(IChannel self, double val)\n"
+ "\n"
+ "virtual\n"
+ "void set_nManning(double val)=0 \n"
+ ""},
+ { (char *)"IChannel_get_length", (PyCFunction)_wrap_IChannel_get_length, METH_O, (char *)"\n"
+ "IChannel_get_length(IChannel self) -> double\n"
+ "\n"
+ "virtual\n"
+ "double get_length() const =0\n"
+ "\n"
+ "Length of the reach. \n"
+ ""},
+ { (char *)"IChannel_typecode", (PyCFunction)_wrap_IChannel_typecode, METH_O, (char *)"\n"
+ "IChannel_typecode(IChannel self) -> char\n"
+ "\n"
+ "virtual char\n"
+ "typecode() const =0 \n"
+ ""},
+ { (char *)"IChannel_get_channel_width", (PyCFunction) _wrap_IChannel_get_channel_width, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "IChannel_get_channel_width(IChannel self, double depth) -> double\n"
+ "\n"
+ "virtual double get_channel_width(double depth) const =0\n"
+ "\n"
+ "Calculates the flow width from a given actual depth [m] using the\n"
+ "actual IChannel geometry. \n"
+ ""},
+ { (char *)"IChannel_get_wetted_perimeter", (PyCFunction) _wrap_IChannel_get_wetted_perimeter, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "IChannel_get_wetted_perimeter(IChannel self, double depth) -> double\n"
+ "\n"
+ "virtual double get_wetted_perimeter(double depth) const =0\n"
+ "\n"
+ "Calculates the wetted perimeter from a given actual depth [m] using\n"
+ "the actual IChannel geometry. \n"
+ ""},
+ { (char *)"IChannel_get_depth", (PyCFunction) _wrap_IChannel_get_depth, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "IChannel_get_depth(IChannel self, double area) -> double\n"
+ "\n"
+ "virtual\n"
+ "double get_depth(double area) const =0\n"
+ "\n"
+ "Calculates the actual depth of the reach using the IChannel geometry.\n"
+ "\n"
+ "get_depth of the reach [m]\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "area: Wetted area of a river cross section [m2], can be obtained by\n"
+ "V/l, where V is the stored volume and l is the reach length \n"
+ ""},
+ { (char *)"IChannel_get_flux_crossection", (PyCFunction) _wrap_IChannel_get_flux_crossection, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "IChannel_get_flux_crossection(IChannel self, double depth) -> double\n"
+ "\n"
+ "virtual double get_flux_crossection(double depth) const =0\n"
+ "\n"
+ "Calculates the wetted area from a given depth using the IChannel\n"
+ "geometry.\n"
+ "\n"
+ "In most cases use get_flux_crossection=V/l, where V is the stored\n"
+ "volume and l is the reach length Wetted area of a river cross section\n"
+ "[m2]\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "depth: depth of the reach [m] \n"
+ ""},
+ { (char *)"IChannel_copy", (PyCFunction)_wrap_IChannel_copy, METH_O, (char *)"\n"
+ "IChannel_copy(IChannel self) -> IChannel\n"
+ "\n"
+ "virtual IChannel*\n"
+ "copy() const =0 \n"
+ ""},
+ { (char *)"IChannel_qManning", (PyCFunction) _wrap_IChannel_qManning, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "IChannel_qManning(IChannel self, double A, double slope) -> double\n"
+ "\n"
+ "virtual double\n"
+ "qManning(double A, double slope) const\n"
+ "\n"
+ "Calculates the flow rate from a given water volume in the reach\n"
+ "\n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " q_{Manning}&=& A R^{\\\\frac 2 3}\n"
+ " \\\\sqrt{\\\\frac {\\\\Delta_z} n} \\\\\\\\ A &=& \\\\frac V l\n"
+ " \\\\mbox{, (Crosssectional area of the wetted crossection, Volume per\n"
+ " length)} \\\\\\\\ R &=& \\\\frac A {P(d)} \\\\\\\\ P(d) &=& \\\\mbox{\n"
+ " the perimeter of the wetted crosssection, a function of reach depth}\n"
+ " \\\\\\\\ d(V) &=& \\\\mbox{ the depth of the reach a function of the\n"
+ " volume} \\\\\\\\ \\\\Delta_z &=& \\\\frac{z_{max} - z_{min}}{l}\n"
+ " \\\\mbox{ Slope of the reach} \n"
+ "\n"
+ ".\n"
+ "\n"
+ "Flow rate [m3/s]\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "A: The area of the cross section [m2]\n"
+ "\n"
+ "slope: The slope of the reach [m/m] \n"
+ ""},
{ (char *)"delete_IChannel", (PyCFunction)_wrap_delete_IChannel, METH_O, (char *)"delete_IChannel(IChannel self)"},
{ (char *)"IChannel_swigregister", IChannel_swigregister, METH_VARARGS, NULL},
{ (char *)"SWATReachType_BottomWidth_set", _wrap_SWATReachType_BottomWidth_set, METH_VARARGS, (char *)"SWATReachType_BottomWidth_set(SWATReachType self, double BottomWidth)"},
@@ -76036,8 +79414,25 @@ static PyMethodDef SwigMethods[] = {
"SWATReachType(SWATReachType copy)\n"
"SWATReachType(double l)\n"
"new_SWATReachType(double l, double BankWidth, double Depth) -> SWATReachType\n"
+ "\n"
+ "SWATReachType(double l, double BankWidth, double Depth)\n"
+ "\n"
+ "Creates a new reach structure from a give width and depth.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "l: length of the channel [m]\n"
+ "\n"
+ "BankWidth: get_channel_width of the reach from bank to bank [m]\n"
+ "\n"
+ "Depth: Depth of the reach [m] \n"
+ ""},
+ { (char *)"SWATReachType_copy", (PyCFunction)_wrap_SWATReachType_copy, METH_O, (char *)"\n"
+ "SWATReachType_copy(SWATReachType self) -> SWATReachType\n"
+ "\n"
+ "SWATReachType* copy() const \n"
""},
- { (char *)"SWATReachType_copy", (PyCFunction)_wrap_SWATReachType_copy, METH_O, (char *)"SWATReachType_copy(SWATReachType self) -> SWATReachType"},
{ (char *)"delete_SWATReachType", (PyCFunction)_wrap_delete_SWATReachType, METH_O, (char *)"delete_SWATReachType(SWATReachType self)"},
{ (char *)"SWATReachType_swigregister", SWATReachType_swigregister, METH_VARARGS, NULL},
{ (char *)"SWATReachType_swiginit", SWATReachType_swiginit, METH_VARARGS, NULL},
@@ -76046,16 +79441,28 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"new_TriangularReach", _wrap_new_TriangularReach, METH_VARARGS, (char *)"\n"
"TriangularReach(double l, double bankSlope=2)\n"
"new_TriangularReach(TriangularReach copy) -> TriangularReach\n"
+ "\n"
+ "TriangularReach(const TriangularReach ©) \n"
+ ""},
+ { (char *)"TriangularReach_copy", (PyCFunction)_wrap_TriangularReach_copy, METH_O, (char *)"\n"
+ "TriangularReach_copy(TriangularReach self) -> TriangularReach\n"
+ "\n"
+ "TriangularReach* copy() const \n"
""},
- { (char *)"TriangularReach_copy", (PyCFunction)_wrap_TriangularReach_copy, METH_O, (char *)"TriangularReach_copy(TriangularReach self) -> TriangularReach"},
{ (char *)"delete_TriangularReach", (PyCFunction)_wrap_delete_TriangularReach, METH_O, (char *)"delete_TriangularReach(TriangularReach self)"},
{ (char *)"TriangularReach_swigregister", TriangularReach_swigregister, METH_VARARGS, NULL},
{ (char *)"TriangularReach_swiginit", TriangularReach_swiginit, METH_VARARGS, NULL},
{ (char *)"new_RectangularReach", _wrap_new_RectangularReach, METH_VARARGS, (char *)"\n"
"RectangularReach(double l, double width)\n"
"new_RectangularReach(RectangularReach copy) -> RectangularReach\n"
+ "\n"
+ "RectangularReach(const RectangularReach ©) \n"
+ ""},
+ { (char *)"RectangularReach_copy", (PyCFunction)_wrap_RectangularReach_copy, METH_O, (char *)"\n"
+ "RectangularReach_copy(RectangularReach self) -> RectangularReach\n"
+ "\n"
+ "RectangularReach* copy() const \n"
""},
- { (char *)"RectangularReach_copy", (PyCFunction)_wrap_RectangularReach_copy, METH_O, (char *)"RectangularReach_copy(RectangularReach self) -> RectangularReach"},
{ (char *)"delete_RectangularReach", (PyCFunction)_wrap_delete_RectangularReach, METH_O, (char *)"delete_RectangularReach(RectangularReach self)"},
{ (char *)"RectangularReach_swigregister", RectangularReach_swigregister, METH_VARARGS, NULL},
{ (char *)"RectangularReach_swiginit", RectangularReach_swiginit, METH_VARARGS, NULL},
@@ -76064,8 +79471,15 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"new_PipeReach", _wrap_new_PipeReach, METH_VARARGS, (char *)"\n"
"PipeReach(double l, double diameter)\n"
"new_PipeReach(PipeReach copy) -> PipeReach\n"
+ "\n"
+ "PipeReach(const PipeReach ©) \n"
+ ""},
+ { (char *)"PipeReach_copy", (PyCFunction)_wrap_PipeReach_copy, METH_O, (char *)"\n"
+ "PipeReach_copy(PipeReach self) -> PipeReach\n"
+ "\n"
+ "PipeReach* copy()\n"
+ "const \n"
""},
- { (char *)"PipeReach_copy", (PyCFunction)_wrap_PipeReach_copy, METH_O, (char *)"PipeReach_copy(PipeReach self) -> PipeReach"},
{ (char *)"delete_PipeReach", (PyCFunction)_wrap_delete_PipeReach, METH_O, (char *)"delete_PipeReach(PipeReach self)"},
{ (char *)"PipeReach_swigregister", PipeReach_swigregister, METH_VARARGS, NULL},
{ (char *)"PipeReach_swiginit", PipeReach_swiginit, METH_VARARGS, NULL},
@@ -76076,22 +79490,80 @@ static PyMethodDef SwigMethods[] = {
"Channel(IVolumeHeightFunction for_casting)\n"
"Channel(Channel for_copy)\n"
"new_Channel(char typecode, double length, double width=1., double depth=0.25) -> Channel\n"
+ "\n"
+ "Channel(char\n"
+ "typecode, double length, double width=1., double depth=0.25)\n"
+ "\n"
+ "Creates a reachtype using a short cut character.\n"
+ "\n"
+ "Acceptes one of the following characters: 'T' TriangularReach, width\n"
+ "and depth are ignored.\n"
+ "\n"
+ "'R' RectangularReach, depth is ignored\n"
+ "\n"
+ "'P' PipeReach, depth is ignored, width is the diameter of the pipe\n"
+ "\n"
+ "'S' SWATReachType, a trapezoid flow cross section, as used in the SWAT\n"
+ "model, width (bank width) and depth are used the reach type\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "typecode: Describes the geometry of the reach cross section.\n"
+ "\n"
+ "length: The length of the channel in m\n"
+ "\n"
+ "width: width of the reach cross section in m (ignored for typecode\n"
+ "'T')\n"
+ "\n"
+ "depth: depth of the reach (ignored for typecode 'T','R','P','S') \n"
+ ""},
+ { (char *)"Channel_copy", (PyCFunction)_wrap_Channel_copy, METH_O, (char *)"\n"
+ "Channel_copy(Channel self) -> Channel\n"
+ "\n"
+ "Channel* copy()\n"
+ "const \n"
""},
- { (char *)"Channel_copy", (PyCFunction)_wrap_Channel_copy, METH_O, (char *)"Channel_copy(Channel self) -> Channel"},
{ (char *)"delete_Channel", (PyCFunction)_wrap_delete_Channel, METH_O, (char *)"delete_Channel(Channel self)"},
{ (char *)"Channel_swigregister", Channel_swigregister, METH_VARARGS, NULL},
{ (char *)"Channel_swiginit", Channel_swiginit, METH_VARARGS, NULL},
{ (char *)"new_MeanChannel", _wrap_new_MeanChannel, METH_VARARGS, (char *)"\n"
"MeanChannel(IChannel channel1, IChannel channel2)\n"
"new_MeanChannel(MeanChannel meanChannel) -> MeanChannel\n"
+ "\n"
+ "MeanChannel(const MeanChannel &meanChannel) \n"
+ ""},
+ { (char *)"MeanChannel_copy", (PyCFunction)_wrap_MeanChannel_copy, METH_O, (char *)"\n"
+ "MeanChannel_copy(MeanChannel self) -> MeanChannel\n"
+ "\n"
+ "MeanChannel*\n"
+ "copy() const \n"
""},
- { (char *)"MeanChannel_copy", (PyCFunction)_wrap_MeanChannel_copy, METH_O, (char *)"MeanChannel_copy(MeanChannel self) -> MeanChannel"},
{ (char *)"delete_MeanChannel", (PyCFunction)_wrap_delete_MeanChannel, METH_O, (char *)"delete_MeanChannel(MeanChannel self)"},
{ (char *)"MeanChannel_swigregister", MeanChannel_swigregister, METH_VARARGS, NULL},
{ (char *)"MeanChannel_swiginit", MeanChannel_swiginit, METH_VARARGS, NULL},
- { (char *)"OpenWaterStorage_get_height_function", (PyCFunction)_wrap_OpenWaterStorage_get_height_function, METH_O, (char *)"OpenWaterStorage_get_height_function(OpenWaterStorage self) -> IVolumeHeightFunction"},
- { (char *)"OpenWaterStorage_set_height_function", (PyCFunction) _wrap_OpenWaterStorage_set_height_function, METH_VARARGS | METH_KEYWORDS, (char *)"OpenWaterStorage_set_height_function(OpenWaterStorage self, IVolumeHeightFunction val)"},
- { (char *)"OpenWaterStorage_wet_area", (PyCFunction)_wrap_OpenWaterStorage_wet_area, METH_O, (char *)"OpenWaterStorage_wet_area(OpenWaterStorage self) -> real"},
+ { (char *)"OpenWaterStorage_get_height_function", (PyCFunction)_wrap_OpenWaterStorage_get_height_function, METH_O, (char *)"\n"
+ "OpenWaterStorage_get_height_function(OpenWaterStorage self) -> IVolumeHeightFunction\n"
+ "\n"
+ "virtual const\n"
+ "IVolumeHeightFunction& get_height_function() const\n"
+ "\n"
+ "The functional relation between volume, depth and exposed area. \n"
+ ""},
+ { (char *)"OpenWaterStorage_set_height_function", (PyCFunction) _wrap_OpenWaterStorage_set_height_function, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "OpenWaterStorage_set_height_function(OpenWaterStorage self, IVolumeHeightFunction val)\n"
+ "\n"
+ "virtual void\n"
+ "set_height_function(const IVolumeHeightFunction &val) \n"
+ ""},
+ { (char *)"OpenWaterStorage_wet_area", (PyCFunction)_wrap_OpenWaterStorage_wet_area, METH_O, (char *)"\n"
+ "OpenWaterStorage_wet_area(OpenWaterStorage self) -> real\n"
+ "\n"
+ "real\n"
+ "wet_area() const\n"
+ "\n"
+ "Returns the exposed surface area in m2. \n"
+ ""},
{ (char *)"OpenWaterStorage_create", _wrap_OpenWaterStorage_create, METH_VARARGS, (char *)"\n"
"create(project _project, real Area) -> cmf::river::OpenWaterStorage::ptr\n"
"OpenWaterStorage_create(project _project, IVolumeHeightFunction base_geo) -> cmf::river::OpenWaterStorage::ptr\n"
@@ -76101,36 +79573,188 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"OpenWaterStorage_depth_get", (PyCFunction)_wrap_OpenWaterStorage_depth_get, METH_O, (char *)"OpenWaterStorage_depth_get(OpenWaterStorage self) -> real"},
{ (char *)"delete_OpenWaterStorage", (PyCFunction)_wrap_delete_OpenWaterStorage, METH_O, (char *)"delete_OpenWaterStorage(OpenWaterStorage self)"},
{ (char *)"OpenWaterStorage_swigregister", OpenWaterStorage_swigregister, METH_VARARGS, NULL},
- { (char *)"Reach_get_reachtype", (PyCFunction)_wrap_Reach_get_reachtype, METH_O, (char *)"Reach_get_reachtype(Reach self) -> Channel"},
- { (char *)"Reach_set_height_function", (PyCFunction) _wrap_Reach_set_height_function, METH_VARARGS | METH_KEYWORDS, (char *)"Reach_set_height_function(Reach self, IChannel val)"},
- { (char *)"Reach_set_outlet", (PyCFunction) _wrap_Reach_set_outlet, METH_VARARGS | METH_KEYWORDS, (char *)"Reach_set_outlet(Reach self, cmf::water::flux_node::ptr outlet)"},
- { (char *)"Reach_set_dead_end", (PyCFunction)_wrap_Reach_set_dead_end, METH_O, (char *)"Reach_set_dead_end(Reach self)"},
- { (char *)"Reach_set_downstream", (PyCFunction) _wrap_Reach_set_downstream, METH_VARARGS | METH_KEYWORDS, (char *)"Reach_set_downstream(Reach self, cmf::river::Reach::ptr new_downstream, bool use_meanchannel=False)"},
- { (char *)"Reach___get_downstream", (PyCFunction)_wrap_Reach___get_downstream, METH_O, (char *)"Reach___get_downstream(Reach self) -> cmf::water::flux_node::ptr"},
- { (char *)"Reach_get_upstream", (PyCFunction) _wrap_Reach_get_upstream, METH_VARARGS | METH_KEYWORDS, (char *)"Reach_get_upstream(Reach self, int index) -> cmf::river::Reach::ptr"},
- { (char *)"Reach_connect_to_surfacewater", (PyCFunction) _wrap_Reach_connect_to_surfacewater, METH_VARARGS | METH_KEYWORDS, (char *)"Reach_connect_to_surfacewater(Reach self, Cell cell, real width, bool diffusive)"},
- { (char *)"Reach_distance_to_cell", (PyCFunction) _wrap_Reach_distance_to_cell, METH_VARARGS | METH_KEYWORDS, (char *)"Reach_distance_to_cell(Reach self, Cell cell) -> double"},
- { (char *)"Reach___get_root", (PyCFunction)_wrap_Reach___get_root, METH_O, (char *)"Reach___get_root(Reach self) -> cmf::river::Reach::ptr"},
- { (char *)"delete_Reach", (PyCFunction)_wrap_delete_Reach, METH_O, (char *)"delete_Reach(Reach self)"},
+ { (char *)"Reach_get_reachtype", (PyCFunction)_wrap_Reach_get_reachtype, METH_O, (char *)"\n"
+ "Reach_get_reachtype(Reach self) -> Channel\n"
+ "\n"
+ "Channel\n"
+ "get_reachtype() const\n"
+ "\n"
+ "Returns the channel shape. \n"
+ ""},
+ { (char *)"Reach_set_height_function", (PyCFunction) _wrap_Reach_set_height_function, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Reach_set_height_function(Reach self, IChannel val)\n"
+ "\n"
+ "void\n"
+ "set_height_function(const IChannel &val)\n"
+ "\n"
+ "Sets the channel shape. \n"
+ ""},
+ { (char *)"Reach_set_outlet", (PyCFunction) _wrap_Reach_set_outlet, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Reach_set_outlet(Reach self, cmf::water::flux_node::ptr outlet)\n"
+ "\n"
+ "void\n"
+ "set_outlet(cmf::water::flux_node::ptr outlet)\n"
+ "\n"
+ "Connects the reach to an outlet, e.g. a boundary condition. \n"
+ ""},
+ { (char *)"Reach_set_dead_end", (PyCFunction)_wrap_Reach_set_dead_end, METH_O, (char *)"\n"
+ "Reach_set_dead_end(Reach self)\n"
+ "\n"
+ "void\n"
+ "set_dead_end()\n"
+ "\n"
+ "Deletes any downstream connection. \n"
+ ""},
+ { (char *)"Reach_set_downstream", (PyCFunction) _wrap_Reach_set_downstream, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Reach_set_downstream(Reach self, cmf::river::Reach::ptr new_downstream, bool use_meanchannel=False)\n"
+ "\n"
+ "void\n"
+ "set_downstream(ptr new_downstream, bool use_meanchannel=false)\n"
+ "\n"
+ "Connects the reach to another one downstream. \n"
+ ""},
+ { (char *)"Reach___get_downstream", (PyCFunction)_wrap_Reach___get_downstream, METH_O, (char *)"\n"
+ "Reach___get_downstream(Reach self) -> cmf::water::flux_node::ptr\n"
+ "\n"
+ "cmf::water::flux_node::ptr get_downstream() const\n"
+ "\n"
+ "Returns the reach downstream of this (or null if there is no reach\n"
+ "downstream) \n"
+ ""},
+ { (char *)"Reach_get_upstream", (PyCFunction) _wrap_Reach_get_upstream, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Reach_get_upstream(Reach self, int index) -> cmf::river::Reach::ptr\n"
+ "\n"
+ "ptr\n"
+ "get_upstream(int index) const\n"
+ "\n"
+ "Returns a reach upstream of this. \n"
+ ""},
+ { (char *)"Reach_connect_to_surfacewater", (PyCFunction) _wrap_Reach_connect_to_surfacewater, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Reach_connect_to_surfacewater(Reach self, Cell cell, real width, bool diffusive)\n"
+ "\n"
+ "void connect_to_surfacewater(cmf::upslope::Cell *cell, real width,\n"
+ "bool diffusive)\n"
+ "\n"
+ "Connects the surfacewater of a cell with this reach.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "cell: The cell with the surface water to be connected with this reach\n"
+ "\n"
+ "width: The flow width from cell to this reach\n"
+ "\n"
+ "diffusive: If diffusive is false, a ManningKinematic connection is\n"
+ "used, else a ManningDiffusive connection \n"
+ ""},
+ { (char *)"Reach_distance_to_cell", (PyCFunction) _wrap_Reach_distance_to_cell, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "Reach_distance_to_cell(Reach self, Cell cell) -> double\n"
+ "\n"
+ "double\n"
+ "distance_to_cell(cmf::upslope::Cell *cell) const\n"
+ "\n"
+ "Returns the distance (d) for connections between this reach and a\n"
+ "cell.\n"
+ "\n"
+ "If the effective inner cell distance (defined as :math:`R_{Cell} = 0.5\\\\frac{\\\\sqrt{A}}{\\\\pi}`) is smaller than the distance\n"
+ "between the center points, the cell radius is returned \n"
+ ""},
+ { (char *)"Reach___get_root", (PyCFunction)_wrap_Reach___get_root, METH_O, (char *)"\n"
+ "Reach___get_root(Reach self) -> cmf::river::Reach::ptr\n"
+ "\n"
+ "ptr get_root()\n"
+ "\n"
+ "Returns the reach most downstream from this reach. \n"
+ ""},
+ { (char *)"delete_Reach", (PyCFunction)_wrap_delete_Reach, METH_O, (char *)"\n"
+ "delete_Reach(Reach self)\n"
+ "\n"
+ "virtual ~Reach() \n"
+ ""},
{ (char *)"Reach_create", (PyCFunction) _wrap_Reach_create, METH_VARARGS | METH_KEYWORDS, (char *)"Reach_create(project project, IChannel shape, bool diffusive=False) -> cmf::river::Reach::ptr"},
{ (char *)"Reach_length_get", (PyCFunction)_wrap_Reach_length_get, METH_O, (char *)"Reach_length_get(Reach self) -> real"},
{ (char *)"Reach_width_get", (PyCFunction)_wrap_Reach_width_get, METH_O, (char *)"Reach_width_get(Reach self) -> real"},
{ (char *)"Reach_channel_get", (PyCFunction)_wrap_Reach_channel_get, METH_O, (char *)"Reach_channel_get(Reach self) -> IChannel"},
- { (char *)"Reach_upstream_count_get", (PyCFunction)_wrap_Reach_upstream_count_get, METH_O, (char *)"Reach_upstream_count_get(Reach self) -> int"},
+ { (char *)"Reach_upstream_count_get", (PyCFunction)_wrap_Reach_upstream_count_get, METH_O, (char *)"\n"
+ "Reach_upstream_count_get(Reach self) -> int\n"
+ "\n"
+ "int\n"
+ "upstream_count() const\n"
+ "\n"
+ "Returns the number of reaches upstream of this. \n"
+ ""},
{ (char *)"Reach_diffusive_set", _wrap_Reach_diffusive_set, METH_VARARGS, (char *)"Reach_diffusive_set(Reach self, bool diffusive)"},
{ (char *)"Reach_diffusive_get", (PyCFunction)_wrap_Reach_diffusive_get, METH_O, (char *)"Reach_diffusive_get(Reach self) -> bool"},
{ (char *)"Reach_swigregister", Reach_swigregister, METH_VARARGS, NULL},
- { (char *)"ReachIterator_next", (PyCFunction)_wrap_ReachIterator_next, METH_O, (char *)"ReachIterator_next(ReachIterator self) -> cmf::river::Reach::ptr"},
- { (char *)"ReachIterator_valid", (PyCFunction)_wrap_ReachIterator_valid, METH_O, (char *)"ReachIterator_valid(ReachIterator self) -> bool"},
- { (char *)"new_ReachIterator", (PyCFunction) _wrap_new_ReachIterator, METH_VARARGS | METH_KEYWORDS, (char *)"new_ReachIterator(cmf::river::Reach::ptr first) -> ReachIterator"},
- { (char *)"ReachIterator___reach", (PyCFunction)_wrap_ReachIterator___reach, METH_O, (char *)"ReachIterator___reach(ReachIterator self) -> cmf::river::Reach::ptr"},
- { (char *)"ReachIterator_position_get", (PyCFunction)_wrap_ReachIterator_position_get, METH_O, (char *)"ReachIterator_position_get(ReachIterator self) -> double"},
+ { (char *)"ReachIterator_next", (PyCFunction)_wrap_ReachIterator_next, METH_O, (char *)"\n"
+ "ReachIterator_next(ReachIterator self) -> cmf::river::Reach::ptr\n"
+ "\n"
+ "Reach::ptr\n"
+ "next()\n"
+ "\n"
+ "Returns the next reach in the upstream queue. \n"
+ ""},
+ { (char *)"ReachIterator_valid", (PyCFunction)_wrap_ReachIterator_valid, METH_O, (char *)"\n"
+ "ReachIterator_valid(ReachIterator self) -> bool\n"
+ "\n"
+ "bool valid()\n"
+ "const\n"
+ "\n"
+ "Returns true, if reaches are left to iterate over. \n"
+ ""},
+ { (char *)"new_ReachIterator", (PyCFunction) _wrap_new_ReachIterator, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_ReachIterator(cmf::river::Reach::ptr first) -> ReachIterator\n"
+ "\n"
+ "ReachIterator(Reach::ptr first)\n"
+ "\n"
+ "Creates a ReachIterator from a first reach. \n"
+ ""},
+ { (char *)"ReachIterator___reach", (PyCFunction)_wrap_ReachIterator___reach, METH_O, (char *)"\n"
+ "ReachIterator___reach(ReachIterator self) -> cmf::river::Reach::ptr\n"
+ "\n"
+ "Reach::ptr\n"
+ "reach() const\n"
+ "\n"
+ "Returns the current reach. \n"
+ ""},
+ { (char *)"ReachIterator_position_get", (PyCFunction)_wrap_ReachIterator_position_get, METH_O, (char *)"\n"
+ "ReachIterator_position_get(ReachIterator self) -> double\n"
+ "\n"
+ "double\n"
+ "position() const\n"
+ "\n"
+ "Returns the distance to the root reach. \n"
+ ""},
{ (char *)"delete_ReachIterator", (PyCFunction)_wrap_delete_ReachIterator, METH_O, (char *)"delete_ReachIterator(ReachIterator self)"},
{ (char *)"ReachIterator_swigregister", ReachIterator_swigregister, METH_VARARGS, NULL},
{ (char *)"ReachIterator_swiginit", ReachIterator_swiginit, METH_VARARGS, NULL},
- { (char *)"make_river_gap", (PyCFunction) _wrap_make_river_gap, METH_VARARGS | METH_KEYWORDS, (char *)"make_river_gap(cmf::river::Reach::ptr root_reach) -> double"},
- { (char *)"SurfaceWater_get_height_function", (PyCFunction)_wrap_SurfaceWater_get_height_function, METH_O, (char *)"SurfaceWater_get_height_function(SurfaceWater self) -> Prism"},
- { (char *)"SurfaceWater_get_cell", (PyCFunction)_wrap_SurfaceWater_get_cell, METH_O, (char *)"SurfaceWater_get_cell(SurfaceWater self) -> Cell"},
+ { (char *)"make_river_gap", (PyCFunction) _wrap_make_river_gap, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "make_river_gap(cmf::river::Reach::ptr root_reach) -> double\n"
+ "\n"
+ "double\n"
+ "cmf::river::make_river_gap(Reach::ptr root_reach)\n"
+ "\n"
+ "Ensures that rivers have a monotone downward flow direction.\n"
+ "\n"
+ "Reaches with a bottom higher than any upstream reach are lowered to\n"
+ "the minimum height of any (possibly distant) upstream reach. \n"
+ ""},
+ { (char *)"SurfaceWater_get_height_function", (PyCFunction)_wrap_SurfaceWater_get_height_function, METH_O, (char *)"\n"
+ "SurfaceWater_get_height_function(SurfaceWater self) -> Prism\n"
+ "\n"
+ "virtual const cmf::river::Prism& get_height_function() const\n"
+ "\n"
+ "Gets the height function (a cmf::river::Prism) for further reference.\n"
+ "\n"
+ ""},
+ { (char *)"SurfaceWater_get_cell", (PyCFunction)_wrap_SurfaceWater_get_cell, METH_O, (char *)"\n"
+ "SurfaceWater_get_cell(SurfaceWater self) -> Cell\n"
+ "\n"
+ "Cell&\n"
+ "get_cell() const\n"
+ "\n"
+ "Get the cell of the surface. \n"
+ ""},
{ (char *)"SurfaceWater_cast", (PyCFunction) _wrap_SurfaceWater_cast, METH_VARARGS | METH_KEYWORDS, (char *)"SurfaceWater_cast(cmf::water::flux_node::ptr node) -> cmf::upslope::SurfaceWater::ptr"},
{ (char *)"SurfaceWater_puddledepth_set", _wrap_SurfaceWater_puddledepth_set, METH_VARARGS, (char *)"SurfaceWater_puddledepth_set(SurfaceWater self, real puddledepth)"},
{ (char *)"SurfaceWater_puddledepth_get", (PyCFunction)_wrap_SurfaceWater_puddledepth_get, METH_O, (char *)"SurfaceWater_puddledepth_get(SurfaceWater self) -> real"},
@@ -76138,13 +79762,39 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"SurfaceWater_nManning_get", (PyCFunction)_wrap_SurfaceWater_nManning_get, METH_O, (char *)"SurfaceWater_nManning_get(SurfaceWater self) -> real"},
{ (char *)"delete_SurfaceWater", (PyCFunction)_wrap_delete_SurfaceWater, METH_O, (char *)"delete_SurfaceWater(SurfaceWater self)"},
{ (char *)"SurfaceWater_swigregister", SurfaceWater_swigregister, METH_VARARGS, NULL},
- { (char *)"new_KinematicSurfaceRunoff", (PyCFunction) _wrap_new_KinematicSurfaceRunoff, METH_VARARGS | METH_KEYWORDS, (char *)"new_KinematicSurfaceRunoff(cmf::upslope::SurfaceWater::ptr left, cmf::water::flux_node::ptr right, real flowwidth, real distance=-1) -> KinematicSurfaceRunoff"},
+ { (char *)"new_KinematicSurfaceRunoff", (PyCFunction) _wrap_new_KinematicSurfaceRunoff, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_KinematicSurfaceRunoff(cmf::upslope::SurfaceWater::ptr left, cmf::water::flux_node::ptr right, real flowwidth, real distance=-1) -> KinematicSurfaceRunoff\n"
+ "\n"
+ "KinematicSurfaceRunoff(cmf::upslope::SurfaceWater::ptr left,\n"
+ "cmf::water::flux_node::ptr right, real flowwidth, real distance=-1)\n"
+ "\n"
+ "Creates a KinematicSurfaceRunoff between a SurfaceWater (left) with\n"
+ "another (right) node.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "left: A surfacewater storage\n"
+ "\n"
+ "right: The target node\n"
+ "\n"
+ "flowwidth: the length of the shared boundary between left and right\n"
+ "in m\n"
+ "\n"
+ "distance: the distance between left and right in m. If d<=0m, the\n"
+ "distance is calculated according to the position of left and right \n"
+ ""},
{ (char *)"delete_KinematicSurfaceRunoff", (PyCFunction)_wrap_delete_KinematicSurfaceRunoff, METH_O, (char *)"delete_KinematicSurfaceRunoff(KinematicSurfaceRunoff self)"},
{ (char *)"KinematicSurfaceRunoff_swigregister", KinematicSurfaceRunoff_swigregister, METH_VARARGS, NULL},
{ (char *)"KinematicSurfaceRunoff_swiginit", KinematicSurfaceRunoff_swiginit, METH_VARARGS, NULL},
{ (char *)"DiffusiveSurfaceRunoff_set_linear_slope", (PyCFunction) _wrap_DiffusiveSurfaceRunoff_set_linear_slope, METH_VARARGS | METH_KEYWORDS, (char *)"DiffusiveSurfaceRunoff_set_linear_slope(real width)"},
{ (char *)"DiffusiveSurfaceRunoff_get_linear_slope", (PyCFunction)_wrap_DiffusiveSurfaceRunoff_get_linear_slope, METH_NOARGS, (char *)"DiffusiveSurfaceRunoff_get_linear_slope() -> real"},
- { (char *)"new_DiffusiveSurfaceRunoff", (PyCFunction) _wrap_new_DiffusiveSurfaceRunoff, METH_VARARGS | METH_KEYWORDS, (char *)"new_DiffusiveSurfaceRunoff(cmf::upslope::SurfaceWater::ptr left, cmf::water::flux_node::ptr right, real flowwidth, real distance=-1) -> DiffusiveSurfaceRunoff"},
+ { (char *)"new_DiffusiveSurfaceRunoff", (PyCFunction) _wrap_new_DiffusiveSurfaceRunoff, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_DiffusiveSurfaceRunoff(cmf::upslope::SurfaceWater::ptr left, cmf::water::flux_node::ptr right, real flowwidth, real distance=-1) -> DiffusiveSurfaceRunoff\n"
+ "\n"
+ "DiffusiveSurfaceRunoff(cmf::upslope::SurfaceWater::ptr left,\n"
+ "cmf::water::flux_node::ptr right, real flowwidth, real distance=-1) \n"
+ ""},
{ (char *)"delete_DiffusiveSurfaceRunoff", (PyCFunction)_wrap_delete_DiffusiveSurfaceRunoff, METH_O, (char *)"delete_DiffusiveSurfaceRunoff(DiffusiveSurfaceRunoff self)"},
{ (char *)"DiffusiveSurfaceRunoff_swigregister", DiffusiveSurfaceRunoff_swigregister, METH_VARARGS, NULL},
{ (char *)"DiffusiveSurfaceRunoff_swiginit", DiffusiveSurfaceRunoff_swiginit, METH_VARARGS, NULL},
@@ -76156,11 +79806,51 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"aquifer_porosity_get", (PyCFunction)_wrap_aquifer_porosity_get, METH_O, (char *)"aquifer_porosity_get(aquifer self) -> real"},
{ (char *)"aquifer_K_set", _wrap_aquifer_K_set, METH_VARARGS, (char *)"aquifer_K_set(aquifer self, point K)"},
{ (char *)"aquifer_K_get", (PyCFunction)_wrap_aquifer_K_get, METH_O, (char *)"aquifer_K_get(aquifer self) -> point"},
- { (char *)"aquifer_get_K", (PyCFunction) _wrap_aquifer_get_K, METH_VARARGS | METH_KEYWORDS, (char *)"aquifer_get_K(aquifer self, point direction) -> real"},
- { (char *)"aquifer_get_abs_errtol", (PyCFunction) _wrap_aquifer_get_abs_errtol, METH_VARARGS | METH_KEYWORDS, (char *)"aquifer_get_abs_errtol(aquifer self, real rel_errtol) -> real"},
+ { (char *)"aquifer_get_K", (PyCFunction) _wrap_aquifer_get_K, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "aquifer_get_K(aquifer self, point direction) -> real\n"
+ "\n"
+ "virtual real\n"
+ "get_K(cmf::geometry::point direction) const\n"
+ "\n"
+ "Returns the conductivity in m/day for a specific direction.\n"
+ "\n"
+ "Takes account for anisotropy \n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " \\\\|K\\\\|(d) =\n"
+ " \\\\frac{d}{\\\\|d\\\\|} \\\\bullet K\n"
+ "\n"
+ "\n"
+ ""},
+ { (char *)"aquifer_get_abs_errtol", (PyCFunction) _wrap_aquifer_get_abs_errtol, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "aquifer_get_abs_errtol(aquifer self, real rel_errtol) -> real\n"
+ "\n"
+ "real\n"
+ "get_abs_errtol(real rel_errtol) const \n"
+ ""},
{ (char *)"new_aquifer", _wrap_new_aquifer, METH_VARARGS, (char *)"\n"
"aquifer(project p, point position, real area, real thickness, real porosity, real K=1e-4)\n"
"new_aquifer(cell_vector cells, real thickness, real porosity, real K=1e-4) -> aquifer\n"
+ "\n"
+ "aquifer(cmf::upslope::cell_vector &cells, real thickness, real\n"
+ "porosity, real K=1e-4)\n"
+ "\n"
+ "Creates an aquifer below a collection of cells.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "cells: The cells above the aquifer. The area of the aquifer equals\n"
+ "the area of the cells, and the upper boundary equals the soildepth of\n"
+ "the lowest cell\n"
+ "\n"
+ "thickness: The thickness of the aquifer in m\n"
+ "\n"
+ "porosity: Porosity of the aquifer\n"
+ "\n"
+ "K: Conductivity of the aquifer in m/day. If the conductivity should\n"
+ "be anisotropic, change the x,y and z values of the member K \n"
""},
{ (char *)"aquifer_cast", (PyCFunction) _wrap_aquifer_cast, METH_VARARGS | METH_KEYWORDS, (char *)"aquifer_cast(cmf::water::flux_node::ptr for_cast) -> cmf::upslope::aquifer::ptr"},
{ (char *)"aquifer_base_height_get", (PyCFunction)_wrap_aquifer_base_height_get, METH_O, (char *)"aquifer_base_height_get(aquifer self) -> double"},
@@ -76170,21 +79860,84 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"aquifer_swiginit", aquifer_swiginit, METH_VARARGS, NULL},
{ (char *)"aquifer_Darcy_flux_width_set", _wrap_aquifer_Darcy_flux_width_set, METH_VARARGS, (char *)"aquifer_Darcy_flux_width_set(aquifer_Darcy self, real flux_width)"},
{ (char *)"aquifer_Darcy_flux_width_get", (PyCFunction)_wrap_aquifer_Darcy_flux_width_get, METH_O, (char *)"aquifer_Darcy_flux_width_get(aquifer_Darcy self) -> real"},
- { (char *)"new_aquifer_Darcy", (PyCFunction) _wrap_new_aquifer_Darcy, METH_VARARGS | METH_KEYWORDS, (char *)"new_aquifer_Darcy(cmf::upslope::aquifer::ptr left, cmf::water::flux_node::ptr right, real width) -> aquifer_Darcy"},
+ { (char *)"new_aquifer_Darcy", (PyCFunction) _wrap_new_aquifer_Darcy, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_aquifer_Darcy(cmf::upslope::aquifer::ptr left, cmf::water::flux_node::ptr right, real width) -> aquifer_Darcy\n"
+ "\n"
+ "aquifer_Darcy(aquifer::ptr left, cmf::water::flux_node::ptr right,\n"
+ "real width)\n"
+ "\n"
+ "Creates a new Darcy flow connection between two aquifers, or an\n"
+ "aquifer and another node acting as Dirichlet boundary condition.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "left: One aquifer\n"
+ "\n"
+ "right: Another aquifer, or a flux node that can be interpreted as an\n"
+ "Dirichlet boundary\n"
+ "\n"
+ "width: Width of the connection \n"
+ ""},
{ (char *)"delete_aquifer_Darcy", (PyCFunction)_wrap_delete_aquifer_Darcy, METH_O, (char *)"delete_aquifer_Darcy(aquifer_Darcy self)"},
{ (char *)"aquifer_Darcy_swigregister", aquifer_Darcy_swigregister, METH_VARARGS, NULL},
{ (char *)"aquifer_Darcy_swiginit", aquifer_Darcy_swiginit, METH_VARARGS, NULL},
{ (char *)"delete_lateral_sub_surface_flux", (PyCFunction)_wrap_delete_lateral_sub_surface_flux, METH_O, (char *)"delete_lateral_sub_surface_flux(lateral_sub_surface_flux self)"},
{ (char *)"lateral_sub_surface_flux_swigregister", lateral_sub_surface_flux_swigregister, METH_VARARGS, NULL},
- { (char *)"new_Darcy", (PyCFunction) _wrap_new_Darcy, METH_VARARGS | METH_KEYWORDS, (char *)"new_Darcy(cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right, real FlowWidth, real Distance=0) -> Darcy"},
+ { (char *)"new_Darcy", (PyCFunction) _wrap_new_Darcy, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_Darcy(cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right, real FlowWidth, real Distance=0) -> Darcy\n"
+ "\n"
+ "Darcy(cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr\n"
+ "right, real FlowWidth, real Distance=0) \n"
+ ""},
{ (char *)"delete_Darcy", (PyCFunction)_wrap_delete_Darcy, METH_O, (char *)"delete_Darcy(Darcy self)"},
{ (char *)"Darcy_swigregister", Darcy_swigregister, METH_VARARGS, NULL},
{ (char *)"Darcy_swiginit", Darcy_swiginit, METH_VARARGS, NULL},
- { (char *)"new_TopographicGradientDarcy", (PyCFunction) _wrap_new_TopographicGradientDarcy, METH_VARARGS | METH_KEYWORDS, (char *)"new_TopographicGradientDarcy(cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right, real FlowWidth, real Distance=0) -> TopographicGradientDarcy"},
+ { (char *)"new_TopographicGradientDarcy", (PyCFunction) _wrap_new_TopographicGradientDarcy, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_TopographicGradientDarcy(cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right, real FlowWidth, real Distance=0) -> TopographicGradientDarcy\n"
+ "\n"
+ "TopographicGradientDarcy(cmf::upslope::SoilLayer::ptr left,\n"
+ "cmf::water::flux_node::ptr right, real FlowWidth, real Distance=0)\n"
+ "\n"
+ "Creates the connection.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "left: Left node of the connection (needs to be soil water storage)\n"
+ "\n"
+ "right: Right node of the connection (can be any node)\n"
+ "\n"
+ "FlowWidth: the width of the connection - is multiplied by layer\n"
+ "thickness to get the interface area\n"
+ "\n"
+ "Distance: the length of the connection. If 0, the distance is\n"
+ "calculated from the position of the nodes \n"
+ ""},
{ (char *)"delete_TopographicGradientDarcy", (PyCFunction)_wrap_delete_TopographicGradientDarcy, METH_O, (char *)"delete_TopographicGradientDarcy(TopographicGradientDarcy self)"},
{ (char *)"TopographicGradientDarcy_swigregister", TopographicGradientDarcy_swigregister, METH_VARARGS, NULL},
{ (char *)"TopographicGradientDarcy_swiginit", TopographicGradientDarcy_swiginit, METH_VARARGS, NULL},
- { (char *)"new_DarcyKinematic", (PyCFunction) _wrap_new_DarcyKinematic, METH_VARARGS | METH_KEYWORDS, (char *)"new_DarcyKinematic(cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right, real FlowWidth, real Distance=0) -> DarcyKinematic"},
+ { (char *)"new_DarcyKinematic", (PyCFunction) _wrap_new_DarcyKinematic, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_DarcyKinematic(cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right, real FlowWidth, real Distance=0) -> DarcyKinematic\n"
+ "\n"
+ "DarcyKinematic(cmf::upslope::SoilLayer::ptr left,\n"
+ "cmf::water::flux_node::ptr right, real FlowWidth, real Distance=0)\n"
+ "\n"
+ "Creates the connection.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "left: Left node of the connection (needs to be soil water storage)\n"
+ "\n"
+ "right: Right node of the connection (can be any node)\n"
+ "\n"
+ "FlowWidth: the width of the connection - is multiplied by layer\n"
+ "thickness to get the interface area\n"
+ "\n"
+ "Distance: the length of the connection. If 0, the distance is\n"
+ "calculated from the position of the nodes \n"
+ ""},
{ (char *)"delete_DarcyKinematic", (PyCFunction)_wrap_delete_DarcyKinematic, METH_O, (char *)"delete_DarcyKinematic(DarcyKinematic self)"},
{ (char *)"DarcyKinematic_swigregister", DarcyKinematic_swigregister, METH_VARARGS, NULL},
{ (char *)"DarcyKinematic_swiginit", DarcyKinematic_swiginit, METH_VARARGS, NULL},
@@ -76192,7 +79945,27 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"Richards_lateral_flow_thickness_get", (PyCFunction)_wrap_Richards_lateral_flow_thickness_get, METH_O, (char *)"Richards_lateral_flow_thickness_get(Richards_lateral self) -> real"},
{ (char *)"Richards_lateral_wet_right_node_set", _wrap_Richards_lateral_wet_right_node_set, METH_VARARGS, (char *)"Richards_lateral_wet_right_node_set(Richards_lateral self, bool wet_right_node)"},
{ (char *)"Richards_lateral_wet_right_node_get", (PyCFunction)_wrap_Richards_lateral_wet_right_node_get, METH_O, (char *)"Richards_lateral_wet_right_node_get(Richards_lateral self) -> bool"},
- { (char *)"new_Richards_lateral", (PyCFunction) _wrap_new_Richards_lateral, METH_VARARGS | METH_KEYWORDS, (char *)"new_Richards_lateral(cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right, real FlowWidth=0, real Distance=0) -> Richards_lateral"},
+ { (char *)"new_Richards_lateral", (PyCFunction) _wrap_new_Richards_lateral, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_Richards_lateral(cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right, real FlowWidth=0, real Distance=0) -> Richards_lateral\n"
+ "\n"
+ "Richards_lateral(cmf::upslope::SoilLayer::ptr left,\n"
+ "cmf::water::flux_node::ptr right, real FlowWidth=0, real Distance=0)\n"
+ "\n"
+ "Creates the connection.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "left: Left node of the connection (needs to be soil water storage)\n"
+ "\n"
+ "right: Right node of the connection (can be any node)\n"
+ "\n"
+ "FlowWidth: the width of the connection - is multiplied by layer\n"
+ "thickness to get the interface area\n"
+ "\n"
+ "Distance: the length of the connection. If 0, the distance is\n"
+ "calculated from the position of the nodes \n"
+ ""},
{ (char *)"Richards_lateral_usebaseflow", (PyCFunction) _wrap_Richards_lateral_usebaseflow, METH_VARARGS | METH_KEYWORDS, (char *)"Richards_lateral_usebaseflow(bool use)"},
{ (char *)"delete_Richards_lateral", (PyCFunction)_wrap_delete_Richards_lateral, METH_O, (char *)"delete_Richards_lateral(Richards_lateral self)"},
{ (char *)"Richards_lateral_swigregister", Richards_lateral_swigregister, METH_VARARGS, NULL},
@@ -76205,7 +79978,13 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"TOPModelFlow_T0_get", (PyCFunction)_wrap_TOPModelFlow_T0_get, METH_O, (char *)"TOPModelFlow_T0_get(TOPModelFlow self) -> real"},
{ (char *)"TOPModelFlow_m_set", _wrap_TOPModelFlow_m_set, METH_VARARGS, (char *)"TOPModelFlow_m_set(TOPModelFlow self, real m)"},
{ (char *)"TOPModelFlow_m_get", (PyCFunction)_wrap_TOPModelFlow_m_get, METH_O, (char *)"TOPModelFlow_m_get(TOPModelFlow self) -> real"},
- { (char *)"new_TOPModelFlow", (PyCFunction) _wrap_new_TOPModelFlow, METH_VARARGS | METH_KEYWORDS, (char *)"new_TOPModelFlow(cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right, real T0, real m, real flowwidth, real distance=0) -> TOPModelFlow"},
+ { (char *)"new_TOPModelFlow", (PyCFunction) _wrap_new_TOPModelFlow, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_TOPModelFlow(cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right, real T0, real m, real flowwidth, real distance=0) -> TOPModelFlow\n"
+ "\n"
+ "TOPModelFlow(cmf::upslope::SoilLayer::ptr left,\n"
+ "cmf::water::flux_node::ptr right, real T0, real m, real flowwidth,\n"
+ "real distance=0) \n"
+ ""},
{ (char *)"delete_TOPModelFlow", (PyCFunction)_wrap_delete_TOPModelFlow, METH_O, (char *)"delete_TOPModelFlow(TOPModelFlow self)"},
{ (char *)"TOPModelFlow_swigregister", TOPModelFlow_swigregister, METH_VARARGS, NULL},
{ (char *)"TOPModelFlow_swiginit", TOPModelFlow_swiginit, METH_VARARGS, NULL},
@@ -76217,82 +79996,220 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"Manning_swigregister", Manning_swigregister, METH_VARARGS, NULL},
{ (char *)"Manning_Diffusive_linear_slope_width_set", _wrap_Manning_Diffusive_linear_slope_width_set, METH_VARARGS, (char *)"Manning_Diffusive_linear_slope_width_set(Manning_Diffusive self, real linear_slope_width)"},
{ (char *)"Manning_Diffusive_linear_slope_width_get", (PyCFunction)_wrap_Manning_Diffusive_linear_slope_width_get, METH_O, (char *)"Manning_Diffusive_linear_slope_width_get(Manning_Diffusive self) -> real"},
- { (char *)"new_Manning_Diffusive", (PyCFunction) _wrap_new_Manning_Diffusive, METH_VARARGS | METH_KEYWORDS, (char *)"new_Manning_Diffusive(cmf::river::OpenWaterStorage::ptr left, cmf::water::flux_node::ptr right, IChannel reachtype) -> Manning_Diffusive"},
+ { (char *)"new_Manning_Diffusive", (PyCFunction) _wrap_new_Manning_Diffusive, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_Manning_Diffusive(cmf::river::OpenWaterStorage::ptr left, cmf::water::flux_node::ptr right, IChannel reachtype) -> Manning_Diffusive\n"
+ "\n"
+ "Manning_Diffusive(cmf::river::OpenWaterStorage::ptr left,\n"
+ "cmf::water::flux_node::ptr right, const cmf::river::IChannel\n"
+ "&reachtype)\n"
+ "\n"
+ "Creates a diffusive wave connection between to open water storages.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "left: right: The nodes to be connected by the diffusive wave. Left\n"
+ "needs to be an open water storage\n"
+ "\n"
+ "reachtype: The channel geometry \n"
+ ""},
{ (char *)"delete_Manning_Diffusive", (PyCFunction)_wrap_delete_Manning_Diffusive, METH_O, (char *)"delete_Manning_Diffusive(Manning_Diffusive self)"},
{ (char *)"Manning_Diffusive_swigregister", Manning_Diffusive_swigregister, METH_VARARGS, NULL},
{ (char *)"Manning_Diffusive_swiginit", Manning_Diffusive_swiginit, METH_VARARGS, NULL},
- { (char *)"new_Manning_Kinematic", (PyCFunction) _wrap_new_Manning_Kinematic, METH_VARARGS | METH_KEYWORDS, (char *)"new_Manning_Kinematic(cmf::river::OpenWaterStorage::ptr left, cmf::water::flux_node::ptr right, IChannel reachtype) -> Manning_Kinematic"},
+ { (char *)"new_Manning_Kinematic", (PyCFunction) _wrap_new_Manning_Kinematic, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_Manning_Kinematic(cmf::river::OpenWaterStorage::ptr left, cmf::water::flux_node::ptr right, IChannel reachtype) -> Manning_Kinematic\n"
+ "\n"
+ "Manning_Kinematic(cmf::river::OpenWaterStorage::ptr left,\n"
+ "cmf::water::flux_node::ptr right, const cmf::river::IChannel\n"
+ "&reachtype)\n"
+ "\n"
+ "Creates a kinematic wave connection between to open water storages.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "left: right: The nodes to be connected by the kinematic wave. Left\n"
+ "needs to be an open water storage\n"
+ "\n"
+ "reachtype: The channel geometry \n"
+ ""},
{ (char *)"delete_Manning_Kinematic", (PyCFunction)_wrap_delete_Manning_Kinematic, METH_O, (char *)"delete_Manning_Kinematic(Manning_Kinematic self)"},
{ (char *)"Manning_Kinematic_swigregister", Manning_Kinematic_swigregister, METH_VARARGS, NULL},
{ (char *)"Manning_Kinematic_swiginit", Manning_Kinematic_swiginit, METH_VARARGS, NULL},
- { (char *)"new_CanopyOverflow", (PyCFunction) _wrap_new_CanopyOverflow, METH_VARARGS | METH_KEYWORDS, (char *)"new_CanopyOverflow(cmf::water::WaterStorage::ptr Canopy, cmf::water::flux_node::ptr target, Cell cell) -> CanopyOverflow"},
+ { (char *)"new_CanopyOverflow", (PyCFunction) _wrap_new_CanopyOverflow, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_CanopyOverflow(cmf::water::WaterStorage::ptr Canopy, cmf::water::flux_node::ptr target, Cell cell) -> CanopyOverflow\n"
+ "\n"
+ "CanopyOverflow(cmf::water::WaterStorage::ptr Canopy,\n"
+ "cmf::water::flux_node::ptr target, cmf::upslope::Cell &cell) \n"
+ ""},
{ (char *)"CanopyOverflow_use_for_cell", (PyCFunction) _wrap_CanopyOverflow_use_for_cell, METH_VARARGS | METH_KEYWORDS, (char *)"CanopyOverflow_use_for_cell(Cell cell) -> CanopyOverflow"},
{ (char *)"delete_CanopyOverflow", (PyCFunction)_wrap_delete_CanopyOverflow, METH_O, (char *)"delete_CanopyOverflow(CanopyOverflow self)"},
{ (char *)"CanopyOverflow_swigregister", CanopyOverflow_swigregister, METH_VARARGS, NULL},
{ (char *)"CanopyOverflow_swiginit", CanopyOverflow_swiginit, METH_VARARGS, NULL},
- { (char *)"new_RutterInterception", (PyCFunction) _wrap_new_RutterInterception, METH_VARARGS | METH_KEYWORDS, (char *)"new_RutterInterception(cmf::water::WaterStorage::ptr Canopy, cmf::water::flux_node::ptr target, Cell cell) -> RutterInterception"},
+ { (char *)"new_RutterInterception", (PyCFunction) _wrap_new_RutterInterception, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_RutterInterception(cmf::water::WaterStorage::ptr Canopy, cmf::water::flux_node::ptr target, Cell cell) -> RutterInterception\n"
+ "\n"
+ "RutterInterception(cmf::water::WaterStorage::ptr Canopy,\n"
+ "cmf::water::flux_node::ptr target, cmf::upslope::Cell &cell) \n"
+ ""},
{ (char *)"RutterInterception_use_for_cell", (PyCFunction) _wrap_RutterInterception_use_for_cell, METH_VARARGS | METH_KEYWORDS, (char *)"RutterInterception_use_for_cell(Cell cell) -> RutterInterception"},
{ (char *)"delete_RutterInterception", (PyCFunction)_wrap_delete_RutterInterception, METH_O, (char *)"delete_RutterInterception(RutterInterception self)"},
{ (char *)"RutterInterception_swigregister", RutterInterception_swigregister, METH_VARARGS, NULL},
{ (char *)"RutterInterception_swiginit", RutterInterception_swiginit, METH_VARARGS, NULL},
{ (char *)"SimpleTindexSnowMelt_SnowMeltRate_set", _wrap_SimpleTindexSnowMelt_SnowMeltRate_set, METH_VARARGS, (char *)"SimpleTindexSnowMelt_SnowMeltRate_set(SimpleTindexSnowMelt self, real SnowMeltRate)"},
{ (char *)"SimpleTindexSnowMelt_SnowMeltRate_get", (PyCFunction)_wrap_SimpleTindexSnowMelt_SnowMeltRate_get, METH_O, (char *)"SimpleTindexSnowMelt_SnowMeltRate_get(SimpleTindexSnowMelt self) -> real"},
- { (char *)"new_SimpleTindexSnowMelt", (PyCFunction) _wrap_new_SimpleTindexSnowMelt, METH_VARARGS | METH_KEYWORDS, (char *)"new_SimpleTindexSnowMelt(cmf::water::WaterStorage::ptr snow, cmf::water::flux_node::ptr surface_water, Cell cell, real rate=7.0) -> SimpleTindexSnowMelt"},
+ { (char *)"new_SimpleTindexSnowMelt", (PyCFunction) _wrap_new_SimpleTindexSnowMelt, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_SimpleTindexSnowMelt(cmf::water::WaterStorage::ptr snow, cmf::water::flux_node::ptr surface_water, Cell cell, real rate=7.0) -> SimpleTindexSnowMelt\n"
+ "\n"
+ "SimpleTindexSnowMelt(cmf::water::WaterStorage::ptr snow,\n"
+ "cmf::water::flux_node::ptr surface_water, cmf::upslope::Cell &cell,\n"
+ "real rate=7.0)\n"
+ "\n"
+ "Creates a new snow melt connection.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "snow: Snow storage, usually cel.snow\n"
+ "\n"
+ "surface_water: target of the melted water (usually cell.surfacewater)\n"
+ "\n"
+ "cell: The cell, needed to get weather and area\n"
+ "\n"
+ "rate: The rate of snow melt, given in mm/(degC day), default = 7.0 \n"
+ ""},
{ (char *)"SimpleTindexSnowMelt_use_for_cell", (PyCFunction) _wrap_SimpleTindexSnowMelt_use_for_cell, METH_VARARGS | METH_KEYWORDS, (char *)"SimpleTindexSnowMelt_use_for_cell(Cell cell)"},
{ (char *)"delete_SimpleTindexSnowMelt", (PyCFunction)_wrap_delete_SimpleTindexSnowMelt, METH_O, (char *)"delete_SimpleTindexSnowMelt(SimpleTindexSnowMelt self)"},
{ (char *)"SimpleTindexSnowMelt_swigregister", SimpleTindexSnowMelt_swigregister, METH_VARARGS, NULL},
{ (char *)"SimpleTindexSnowMelt_swiginit", SimpleTindexSnowMelt_swiginit, METH_VARARGS, NULL},
- { (char *)"new_EnergyBudgetSnowMelt", (PyCFunction) _wrap_new_EnergyBudgetSnowMelt, METH_VARARGS | METH_KEYWORDS, (char *)"new_EnergyBudgetSnowMelt(cmf::water::WaterStorage::ptr snow, cmf::water::flux_node::ptr surface_water, Cell cell) -> EnergyBudgetSnowMelt"},
+ { (char *)"new_EnergyBudgetSnowMelt", (PyCFunction) _wrap_new_EnergyBudgetSnowMelt, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_EnergyBudgetSnowMelt(cmf::water::WaterStorage::ptr snow, cmf::water::flux_node::ptr surface_water, Cell cell) -> EnergyBudgetSnowMelt\n"
+ "\n"
+ "EnergyBudgetSnowMelt(cmf::water::WaterStorage::ptr snow,\n"
+ "cmf::water::flux_node::ptr surface_water, cmf::upslope::Cell &cell) \n"
+ ""},
{ (char *)"EnergyBudgetSnowMelt_use_for_cell", (PyCFunction) _wrap_EnergyBudgetSnowMelt_use_for_cell, METH_VARARGS | METH_KEYWORDS, (char *)"EnergyBudgetSnowMelt_use_for_cell(Cell cell)"},
{ (char *)"delete_EnergyBudgetSnowMelt", (PyCFunction)_wrap_delete_EnergyBudgetSnowMelt, METH_O, (char *)"delete_EnergyBudgetSnowMelt(EnergyBudgetSnowMelt self)"},
{ (char *)"EnergyBudgetSnowMelt_swigregister", EnergyBudgetSnowMelt_swigregister, METH_VARARGS, NULL},
{ (char *)"EnergyBudgetSnowMelt_swiginit", EnergyBudgetSnowMelt_swiginit, METH_VARARGS, NULL},
- { (char *)"snowfraction", (PyCFunction) _wrap_snowfraction, METH_VARARGS | METH_KEYWORDS, (char *)"snowfraction(real T) -> real"},
+ { (char *)"snowfraction", (PyCFunction) _wrap_snowfraction, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "snowfraction(real T) -> real\n"
+ "\n"
+ "real\n"
+ "cmf::upslope::connections::snowfraction(real T)\n"
+ "\n"
+ "A function to calculate the snow fraction of the precipitation\n"
+ "according to the air temperature.\n"
+ "\n"
+ "Returns 0.0 for T>+1 degC, 1.0 for T<-1degC and interpolates linear\n"
+ "between. Values between 0 and 1 can be interpreted as sleet \n"
+ ""},
{ (char *)"Rainfall_Throughfall_set", _wrap_Rainfall_Throughfall_set, METH_VARARGS, (char *)"Rainfall_Throughfall_set(Rainfall self, bool Throughfall)"},
{ (char *)"Rainfall_Throughfall_get", (PyCFunction)_wrap_Rainfall_Throughfall_get, METH_O, (char *)"Rainfall_Throughfall_get(Rainfall self) -> bool"},
{ (char *)"Rainfall_InterceptedRainfall_set", _wrap_Rainfall_InterceptedRainfall_set, METH_VARARGS, (char *)"Rainfall_InterceptedRainfall_set(Rainfall self, bool InterceptedRainfall)"},
{ (char *)"Rainfall_InterceptedRainfall_get", (PyCFunction)_wrap_Rainfall_InterceptedRainfall_get, METH_O, (char *)"Rainfall_InterceptedRainfall_get(Rainfall self) -> bool"},
- { (char *)"new_Rainfall", (PyCFunction) _wrap_new_Rainfall, METH_VARARGS | METH_KEYWORDS, (char *)"new_Rainfall(cmf::water::flux_node::ptr target, Cell cell, bool getthroughfall=True, bool getintercepted=True) -> Rainfall"},
+ { (char *)"new_Rainfall", (PyCFunction) _wrap_new_Rainfall, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_Rainfall(cmf::water::flux_node::ptr target, Cell cell, bool getthroughfall=True, bool getintercepted=True) -> Rainfall\n"
+ "\n"
+ "Rainfall(cmf::water::flux_node::ptr target, cmf::upslope::Cell &cell,\n"
+ "bool getthroughfall=true, bool getintercepted=true)\n"
+ "\n"
+ "Creates a new Rainfall connection. \n"
+ ""},
{ (char *)"delete_Rainfall", (PyCFunction)_wrap_delete_Rainfall, METH_O, (char *)"delete_Rainfall(Rainfall self)"},
{ (char *)"Rainfall_swigregister", Rainfall_swigregister, METH_VARARGS, NULL},
{ (char *)"Rainfall_swiginit", Rainfall_swiginit, METH_VARARGS, NULL},
- { (char *)"new_Snowfall", (PyCFunction) _wrap_new_Snowfall, METH_VARARGS | METH_KEYWORDS, (char *)"new_Snowfall(cmf::water::flux_node::ptr target, Cell cell) -> Snowfall"},
+ { (char *)"new_Snowfall", (PyCFunction) _wrap_new_Snowfall, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_Snowfall(cmf::water::flux_node::ptr target, Cell cell) -> Snowfall\n"
+ "\n"
+ "Snowfall(cmf::water::flux_node::ptr target, cmf::upslope::Cell &cell)\n"
+ "\n"
+ ""},
{ (char *)"delete_Snowfall", (PyCFunction)_wrap_delete_Snowfall, METH_O, (char *)"delete_Snowfall(Snowfall self)"},
{ (char *)"Snowfall_swigregister", Snowfall_swigregister, METH_VARARGS, NULL},
{ (char *)"Snowfall_swiginit", Snowfall_swiginit, METH_VARARGS, NULL},
- { (char *)"new_MatrixInfiltration", (PyCFunction) _wrap_new_MatrixInfiltration, METH_VARARGS | METH_KEYWORDS, (char *)"new_MatrixInfiltration(cmf::upslope::SoilLayer::ptr soilwater, cmf::water::flux_node::ptr surfacewater) -> MatrixInfiltration"},
+ { (char *)"new_MatrixInfiltration", (PyCFunction) _wrap_new_MatrixInfiltration, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_MatrixInfiltration(cmf::upslope::SoilLayer::ptr soilwater, cmf::water::flux_node::ptr surfacewater) -> MatrixInfiltration\n"
+ "\n"
+ "MatrixInfiltration(cmf::upslope::SoilLayer::ptr soilwater,\n"
+ "cmf::water::flux_node::ptr surfacewater) \n"
+ ""},
{ (char *)"MatrixInfiltration_use_for_cell", (PyCFunction) _wrap_MatrixInfiltration_use_for_cell, METH_VARARGS | METH_KEYWORDS, (char *)"MatrixInfiltration_use_for_cell(Cell c)"},
{ (char *)"delete_MatrixInfiltration", (PyCFunction)_wrap_delete_MatrixInfiltration, METH_O, (char *)"delete_MatrixInfiltration(MatrixInfiltration self)"},
{ (char *)"MatrixInfiltration_swigregister", MatrixInfiltration_swigregister, METH_VARARGS, NULL},
{ (char *)"MatrixInfiltration_swiginit", MatrixInfiltration_swiginit, METH_VARARGS, NULL},
- { (char *)"new_GreenAmptInfiltration", (PyCFunction) _wrap_new_GreenAmptInfiltration, METH_VARARGS | METH_KEYWORDS, (char *)"new_GreenAmptInfiltration(cmf::upslope::SoilLayer::ptr soilwater, cmf::water::flux_node::ptr surfacewater) -> GreenAmptInfiltration"},
+ { (char *)"new_GreenAmptInfiltration", (PyCFunction) _wrap_new_GreenAmptInfiltration, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_GreenAmptInfiltration(cmf::upslope::SoilLayer::ptr soilwater, cmf::water::flux_node::ptr surfacewater) -> GreenAmptInfiltration\n"
+ "\n"
+ "GreenAmptInfiltration(cmf::upslope::SoilLayer::ptr soilwater,\n"
+ "cmf::water::flux_node::ptr surfacewater) \n"
+ ""},
{ (char *)"GreenAmptInfiltration_use_for_cell", (PyCFunction) _wrap_GreenAmptInfiltration_use_for_cell, METH_VARARGS | METH_KEYWORDS, (char *)"GreenAmptInfiltration_use_for_cell(Cell c)"},
{ (char *)"delete_GreenAmptInfiltration", (PyCFunction)_wrap_delete_GreenAmptInfiltration, METH_O, (char *)"delete_GreenAmptInfiltration(GreenAmptInfiltration self)"},
{ (char *)"GreenAmptInfiltration_swigregister", GreenAmptInfiltration_swigregister, METH_VARARGS, NULL},
{ (char *)"GreenAmptInfiltration_swiginit", GreenAmptInfiltration_swiginit, METH_VARARGS, NULL},
{ (char *)"SimpleInfiltration_W0_set", _wrap_SimpleInfiltration_W0_set, METH_VARARGS, (char *)"SimpleInfiltration_W0_set(SimpleInfiltration self, real W0)"},
{ (char *)"SimpleInfiltration_W0_get", (PyCFunction)_wrap_SimpleInfiltration_W0_get, METH_O, (char *)"SimpleInfiltration_W0_get(SimpleInfiltration self) -> real"},
- { (char *)"new_SimpleInfiltration", (PyCFunction) _wrap_new_SimpleInfiltration, METH_VARARGS | METH_KEYWORDS, (char *)"new_SimpleInfiltration(cmf::upslope::SoilLayer::ptr soilwater, cmf::water::flux_node::ptr surfacewater, real W0=0.9) -> SimpleInfiltration"},
+ { (char *)"new_SimpleInfiltration", (PyCFunction) _wrap_new_SimpleInfiltration, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_SimpleInfiltration(cmf::upslope::SoilLayer::ptr soilwater, cmf::water::flux_node::ptr surfacewater, real W0=0.9) -> SimpleInfiltration\n"
+ "\n"
+ "SimpleInfiltration(cmf::upslope::SoilLayer::ptr soilwater,\n"
+ "cmf::water::flux_node::ptr surfacewater, real W0=0.9)\n"
+ "\n"
+ "Creates the connection between surfacewater and first soil layer.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "soilwater: the infiltration target\n"
+ "\n"
+ "surfacewater: the infiltration source\n"
+ "\n"
+ "W0: the 50% saturation value \n"
+ ""},
{ (char *)"SimpleInfiltration_use_for_cell", (PyCFunction) _wrap_SimpleInfiltration_use_for_cell, METH_VARARGS | METH_KEYWORDS, (char *)"SimpleInfiltration_use_for_cell(Cell c)"},
{ (char *)"delete_SimpleInfiltration", (PyCFunction)_wrap_delete_SimpleInfiltration, METH_O, (char *)"delete_SimpleInfiltration(SimpleInfiltration self)"},
{ (char *)"SimpleInfiltration_swigregister", SimpleInfiltration_swigregister, METH_VARARGS, NULL},
{ (char *)"SimpleInfiltration_swiginit", SimpleInfiltration_swiginit, METH_VARARGS, NULL},
{ (char *)"SWATPercolation_use_for_cell", (PyCFunction) _wrap_SWATPercolation_use_for_cell, METH_VARARGS | METH_KEYWORDS, (char *)"SWATPercolation_use_for_cell(Cell cell, bool no_override=True)"},
- { (char *)"new_SWATPercolation", (PyCFunction) _wrap_new_SWATPercolation, METH_VARARGS | METH_KEYWORDS, (char *)"new_SWATPercolation(cmf::upslope::SoilLayer::ptr upperLayer, cmf::upslope::SoilLayer::ptr lowerLayer) -> SWATPercolation"},
+ { (char *)"new_SWATPercolation", (PyCFunction) _wrap_new_SWATPercolation, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_SWATPercolation(cmf::upslope::SoilLayer::ptr upperLayer, cmf::upslope::SoilLayer::ptr lowerLayer) -> SWATPercolation\n"
+ "\n"
+ "SWATPercolation(cmf::upslope::SoilLayer::ptr upperLayer,\n"
+ "cmf::upslope::SoilLayer::ptr lowerLayer) \n"
+ ""},
{ (char *)"delete_SWATPercolation", (PyCFunction)_wrap_delete_SWATPercolation, METH_O, (char *)"delete_SWATPercolation(SWATPercolation self)"},
{ (char *)"SWATPercolation_swigregister", SWATPercolation_swigregister, METH_VARARGS, NULL},
{ (char *)"SWATPercolation_swiginit", SWATPercolation_swiginit, METH_VARARGS, NULL},
- { (char *)"new_Richards", (PyCFunction) _wrap_new_Richards, METH_VARARGS | METH_KEYWORDS, (char *)"new_Richards(cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right) -> Richards"},
+ { (char *)"new_Richards", (PyCFunction) _wrap_new_Richards, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_Richards(cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right) -> Richards\n"
+ "\n"
+ "Richards(cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr\n"
+ "right)\n"
+ "\n"
+ "Creates a Richards equation connection between two soil layers (left\n"
+ "and right, rather top and bottom) of the same cell. \n"
+ ""},
{ (char *)"Richards_use_for_cell", (PyCFunction) _wrap_Richards_use_for_cell, METH_VARARGS | METH_KEYWORDS, (char *)"Richards_use_for_cell(Cell cell, bool no_override=True)"},
{ (char *)"delete_Richards", (PyCFunction)_wrap_delete_Richards, METH_O, (char *)"delete_Richards(Richards self)"},
{ (char *)"Richards_swigregister", Richards_swigregister, METH_VARARGS, NULL},
{ (char *)"Richards_swiginit", Richards_swiginit, METH_VARARGS, NULL},
- { (char *)"new_SimplRichards", (PyCFunction) _wrap_new_SimplRichards, METH_VARARGS | METH_KEYWORDS, (char *)"new_SimplRichards(cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right) -> SimplRichards"},
+ { (char *)"new_SimplRichards", (PyCFunction) _wrap_new_SimplRichards, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_SimplRichards(cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right) -> SimplRichards\n"
+ "\n"
+ "SimplRichards(cmf::upslope::SoilLayer::ptr left,\n"
+ "cmf::water::flux_node::ptr right) \n"
+ ""},
{ (char *)"SimplRichards_use_for_cell", (PyCFunction) _wrap_SimplRichards_use_for_cell, METH_VARARGS | METH_KEYWORDS, (char *)"SimplRichards_use_for_cell(Cell cell, bool no_override=True)"},
{ (char *)"delete_SimplRichards", (PyCFunction)_wrap_delete_SimplRichards, METH_O, (char *)"delete_SimplRichards(SimplRichards self)"},
{ (char *)"SimplRichards_swigregister", SimplRichards_swigregister, METH_VARARGS, NULL},
{ (char *)"SimplRichards_swiginit", SimplRichards_swiginit, METH_VARARGS, NULL},
- { (char *)"new_FreeDrainagePercolation", (PyCFunction) _wrap_new_FreeDrainagePercolation, METH_VARARGS | METH_KEYWORDS, (char *)"new_FreeDrainagePercolation(cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right) -> FreeDrainagePercolation"},
+ { (char *)"new_FreeDrainagePercolation", (PyCFunction) _wrap_new_FreeDrainagePercolation, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_FreeDrainagePercolation(cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right) -> FreeDrainagePercolation\n"
+ "\n"
+ "FreeDrainagePercolation(cmf::upslope::SoilLayer::ptr left,\n"
+ "cmf::water::flux_node::ptr right) \n"
+ ""},
{ (char *)"delete_FreeDrainagePercolation", (PyCFunction)_wrap_delete_FreeDrainagePercolation, METH_O, (char *)"delete_FreeDrainagePercolation(FreeDrainagePercolation self)"},
{ (char *)"FreeDrainagePercolation_swigregister", FreeDrainagePercolation_swigregister, METH_VARARGS, NULL},
{ (char *)"FreeDrainagePercolation_swiginit", FreeDrainagePercolation_swiginit, METH_VARARGS, NULL},
@@ -76302,14 +80219,73 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"LayerBypass_w0_get", (PyCFunction)_wrap_LayerBypass_w0_get, METH_O, (char *)"LayerBypass_w0_get(LayerBypass self) -> real"},
{ (char *)"LayerBypass_beta_set", _wrap_LayerBypass_beta_set, METH_VARARGS, (char *)"LayerBypass_beta_set(LayerBypass self, real beta)"},
{ (char *)"LayerBypass_beta_get", (PyCFunction)_wrap_LayerBypass_beta_get, METH_O, (char *)"LayerBypass_beta_get(LayerBypass self) -> real"},
- { (char *)"LayerBypass_K", (PyCFunction) _wrap_LayerBypass_K, METH_VARARGS | METH_KEYWORDS, (char *)"LayerBypass_K(LayerBypass self, real w) -> real"},
- { (char *)"new_LayerBypass", (PyCFunction) _wrap_new_LayerBypass, METH_VARARGS | METH_KEYWORDS, (char *)"new_LayerBypass(cmf::water::flux_node::ptr left, cmf::upslope::SoilLayer::ptr right, real Kmax=100., real w0=0.0, real beta=1.0) -> LayerBypass"},
+ { (char *)"LayerBypass_K", (PyCFunction) _wrap_LayerBypass_K, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "LayerBypass_K(LayerBypass self, real w) -> real\n"
+ "\n"
+ "real K(real w)\n"
+ "\n"
+ "the actual crack conductivity\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "w: the wetness of the target layer \n"
+ ""},
+ { (char *)"new_LayerBypass", (PyCFunction) _wrap_new_LayerBypass, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_LayerBypass(cmf::water::flux_node::ptr left, cmf::upslope::SoilLayer::ptr right, real Kmax=100., real w0=0.0, real beta=1.0) -> LayerBypass\n"
+ "\n"
+ "LayerBypass(cmf::water::flux_node::ptr left,\n"
+ "cmf::upslope::SoilLayer::ptr right, real Kmax=100., real w0=0.0, real\n"
+ "beta=1.0)\n"
+ "\n"
+ "Creates a layer bypass connection.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "left: The source of the flux, usually the surfacewater of the cell\n"
+ "\n"
+ "right: The target soil layer\n"
+ "\n"
+ "Kmax: maximum conductivity of the cracks in m/day\n"
+ "\n"
+ "w0: is the actual wetness of the target layer\n"
+ "\n"
+ "beta: is an empirical shape parameter of the crack size/wetness\n"
+ "relation \n"
+ ""},
{ (char *)"delete_LayerBypass", (PyCFunction)_wrap_delete_LayerBypass, METH_O, (char *)"delete_LayerBypass(LayerBypass self)"},
{ (char *)"LayerBypass_swigregister", LayerBypass_swigregister, METH_VARARGS, NULL},
{ (char *)"LayerBypass_swiginit", LayerBypass_swiginit, METH_VARARGS, NULL},
- { (char *)"RootUptakeStessFunction_Tact", (PyCFunction) _wrap_RootUptakeStessFunction_Tact, METH_VARARGS | METH_KEYWORDS, (char *)"RootUptakeStessFunction_Tact(RootUptakeStessFunction self, stressedET connection, real Tpot) -> real"},
- { (char *)"RootUptakeStessFunction_copy", (PyCFunction)_wrap_RootUptakeStessFunction_copy, METH_O, (char *)"RootUptakeStessFunction_copy(RootUptakeStessFunction self) -> RootUptakeStessFunction"},
- { (char *)"RootUptakeStessFunction_to_string", (PyCFunction)_wrap_RootUptakeStessFunction_to_string, METH_O, (char *)"RootUptakeStessFunction_to_string(RootUptakeStessFunction self) -> std::string"},
+ { (char *)"RootUptakeStessFunction_Tact", (PyCFunction) _wrap_RootUptakeStessFunction_Tact, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "RootUptakeStessFunction_Tact(RootUptakeStessFunction self, stressedET connection, real Tpot) -> real\n"
+ "\n"
+ "virtual real Tact(const stressedET *connection, real Tpot) const =0\n"
+ "\n"
+ "Calculates the water stress for a layer.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "connection: The stressedET connection this stress function belongs to\n"
+ "\n"
+ "Tpot: Potential Transpiration in mm/day (for the full profile)\n"
+ "\n"
+ "Actual flux from layer in m3/day \n"
+ ""},
+ { (char *)"RootUptakeStessFunction_copy", (PyCFunction)_wrap_RootUptakeStessFunction_copy, METH_O, (char *)"\n"
+ "RootUptakeStessFunction_copy(RootUptakeStessFunction self) -> RootUptakeStessFunction\n"
+ "\n"
+ "virtual cmf::upslope::ET::RootUptakeStessFunction* copy() const =0\n"
+ "\n"
+ "Creates a new copy of this wetness. \n"
+ ""},
+ { (char *)"RootUptakeStessFunction_to_string", (PyCFunction)_wrap_RootUptakeStessFunction_to_string, METH_O, (char *)"\n"
+ "RootUptakeStessFunction_to_string(RootUptakeStessFunction self) -> std::string\n"
+ "\n"
+ "virtual\n"
+ "std::string to_string() const =0 \n"
+ ""},
{ (char *)"delete_RootUptakeStessFunction", (PyCFunction)_wrap_delete_RootUptakeStessFunction, METH_O, (char *)"delete_RootUptakeStessFunction(RootUptakeStessFunction self)"},
{ (char *)"RootUptakeStessFunction_swigregister", RootUptakeStessFunction_swigregister, METH_VARARGS, NULL},
{ (char *)"SuctionStress_P0_set", _wrap_SuctionStress_P0_set, METH_VARARGS, (char *)"SuctionStress_P0_set(SuctionStress self, real P0)"},
@@ -76323,8 +80299,16 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"new_SuctionStress", _wrap_new_SuctionStress, METH_VARARGS, (char *)"\n"
"SuctionStress(real P0=1e308, real P1=1e307, real P2=-5, real P3=-160)\n"
"new_SuctionStress(SuctionStress other) -> SuctionStress\n"
+ "\n"
+ "SuctionStress(const SuctionStress &other) \n"
+ ""},
+ { (char *)"SuctionStress_copy", (PyCFunction)_wrap_SuctionStress_copy, METH_O, (char *)"\n"
+ "SuctionStress_copy(SuctionStress self) -> SuctionStress\n"
+ "\n"
+ "cmf::upslope::ET::SuctionStress* copy() const\n"
+ "\n"
+ "Creates a new copy of this wetness. \n"
""},
- { (char *)"SuctionStress_copy", (PyCFunction)_wrap_SuctionStress_copy, METH_O, (char *)"SuctionStress_copy(SuctionStress self) -> SuctionStress"},
{ (char *)"delete_SuctionStress", (PyCFunction)_wrap_delete_SuctionStress, METH_O, (char *)"delete_SuctionStress(SuctionStress self)"},
{ (char *)"SuctionStress_swigregister", SuctionStress_swigregister, METH_VARARGS, NULL},
{ (char *)"SuctionStress_swiginit", SuctionStress_swiginit, METH_VARARGS, NULL},
@@ -76332,8 +80316,21 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"ContentStress_theta_d_get", (PyCFunction)_wrap_ContentStress_theta_d_get, METH_O, (char *)"ContentStress_theta_d_get(ContentStress self) -> real"},
{ (char *)"ContentStress_theta_w_set", _wrap_ContentStress_theta_w_set, METH_VARARGS, (char *)"ContentStress_theta_w_set(ContentStress self, real theta_w)"},
{ (char *)"ContentStress_theta_w_get", (PyCFunction)_wrap_ContentStress_theta_w_get, METH_O, (char *)"ContentStress_theta_w_get(ContentStress self) -> real"},
- { (char *)"ContentStress_copy", (PyCFunction)_wrap_ContentStress_copy, METH_O, (char *)"ContentStress_copy(ContentStress self) -> ContentStress"},
- { (char *)"new_ContentStress", (PyCFunction) _wrap_new_ContentStress, METH_VARARGS | METH_KEYWORDS, (char *)"new_ContentStress(real theta_d=-1, real theta_w=-1) -> ContentStress"},
+ { (char *)"ContentStress_copy", (PyCFunction)_wrap_ContentStress_copy, METH_O, (char *)"\n"
+ "ContentStress_copy(ContentStress self) -> ContentStress\n"
+ "\n"
+ "cmf::upslope::ET::ContentStress* copy() const\n"
+ "\n"
+ "Creates a new copy of this wetness. \n"
+ ""},
+ { (char *)"new_ContentStress", (PyCFunction) _wrap_new_ContentStress, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_ContentStress(real theta_d=-1, real theta_w=-1) -> ContentStress\n"
+ "\n"
+ "ContentStress(real theta_d=-1, real theta_w=-1)\n"
+ "\n"
+ "Creates a new ContentStress for critical water content theta_d in vol\n"
+ "Water/vol Soil and wilting point theta_w. \n"
+ ""},
{ (char *)"delete_ContentStress", (PyCFunction)_wrap_delete_ContentStress, METH_O, (char *)"delete_ContentStress(ContentStress self)"},
{ (char *)"ContentStress_swigregister", ContentStress_swigregister, METH_VARARGS, NULL},
{ (char *)"ContentStress_swiginit", ContentStress_swiginit, METH_VARARGS, NULL},
@@ -76344,75 +80341,205 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"new_VolumeStress", _wrap_new_VolumeStress, METH_VARARGS, (char *)"\n"
"VolumeStress(real V1, real V0)\n"
"new_VolumeStress(VolumeStress other) -> VolumeStress\n"
+ "\n"
+ "VolumeStress(const VolumeStress &other) \n"
+ ""},
+ { (char *)"VolumeStress_copy", (PyCFunction)_wrap_VolumeStress_copy, METH_O, (char *)"\n"
+ "VolumeStress_copy(VolumeStress self) -> VolumeStress\n"
+ "\n"
+ "cmf::upslope::ET::VolumeStress* copy() const\n"
+ "\n"
+ "Creates a new copy of this wetness. \n"
""},
- { (char *)"VolumeStress_copy", (PyCFunction)_wrap_VolumeStress_copy, METH_O, (char *)"VolumeStress_copy(VolumeStress self) -> VolumeStress"},
{ (char *)"delete_VolumeStress", (PyCFunction)_wrap_delete_VolumeStress, METH_O, (char *)"delete_VolumeStress(VolumeStress self)"},
{ (char *)"VolumeStress_swigregister", VolumeStress_swigregister, METH_VARARGS, NULL},
{ (char *)"VolumeStress_swiginit", VolumeStress_swiginit, METH_VARARGS, NULL},
- { (char *)"new_log_wind_profile", (PyCFunction) _wrap_new_log_wind_profile, METH_VARARGS | METH_KEYWORDS, (char *)"new_log_wind_profile(Cell _cell) -> log_wind_profile"},
+ { (char *)"new_log_wind_profile", (PyCFunction) _wrap_new_log_wind_profile, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_log_wind_profile(Cell _cell) -> log_wind_profile\n"
+ "\n"
+ "log_wind_profile(cmf::upslope::Cell &_cell) \n"
+ ""},
{ (char *)"delete_log_wind_profile", (PyCFunction)_wrap_delete_log_wind_profile, METH_O, (char *)"delete_log_wind_profile(log_wind_profile self)"},
{ (char *)"log_wind_profile_swigregister", log_wind_profile_swigregister, METH_VARARGS, NULL},
{ (char *)"log_wind_profile_swiginit", log_wind_profile_swiginit, METH_VARARGS, NULL},
- { (char *)"transpiration_method_transp_from_layer", (PyCFunction) _wrap_transpiration_method_transp_from_layer, METH_VARARGS | METH_KEYWORDS, (char *)"transpiration_method_transp_from_layer(transpiration_method self, cmf::upslope::SoilLayer::ptr arg3, Time t) -> double"},
+ { (char *)"transpiration_method_transp_from_layer", (PyCFunction) _wrap_transpiration_method_transp_from_layer, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "transpiration_method_transp_from_layer(transpiration_method self, cmf::upslope::SoilLayer::ptr arg3, Time t) -> double\n"
+ "\n"
+ "virtual\n"
+ "double transp_from_layer(cmf::upslope::SoilLayer::ptr, cmf::math::Time\n"
+ "t)=0\n"
+ "\n"
+ "returns the transpiration rate from one layer in m3/day \n"
+ ""},
{ (char *)"delete_transpiration_method", (PyCFunction)_wrap_delete_transpiration_method, METH_O, (char *)"delete_transpiration_method(transpiration_method self)"},
{ (char *)"transpiration_method_swigregister", transpiration_method_swigregister, METH_VARARGS, NULL},
- { (char *)"soil_evaporation_method_evap_from_layer", (PyCFunction) _wrap_soil_evaporation_method_evap_from_layer, METH_VARARGS | METH_KEYWORDS, (char *)"soil_evaporation_method_evap_from_layer(soil_evaporation_method self, cmf::upslope::SoilLayer::ptr arg3, Time t) -> double"},
+ { (char *)"soil_evaporation_method_evap_from_layer", (PyCFunction) _wrap_soil_evaporation_method_evap_from_layer, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "soil_evaporation_method_evap_from_layer(soil_evaporation_method self, cmf::upslope::SoilLayer::ptr arg3, Time t) -> double\n"
+ "\n"
+ "virtual\n"
+ "double evap_from_layer(cmf::upslope::SoilLayer::ptr, cmf::math::Time\n"
+ "t)=0\n"
+ "\n"
+ "returns the soil evaporation rate from one layer in m3/day \n"
+ ""},
{ (char *)"delete_soil_evaporation_method", (PyCFunction)_wrap_delete_soil_evaporation_method, METH_O, (char *)"delete_soil_evaporation_method(soil_evaporation_method self)"},
{ (char *)"soil_evaporation_method_swigregister", soil_evaporation_method_swigregister, METH_VARARGS, NULL},
- { (char *)"surface_water_evaporation_method_evap_from_openwater", (PyCFunction) _wrap_surface_water_evaporation_method_evap_from_openwater, METH_VARARGS | METH_KEYWORDS, (char *)"surface_water_evaporation_method_evap_from_openwater(surface_water_evaporation_method self, cmf::river::OpenWaterStorage::ptr arg3, Time arg4) -> double"},
+ { (char *)"surface_water_evaporation_method_evap_from_openwater", (PyCFunction) _wrap_surface_water_evaporation_method_evap_from_openwater, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "surface_water_evaporation_method_evap_from_openwater(surface_water_evaporation_method self, cmf::river::OpenWaterStorage::ptr arg3, Time arg4) -> double\n"
+ "\n"
+ "virtual double\n"
+ "evap_from_openwater(cmf::river::OpenWaterStorage::ptr,\n"
+ "cmf::math::Time)=0 \n"
+ ""},
{ (char *)"delete_surface_water_evaporation_method", (PyCFunction)_wrap_delete_surface_water_evaporation_method, METH_O, (char *)"delete_surface_water_evaporation_method(surface_water_evaporation_method self)"},
{ (char *)"surface_water_evaporation_method_swigregister", surface_water_evaporation_method_swigregister, METH_VARARGS, NULL},
- { (char *)"canopy_evaporation_method_evap_from_canopy", (PyCFunction) _wrap_canopy_evaporation_method_evap_from_canopy, METH_VARARGS | METH_KEYWORDS, (char *)"canopy_evaporation_method_evap_from_canopy(canopy_evaporation_method self, cmf::water::WaterStorage::ptr arg3, Time arg4) -> double"},
+ { (char *)"canopy_evaporation_method_evap_from_canopy", (PyCFunction) _wrap_canopy_evaporation_method_evap_from_canopy, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "canopy_evaporation_method_evap_from_canopy(canopy_evaporation_method self, cmf::water::WaterStorage::ptr arg3, Time arg4) -> double\n"
+ "\n"
+ "virtual double evap_from_canopy(cmf::water::WaterStorage::ptr,\n"
+ "cmf::math::Time)=0 \n"
+ ""},
{ (char *)"delete_canopy_evaporation_method", (PyCFunction)_wrap_delete_canopy_evaporation_method, METH_O, (char *)"delete_canopy_evaporation_method(canopy_evaporation_method self)"},
{ (char *)"canopy_evaporation_method_swigregister", canopy_evaporation_method_swigregister, METH_VARARGS, NULL},
- { (char *)"snow_evaporation_method_evap_from_snow", (PyCFunction) _wrap_snow_evaporation_method_evap_from_snow, METH_VARARGS | METH_KEYWORDS, (char *)"snow_evaporation_method_evap_from_snow(snow_evaporation_method self, cmf::water::WaterStorage::ptr snow, Time t) -> double"},
+ { (char *)"snow_evaporation_method_evap_from_snow", (PyCFunction) _wrap_snow_evaporation_method_evap_from_snow, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "snow_evaporation_method_evap_from_snow(snow_evaporation_method self, cmf::water::WaterStorage::ptr snow, Time t) -> double\n"
+ "\n"
+ "virtual\n"
+ "double evap_from_snow(cmf::water::WaterStorage::ptr snow,\n"
+ "cmf::math::Time t)=0 \n"
+ ""},
{ (char *)"delete_snow_evaporation_method", (PyCFunction)_wrap_delete_snow_evaporation_method, METH_O, (char *)"delete_snow_evaporation_method(snow_evaporation_method self)"},
{ (char *)"snow_evaporation_method_swigregister", snow_evaporation_method_swigregister, METH_VARARGS, NULL},
- { (char *)"new_transpiration", (PyCFunction) _wrap_new_transpiration, METH_VARARGS | METH_KEYWORDS, (char *)"new_transpiration(cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target, std::shared_ptr< cmf::upslope::ET::transpiration_method > _method, std::string method_name) -> transpiration"},
+ { (char *)"new_transpiration", (PyCFunction) _wrap_new_transpiration, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_transpiration(cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target, std::shared_ptr< cmf::upslope::ET::transpiration_method > _method, std::string method_name) -> transpiration\n"
+ "\n"
+ "transpiration(cmf::upslope::SoilLayer::ptr source,\n"
+ "cmf::water::flux_node::ptr ET_target, std::shared_ptr<\n"
+ "transpiration_method > _method, std::string method_name) \n"
+ ""},
{ (char *)"delete_transpiration", (PyCFunction)_wrap_delete_transpiration, METH_O, (char *)"delete_transpiration(transpiration self)"},
{ (char *)"transpiration_swigregister", transpiration_swigregister, METH_VARARGS, NULL},
{ (char *)"transpiration_swiginit", transpiration_swiginit, METH_VARARGS, NULL},
- { (char *)"new_soil_evaporation", (PyCFunction) _wrap_new_soil_evaporation, METH_VARARGS | METH_KEYWORDS, (char *)"new_soil_evaporation(cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target, std::shared_ptr< cmf::upslope::ET::soil_evaporation_method > _method, std::string method_name) -> soil_evaporation"},
+ { (char *)"new_soil_evaporation", (PyCFunction) _wrap_new_soil_evaporation, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_soil_evaporation(cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target, std::shared_ptr< cmf::upslope::ET::soil_evaporation_method > _method, std::string method_name) -> soil_evaporation\n"
+ "\n"
+ "soil_evaporation(cmf::upslope::SoilLayer::ptr source,\n"
+ "cmf::water::flux_node::ptr ET_target, std::shared_ptr<\n"
+ "soil_evaporation_method > _method, std::string method_name) \n"
+ ""},
{ (char *)"delete_soil_evaporation", (PyCFunction)_wrap_delete_soil_evaporation, METH_O, (char *)"delete_soil_evaporation(soil_evaporation self)"},
{ (char *)"soil_evaporation_swigregister", soil_evaporation_swigregister, METH_VARARGS, NULL},
{ (char *)"soil_evaporation_swiginit", soil_evaporation_swiginit, METH_VARARGS, NULL},
- { (char *)"new_canopy_evaporation", (PyCFunction) _wrap_new_canopy_evaporation, METH_VARARGS | METH_KEYWORDS, (char *)"new_canopy_evaporation(cmf::water::WaterStorage::ptr source, cmf::water::flux_node::ptr ET_target, std::shared_ptr< cmf::upslope::ET::canopy_evaporation_method > _method, std::string method_name) -> canopy_evaporation"},
+ { (char *)"new_canopy_evaporation", (PyCFunction) _wrap_new_canopy_evaporation, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_canopy_evaporation(cmf::water::WaterStorage::ptr source, cmf::water::flux_node::ptr ET_target, std::shared_ptr< cmf::upslope::ET::canopy_evaporation_method > _method, std::string method_name) -> canopy_evaporation\n"
+ "\n"
+ "canopy_evaporation(cmf::water::WaterStorage::ptr source,\n"
+ "cmf::water::flux_node::ptr ET_target, std::shared_ptr<\n"
+ "canopy_evaporation_method > _method, std::string method_name) \n"
+ ""},
{ (char *)"delete_canopy_evaporation", (PyCFunction)_wrap_delete_canopy_evaporation, METH_O, (char *)"delete_canopy_evaporation(canopy_evaporation self)"},
{ (char *)"canopy_evaporation_swigregister", canopy_evaporation_swigregister, METH_VARARGS, NULL},
{ (char *)"canopy_evaporation_swiginit", canopy_evaporation_swiginit, METH_VARARGS, NULL},
- { (char *)"new_snow_evaporation", (PyCFunction) _wrap_new_snow_evaporation, METH_VARARGS | METH_KEYWORDS, (char *)"new_snow_evaporation(cmf::water::WaterStorage::ptr source, cmf::water::flux_node::ptr ET_target, std::shared_ptr< cmf::upslope::ET::snow_evaporation_method > _method, std::string method_name) -> snow_evaporation"},
+ { (char *)"new_snow_evaporation", (PyCFunction) _wrap_new_snow_evaporation, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_snow_evaporation(cmf::water::WaterStorage::ptr source, cmf::water::flux_node::ptr ET_target, std::shared_ptr< cmf::upslope::ET::snow_evaporation_method > _method, std::string method_name) -> snow_evaporation\n"
+ "\n"
+ "snow_evaporation(cmf::water::WaterStorage::ptr source,\n"
+ "cmf::water::flux_node::ptr ET_target, std::shared_ptr<\n"
+ "snow_evaporation_method > _method, std::string method_name) \n"
+ ""},
{ (char *)"delete_snow_evaporation", (PyCFunction)_wrap_delete_snow_evaporation, METH_O, (char *)"delete_snow_evaporation(snow_evaporation self)"},
{ (char *)"snow_evaporation_swigregister", snow_evaporation_swigregister, METH_VARARGS, NULL},
{ (char *)"snow_evaporation_swiginit", snow_evaporation_swiginit, METH_VARARGS, NULL},
- { (char *)"new_surface_water_evaporation", (PyCFunction) _wrap_new_surface_water_evaporation, METH_VARARGS | METH_KEYWORDS, (char *)"new_surface_water_evaporation(cmf::river::OpenWaterStorage::ptr source, cmf::water::flux_node::ptr ET_target, std::shared_ptr< cmf::upslope::ET::surface_water_evaporation_method > _method, std::string method_name) -> surface_water_evaporation"},
+ { (char *)"new_surface_water_evaporation", (PyCFunction) _wrap_new_surface_water_evaporation, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_surface_water_evaporation(cmf::river::OpenWaterStorage::ptr source, cmf::water::flux_node::ptr ET_target, std::shared_ptr< cmf::upslope::ET::surface_water_evaporation_method > _method, std::string method_name) -> surface_water_evaporation\n"
+ "\n"
+ "surface_water_evaporation(cmf::river::OpenWaterStorage::ptr source,\n"
+ "cmf::water::flux_node::ptr ET_target, std::shared_ptr<\n"
+ "surface_water_evaporation_method > _method, std::string method_name)\n"
+ "\n"
+ ""},
{ (char *)"delete_surface_water_evaporation", (PyCFunction)_wrap_delete_surface_water_evaporation, METH_O, (char *)"delete_surface_water_evaporation(surface_water_evaporation self)"},
{ (char *)"surface_water_evaporation_swigregister", surface_water_evaporation_swigregister, METH_VARARGS, NULL},
{ (char *)"surface_water_evaporation_swiginit", surface_water_evaporation_swiginit, METH_VARARGS, NULL},
{ (char *)"PenmanMonteith", _wrap_PenmanMonteith, METH_VARARGS, (char *)"\n"
"PenmanMonteith(real Rn, real ra, real rs, real T, real vap_press_deficit) -> real\n"
"PenmanMonteith(Weather A, Vegetation veg, double h) -> real\n"
+ "\n"
+ "real\n"
+ "cmf::upslope::ET::PenmanMonteith(cmf::atmosphere::Weather A, const\n"
+ "cmf::upslope::vegetation::Vegetation &veg, double h)\n"
+ "\n"
+ "Returns the potential ET after Penman-Monteith using some\n"
+ "simplifications for a weather and a vegetation object.\n"
+ "\n"
+ "aerodynamic and surface resistances, and a vapor pressure deficit\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "A: Current weather\n"
+ "\n"
+ "veg: Vegetation data\n"
+ "\n"
+ "h: Height above sea level in m (for air pressure estimation) \n"
+ ""},
+ { (char *)"stressedET_set_stressfunction", (PyCFunction) _wrap_stressedET_set_stressfunction, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "stressedET_set_stressfunction(stressedET self, RootUptakeStessFunction stressfunction)\n"
+ "\n"
+ "void\n"
+ "set_stressfunction(const RootUptakeStessFunction &stressfunction)\n"
+ "\n"
+ "Sets the stress function to limit water uptake. \n"
+ ""},
+ { (char *)"stressedET_get_layer", (PyCFunction)_wrap_stressedET_get_layer, METH_O, (char *)"\n"
+ "stressedET_get_layer(stressedET self) -> cmf::upslope::SoilLayer::ptr\n"
+ "\n"
+ "SoilLayer::ptr get_layer() const \n"
+ ""},
+ { (char *)"stressedET_ETpot", (PyCFunction) _wrap_stressedET_ETpot, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "stressedET_ETpot(stressedET self, Time t) -> real\n"
+ "\n"
+ "virtual\n"
+ "real ETpot(cmf::math::Time t) const \n"
""},
- { (char *)"stressedET_set_stressfunction", (PyCFunction) _wrap_stressedET_set_stressfunction, METH_VARARGS | METH_KEYWORDS, (char *)"stressedET_set_stressfunction(stressedET self, RootUptakeStessFunction stressfunction)"},
- { (char *)"stressedET_get_layer", (PyCFunction)_wrap_stressedET_get_layer, METH_O, (char *)"stressedET_get_layer(stressedET self) -> cmf::upslope::SoilLayer::ptr"},
- { (char *)"stressedET_ETpot", (PyCFunction) _wrap_stressedET_ETpot, METH_VARARGS | METH_KEYWORDS, (char *)"stressedET_ETpot(stressedET self, Time t) -> real"},
{ (char *)"delete_stressedET", (PyCFunction)_wrap_delete_stressedET, METH_O, (char *)"delete_stressedET(stressedET self)"},
{ (char *)"stressedET_swigregister", stressedET_swigregister, METH_VARARGS, NULL},
{ (char *)"constantETpot_ETpot_value_set", _wrap_constantETpot_ETpot_value_set, METH_VARARGS, (char *)"constantETpot_ETpot_value_set(constantETpot self, real ETpot_value)"},
{ (char *)"constantETpot_ETpot_value_get", (PyCFunction)_wrap_constantETpot_ETpot_value_get, METH_O, (char *)"constantETpot_ETpot_value_get(constantETpot self) -> real"},
- { (char *)"constantETpot_GetETpot", (PyCFunction) _wrap_constantETpot_GetETpot, METH_VARARGS | METH_KEYWORDS, (char *)"constantETpot_GetETpot(constantETpot self, Time t) -> real"},
- { (char *)"new_constantETpot", (PyCFunction) _wrap_new_constantETpot, METH_VARARGS | METH_KEYWORDS, (char *)"new_constantETpot(cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target, double constantETpot_value) -> constantETpot"},
+ { (char *)"constantETpot_GetETpot", (PyCFunction) _wrap_constantETpot_GetETpot, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "constantETpot_GetETpot(constantETpot self, Time t) -> real\n"
+ "\n"
+ "real GetETpot(cmf::math::Time t) const \n"
+ ""},
+ { (char *)"new_constantETpot", (PyCFunction) _wrap_new_constantETpot, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_constantETpot(cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target, double constantETpot_value) -> constantETpot\n"
+ "\n"
+ "constantETpot(cmf::upslope::SoilLayer::ptr source,\n"
+ "cmf::water::flux_node::ptr ET_target, double constantETpot_value) \n"
+ ""},
{ (char *)"delete_constantETpot", (PyCFunction)_wrap_delete_constantETpot, METH_O, (char *)"delete_constantETpot(constantETpot self)"},
{ (char *)"constantETpot_swigregister", constantETpot_swigregister, METH_VARARGS, NULL},
{ (char *)"constantETpot_swiginit", constantETpot_swiginit, METH_VARARGS, NULL},
{ (char *)"timeseriesETpot_ETpot_data_set", _wrap_timeseriesETpot_ETpot_data_set, METH_VARARGS, (char *)"timeseriesETpot_ETpot_data_set(timeseriesETpot self, timeseries ETpot_data)"},
{ (char *)"timeseriesETpot_ETpot_data_get", (PyCFunction)_wrap_timeseriesETpot_ETpot_data_get, METH_O, (char *)"timeseriesETpot_ETpot_data_get(timeseriesETpot self) -> timeseries"},
- { (char *)"new_timeseriesETpot", (PyCFunction) _wrap_new_timeseriesETpot, METH_VARARGS | METH_KEYWORDS, (char *)"new_timeseriesETpot(cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target, timeseries ETpot_values) -> timeseriesETpot"},
+ { (char *)"new_timeseriesETpot", (PyCFunction) _wrap_new_timeseriesETpot, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_timeseriesETpot(cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target, timeseries ETpot_values) -> timeseriesETpot\n"
+ "\n"
+ "timeseriesETpot(cmf::upslope::SoilLayer::ptr source,\n"
+ "cmf::water::flux_node::ptr ET_target, cmf::math::timeseries\n"
+ "ETpot_values) \n"
+ ""},
{ (char *)"delete_timeseriesETpot", (PyCFunction)_wrap_delete_timeseriesETpot, METH_O, (char *)"delete_timeseriesETpot(timeseriesETpot self)"},
{ (char *)"timeseriesETpot_swigregister", timeseriesETpot_swigregister, METH_VARARGS, NULL},
{ (char *)"timeseriesETpot_swiginit", timeseriesETpot_swiginit, METH_VARARGS, NULL},
{ (char *)"PenmanMonteithET_daily_set", _wrap_PenmanMonteithET_daily_set, METH_VARARGS, (char *)"PenmanMonteithET_daily_set(PenmanMonteithET self, bool daily)"},
{ (char *)"PenmanMonteithET_daily_get", (PyCFunction)_wrap_PenmanMonteithET_daily_get, METH_O, (char *)"PenmanMonteithET_daily_get(PenmanMonteithET self) -> bool"},
- { (char *)"new_PenmanMonteithET", (PyCFunction) _wrap_new_PenmanMonteithET, METH_VARARGS | METH_KEYWORDS, (char *)"new_PenmanMonteithET(cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target) -> PenmanMonteithET"},
+ { (char *)"new_PenmanMonteithET", (PyCFunction) _wrap_new_PenmanMonteithET, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_PenmanMonteithET(cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target) -> PenmanMonteithET\n"
+ "\n"
+ "PenmanMonteithET(cmf::upslope::SoilLayer::ptr source,\n"
+ "cmf::water::flux_node::ptr ET_target) \n"
+ ""},
{ (char *)"PenmanMonteithET_r_s", (PyCFunction) _wrap_PenmanMonteithET_r_s, METH_VARARGS | METH_KEYWORDS, (char *)"PenmanMonteithET_r_s(Vegetation veg) -> real"},
{ (char *)"PenmanMonteithET_r_a", (PyCFunction) _wrap_PenmanMonteithET_r_a, METH_VARARGS | METH_KEYWORDS, (char *)"PenmanMonteithET_r_a(Weather A, real veg_height) -> real"},
{ (char *)"PenmanMonteithET_use_for_cell", (PyCFunction) _wrap_PenmanMonteithET_use_for_cell, METH_VARARGS | METH_KEYWORDS, (char *)"PenmanMonteithET_use_for_cell(Cell cell)"},
@@ -76423,28 +80550,54 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"PriestleyTaylorET_daily_get", (PyCFunction)_wrap_PriestleyTaylorET_daily_get, METH_O, (char *)"PriestleyTaylorET_daily_get(PriestleyTaylorET self) -> bool"},
{ (char *)"PriestleyTaylorET_alpha_set", _wrap_PriestleyTaylorET_alpha_set, METH_VARARGS, (char *)"PriestleyTaylorET_alpha_set(PriestleyTaylorET self, real alpha)"},
{ (char *)"PriestleyTaylorET_alpha_get", (PyCFunction)_wrap_PriestleyTaylorET_alpha_get, METH_O, (char *)"PriestleyTaylorET_alpha_get(PriestleyTaylorET self) -> real"},
- { (char *)"new_PriestleyTaylorET", (PyCFunction) _wrap_new_PriestleyTaylorET, METH_VARARGS | METH_KEYWORDS, (char *)"new_PriestleyTaylorET(cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target, real alpha=1.26) -> PriestleyTaylorET"},
+ { (char *)"new_PriestleyTaylorET", (PyCFunction) _wrap_new_PriestleyTaylorET, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_PriestleyTaylorET(cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target, real alpha=1.26) -> PriestleyTaylorET\n"
+ "\n"
+ "PriestleyTaylorET(cmf::upslope::SoilLayer::ptr source,\n"
+ "cmf::water::flux_node::ptr ET_target, real alpha=1.26) \n"
+ ""},
{ (char *)"PriestleyTaylorET_use_for_cell", (PyCFunction) _wrap_PriestleyTaylorET_use_for_cell, METH_VARARGS | METH_KEYWORDS, (char *)"PriestleyTaylorET_use_for_cell(Cell cell)"},
{ (char *)"delete_PriestleyTaylorET", (PyCFunction)_wrap_delete_PriestleyTaylorET, METH_O, (char *)"delete_PriestleyTaylorET(PriestleyTaylorET self)"},
{ (char *)"PriestleyTaylorET_swigregister", PriestleyTaylorET_swigregister, METH_VARARGS, NULL},
{ (char *)"PriestleyTaylorET_swiginit", PriestleyTaylorET_swiginit, METH_VARARGS, NULL},
- { (char *)"new_HargreaveET", (PyCFunction) _wrap_new_HargreaveET, METH_VARARGS | METH_KEYWORDS, (char *)"new_HargreaveET(cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target, real latitude=51.0) -> HargreaveET"},
+ { (char *)"new_HargreaveET", (PyCFunction) _wrap_new_HargreaveET, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_HargreaveET(cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target, real latitude=51.0) -> HargreaveET\n"
+ "\n"
+ "HargreaveET(cmf::upslope::SoilLayer::ptr source,\n"
+ "cmf::water::flux_node::ptr ET_target, real latitude=51.0) \n"
+ ""},
{ (char *)"HargreaveET_lat_set", _wrap_HargreaveET_lat_set, METH_VARARGS, (char *)"HargreaveET_lat_set(HargreaveET self, real lat)"},
{ (char *)"HargreaveET_lat_get", (PyCFunction)_wrap_HargreaveET_lat_get, METH_O, (char *)"HargreaveET_lat_get(HargreaveET self) -> real"},
{ (char *)"HargreaveET_use_for_cell", (PyCFunction) _wrap_HargreaveET_use_for_cell, METH_VARARGS | METH_KEYWORDS, (char *)"HargreaveET_use_for_cell(Cell cell)"},
{ (char *)"delete_HargreaveET", (PyCFunction)_wrap_delete_HargreaveET, METH_O, (char *)"delete_HargreaveET(HargreaveET self)"},
{ (char *)"HargreaveET_swigregister", HargreaveET_swigregister, METH_VARARGS, NULL},
{ (char *)"HargreaveET_swiginit", HargreaveET_swiginit, METH_VARARGS, NULL},
- { (char *)"new_TurcET", (PyCFunction) _wrap_new_TurcET, METH_VARARGS | METH_KEYWORDS, (char *)"new_TurcET(cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target) -> TurcET"},
+ { (char *)"new_TurcET", (PyCFunction) _wrap_new_TurcET, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_TurcET(cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target) -> TurcET\n"
+ "\n"
+ "TurcET(cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr\n"
+ "ET_target) \n"
+ ""},
{ (char *)"TurcET_use_for_cell", (PyCFunction) _wrap_TurcET_use_for_cell, METH_VARARGS | METH_KEYWORDS, (char *)"TurcET_use_for_cell(Cell cell)"},
{ (char *)"delete_TurcET", (PyCFunction)_wrap_delete_TurcET, METH_O, (char *)"delete_TurcET(TurcET self)"},
{ (char *)"TurcET_swigregister", TurcET_swigregister, METH_VARARGS, NULL},
{ (char *)"TurcET_swiginit", TurcET_swiginit, METH_VARARGS, NULL},
- { (char *)"new_CanopyStorageEvaporation", (PyCFunction) _wrap_new_CanopyStorageEvaporation, METH_VARARGS | METH_KEYWORDS, (char *)"new_CanopyStorageEvaporation(cmf::water::WaterStorage::ptr CanopyStorage, cmf::water::flux_node::ptr ET_target, Cell cell) -> CanopyStorageEvaporation"},
+ { (char *)"new_CanopyStorageEvaporation", (PyCFunction) _wrap_new_CanopyStorageEvaporation, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_CanopyStorageEvaporation(cmf::water::WaterStorage::ptr CanopyStorage, cmf::water::flux_node::ptr ET_target, Cell cell) -> CanopyStorageEvaporation\n"
+ "\n"
+ "CanopyStorageEvaporation(cmf::water::WaterStorage::ptr CanopyStorage,\n"
+ "cmf::water::flux_node::ptr ET_target, cmf::upslope::Cell &cell) \n"
+ ""},
{ (char *)"delete_CanopyStorageEvaporation", (PyCFunction)_wrap_delete_CanopyStorageEvaporation, METH_O, (char *)"delete_CanopyStorageEvaporation(CanopyStorageEvaporation self)"},
{ (char *)"CanopyStorageEvaporation_swigregister", CanopyStorageEvaporation_swigregister, METH_VARARGS, NULL},
{ (char *)"CanopyStorageEvaporation_swiginit", CanopyStorageEvaporation_swiginit, METH_VARARGS, NULL},
- { (char *)"new_PenmanEvaporation", (PyCFunction) _wrap_new_PenmanEvaporation, METH_VARARGS | METH_KEYWORDS, (char *)"new_PenmanEvaporation(cmf::river::OpenWaterStorage::ptr source, cmf::water::flux_node::ptr Evap_target, Meteorology meteo) -> PenmanEvaporation"},
+ { (char *)"new_PenmanEvaporation", (PyCFunction) _wrap_new_PenmanEvaporation, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_PenmanEvaporation(cmf::river::OpenWaterStorage::ptr source, cmf::water::flux_node::ptr Evap_target, Meteorology meteo) -> PenmanEvaporation\n"
+ "\n"
+ "PenmanEvaporation(cmf::river::OpenWaterStorage::ptr source,\n"
+ "cmf::water::flux_node::ptr Evap_target, const\n"
+ "cmf::atmosphere::Meteorology &meteo) \n"
+ ""},
{ (char *)"delete_PenmanEvaporation", (PyCFunction)_wrap_delete_PenmanEvaporation, METH_O, (char *)"delete_PenmanEvaporation(PenmanEvaporation self)"},
{ (char *)"PenmanEvaporation_swigregister", PenmanEvaporation_swigregister, METH_VARARGS, NULL},
{ (char *)"PenmanEvaporation_swiginit", PenmanEvaporation_swiginit, METH_VARARGS, NULL},
@@ -76463,6 +80616,8 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"ShuttleworthWallace_refresh", _wrap_ShuttleworthWallace_refresh, METH_VARARGS, (char *)"\n"
"refresh(Time t)\n"
"ShuttleworthWallace_refresh(ShuttleworthWallace self)\n"
+ "\n"
+ "void refresh() \n"
""},
{ (char *)"ShuttleworthWallace_PTR_set", _wrap_ShuttleworthWallace_PTR_set, METH_VARARGS, (char *)"ShuttleworthWallace_PTR_set(ShuttleworthWallace self, double PTR)"},
{ (char *)"ShuttleworthWallace_PTR_get", (PyCFunction)_wrap_ShuttleworthWallace_PTR_get, METH_O, (char *)"ShuttleworthWallace_PTR_get(ShuttleworthWallace self) -> double"},
@@ -76487,46 +80642,438 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"ShuttleworthWallace_allow_dew_set", _wrap_ShuttleworthWallace_allow_dew_set, METH_VARARGS, (char *)"ShuttleworthWallace_allow_dew_set(ShuttleworthWallace self, bool allow_dew)"},
{ (char *)"ShuttleworthWallace_allow_dew_get", (PyCFunction)_wrap_ShuttleworthWallace_allow_dew_get, METH_O, (char *)"ShuttleworthWallace_allow_dew_get(ShuttleworthWallace self) -> bool"},
{ (char *)"ShuttleworthWallace_set_RSS_parameters", (PyCFunction) _wrap_ShuttleworthWallace_set_RSS_parameters, METH_VARARGS | METH_KEYWORDS, (char *)"ShuttleworthWallace_set_RSS_parameters(double _RSSa=500., double _RSSb=1.0, double _RSSa_pot=-3.22)"},
- { (char *)"new_ShuttleworthWallace", (PyCFunction) _wrap_new_ShuttleworthWallace, METH_VARARGS | METH_KEYWORDS, (char *)"new_ShuttleworthWallace(Cell cell, bool allow_dew=True) -> ShuttleworthWallace"},
+ { (char *)"new_ShuttleworthWallace", (PyCFunction) _wrap_new_ShuttleworthWallace, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_ShuttleworthWallace(Cell cell, bool allow_dew=True) -> ShuttleworthWallace\n"
+ "\n"
+ "ShuttleworthWallace(cmf::upslope::Cell &cell, bool allow_dew=true)\n"
+ "\n"
+ "Calculates the transpiration and the soil evaporation from dry\n"
+ "surfaces. \n"
+ ""},
{ (char *)"ShuttleworthWallace_use_for_cell", (PyCFunction) _wrap_ShuttleworthWallace_use_for_cell, METH_VARARGS | METH_KEYWORDS, (char *)"ShuttleworthWallace_use_for_cell(Cell cell) -> ShuttleworthWallace"},
{ (char *)"delete_ShuttleworthWallace", (PyCFunction)_wrap_delete_ShuttleworthWallace, METH_O, (char *)"delete_ShuttleworthWallace(ShuttleworthWallace self)"},
{ (char *)"ShuttleworthWallace_swigregister", ShuttleworthWallace_swigregister, METH_VARARGS, NULL},
{ (char *)"ShuttleworthWallace_swiginit", ShuttleworthWallace_swiginit, METH_VARARGS, NULL},
- { (char *)"project_remove_node", (PyCFunction) _wrap_project_remove_node, METH_VARARGS | METH_KEYWORDS, (char *)"project_remove_node(project self, cmf::water::flux_node::ptr node) -> size_t"},
+ { (char *)"project_remove_node", (PyCFunction) _wrap_project_remove_node, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "project_remove_node(project self, cmf::water::flux_node::ptr node) -> size_t\n"
+ "\n"
+ "size_t\n"
+ "remove_node(cmf::water::flux_node::ptr node)\n"
+ "\n"
+ "Removes a node from the repository.\n"
+ "\n"
+ "Removes a node (boundary condition or water storage) from the node\n"
+ "repository of the project. NOTE: If you have other references to this\n"
+ "node, the node is not deleted. If you are creating a new solver, the\n"
+ "node will not be part of the solver. \n"
+ ""},
{ (char *)"project_solutes_get", (PyCFunction)_wrap_project_solutes_get, METH_O, (char *)"project_solutes_get(project self) -> solute_vector"},
{ (char *)"project_meteo_stations_set", _wrap_project_meteo_stations_set, METH_VARARGS, (char *)"project_meteo_stations_set(project self, MeteoStationList meteo_stations)"},
{ (char *)"project_meteo_stations_get", (PyCFunction)_wrap_project_meteo_stations_get, METH_O, (char *)"project_meteo_stations_get(project self) -> MeteoStationList"},
{ (char *)"project_rainfall_stations_set", _wrap_project_rainfall_stations_set, METH_VARARGS, (char *)"project_rainfall_stations_set(project self, RainfallStationList rainfall_stations)"},
{ (char *)"project_rainfall_stations_get", (PyCFunction)_wrap_project_rainfall_stations_get, METH_O, (char *)"project_rainfall_stations_get(project self) -> RainfallStationList"},
- { (char *)"project_use_IDW_meteo", (PyCFunction) _wrap_project_use_IDW_meteo, METH_VARARGS | METH_KEYWORDS, (char *)"project_use_IDW_meteo(project self, double z_weight=0, double power=2)"},
- { (char *)"project_use_nearest_meteo", (PyCFunction) _wrap_project_use_nearest_meteo, METH_VARARGS | METH_KEYWORDS, (char *)"project_use_nearest_meteo(project self, double z_weight=0)"},
- { (char *)"project_use_IDW_rainfall", (PyCFunction) _wrap_project_use_IDW_rainfall, METH_VARARGS | METH_KEYWORDS, (char *)"project_use_IDW_rainfall(project self, double z_weight=0, double power=2)"},
- { (char *)"project_use_nearest_rainfall", (PyCFunction) _wrap_project_use_nearest_rainfall, METH_VARARGS | METH_KEYWORDS, (char *)"project_use_nearest_rainfall(project self, double z_weight=0)"},
- { (char *)"project_get_cell", (PyCFunction) _wrap_project_get_cell, METH_VARARGS | METH_KEYWORDS, (char *)"project_get_cell(project self, ptrdiff_t index) -> Cell"},
- { (char *)"project_size", (PyCFunction)_wrap_project_size, METH_O, (char *)"project_size(project self) -> size_t"},
- { (char *)"new_project", (PyCFunction) _wrap_new_project, METH_VARARGS | METH_KEYWORDS, (char *)"new_project(std::string solute_names) -> project"},
- { (char *)"delete_project", (PyCFunction)_wrap_delete_project, METH_O, (char *)"delete_project(project self)"},
- { (char *)"project_NewCell", (PyCFunction) _wrap_project_NewCell, METH_VARARGS | METH_KEYWORDS, (char *)"project_NewCell(project self, double x, double y, double z, double area, bool with_surfacewater=False) -> Cell"},
- { (char *)"project_NewOutlet", (PyCFunction) _wrap_project_NewOutlet, METH_VARARGS | METH_KEYWORDS, (char *)"project_NewOutlet(project self, std::string name, double x=0, double y=0, double z=0) -> cmf::water::DirichletBoundary::ptr"},
- { (char *)"project_NewStorage", (PyCFunction) _wrap_project_NewStorage, METH_VARARGS | METH_KEYWORDS, (char *)"project_NewStorage(project self, std::string name, double x=0, double y=0, double z=0) -> cmf::water::WaterStorage::ptr"},
- { (char *)"project_NewOpenStorage", (PyCFunction) _wrap_project_NewOpenStorage, METH_VARARGS | METH_KEYWORDS, (char *)"project_NewOpenStorage(project self, std::string name, double x, double y, double z, double area) -> cmf::river::OpenWaterStorage::ptr"},
- { (char *)"project_NewNeumannBoundary", (PyCFunction) _wrap_project_NewNeumannBoundary, METH_VARARGS | METH_KEYWORDS, (char *)"project_NewNeumannBoundary(project self, std::string name, cmf::water::WaterStorage::ptr target) -> cmf::water::NeumannBoundary::ptr"},
- { (char *)"project_NewReach", (PyCFunction) _wrap_project_NewReach, METH_VARARGS | METH_KEYWORDS, (char *)"project_NewReach(project self, double x, double y, double z, IChannel shape, bool diffusive=False) -> cmf::river::Reach::ptr"},
- { (char *)"project_get_reach", (PyCFunction) _wrap_project_get_reach, METH_VARARGS | METH_KEYWORDS, (char *)"project_get_reach(project self, ptrdiff_t index) -> cmf::river::Reach::ptr"},
- { (char *)"project_reach_count", (PyCFunction)_wrap_project_reach_count, METH_O, (char *)"project_reach_count(project self) -> size_t"},
- { (char *)"project_get_node", (PyCFunction) _wrap_project_get_node, METH_VARARGS | METH_KEYWORDS, (char *)"project_get_node(project self, ptrdiff_t index) -> cmf::water::flux_node::ptr"},
- { (char *)"project_node_count", (PyCFunction)_wrap_project_node_count, METH_O, (char *)"project_node_count(project self) -> size_t"},
- { (char *)"project_get_storages", (PyCFunction)_wrap_project_get_storages, METH_O, (char *)"project_get_storages(project self) -> node_list"},
+ { (char *)"project_use_IDW_meteo", (PyCFunction) _wrap_project_use_IDW_meteo, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "project_use_IDW_meteo(project self, double z_weight=0, double power=2)\n"
+ "\n"
+ "void\n"
+ "use_IDW_meteo(double z_weight=0, double power=2)\n"
+ "\n"
+ "Uses IDW interpolation to generate meterological data for each cell of\n"
+ "project.\n"
+ "\n"
+ "Creates a meteo-data source for each cell, using spatial interpolated\n"
+ "data from all meteorological stations of the project using Inverse\n"
+ "Distance Weighted (IDW) interpolation. The meteorolgical value f is\n"
+ "calculated with IDW for position x,y,z and time t as follows:\n"
+ "\n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " f(x,y,z,t) &=& \\\\sum^N_{i=1}{f_i(t) w_i(x,y,z)}\n"
+ " \\\\\\\\ w_i(x,y,z) &=&\n"
+ " \\\\frac{d_i(x,y,z)^{-p}}{\\\\sum^N_{j=0}{d_j(x,y,z)^{-p}}} \\\\\\\\\n"
+ " d_i(x,y,z) &=& w_z \\\\left|z-z_i\\\\right| +\n"
+ " \\\\sqrt{\\\\left(x-x_i\\\\right)^2 + \\\\left(y-y_i\\\\right)^2}\n"
+ "\n"
+ "\n"
+ " :math:`N` is the number of stations\n"
+ "\n"
+ ":math:`f_i(t)` the meteorological value at time t, eg. Temperature, Humidity\n"
+ "\n"
+ ":math:`w_i` is the weight of station i\n"
+ "\n"
+ ":math:`d_i` is the distance from x,y,z to station i\n"
+ "\n"
+ ":math:`p` the power of the weighting function, usually 2.\n"
+ "\n"
+ ":math:`x_i,y_i,z_i` is the position of station i in space\n"
+ "\n"
+ ":math:`w_z` is a factor to weight the vertical distance between stations and\n"
+ "the cell. 0 results in a pure horizontal interpolation (normal IDW).\n"
+ "If :math:`w_z=1`, height difference is as important as horizontal distance,\n"
+ "and with :math:`w_z>1` the height difference is weighted more important than\n"
+ "horizontal distance See: IDW_Meteorology\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "z_weight: :math:`w_z` the weight of height difference between cell and\n"
+ "station\n"
+ "\n"
+ "power: the power of the distance weight \n"
+ ""},
+ { (char *)"project_use_nearest_meteo", (PyCFunction) _wrap_project_use_nearest_meteo, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "project_use_nearest_meteo(project self, double z_weight=0)\n"
+ "\n"
+ "void\n"
+ "use_nearest_meteo(double z_weight=0)\n"
+ "\n"
+ "Connects all cells of the project with its nearest meteorological\n"
+ "station.\n"
+ "\n"
+ "Distance is calculated as follows: \n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " d_i(x,y,z) = w_z\n"
+ " \\\\left|z-z_i\\\\right| + \\\\sqrt{\\\\left(x-x_i\\\\right)^2 +\n"
+ " \\\\left(y-y_i\\\\right)^2} \n"
+ "\n"
+ ":math:`d_i` is the distance from x,y,z to\n"
+ "station i\n"
+ "\n"
+ ":math:`p` the power of the weighting function, usually 2.\n"
+ "\n"
+ ":math:`x_i,y_i,z_i` is the position of station i in space\n"
+ "\n"
+ ":math:`w_z` is a factor to weight the vertical distance between stations and\n"
+ "the cell. 0 results in a pure horizontal interpolation (normal IDW).\n"
+ "If :math:`w_z=1`, height difference is as important as horizontal distance,\n"
+ "and with :math:`w_z>1` the height difference is weighted more important than\n"
+ "horizontal distance\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "z_weight: :math:`w_z` the weight of height difference between cell and\n"
+ "station \n"
+ ""},
+ { (char *)"project_use_IDW_rainfall", (PyCFunction) _wrap_project_use_IDW_rainfall, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "project_use_IDW_rainfall(project self, double z_weight=0, double power=2)\n"
+ "\n"
+ "void\n"
+ "use_IDW_rainfall(double z_weight=0, double power=2)\n"
+ "\n"
+ "Uses IDW interpolation to generate rainfall data for each cell of\n"
+ "project.\n"
+ "\n"
+ "Creates a rainfall-data source for each cell, using spatial\n"
+ "interpolated data from all meteorological stations of the project\n"
+ "using Inverse Distance Weighted (IDW) interpolation. The rainfall\n"
+ "intensity P is calculated with IDW for position x,y,z and time t as\n"
+ "follows: \n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " P(x,y,z,t) &=& \\\\sum^N_{i=1}{P_i(t)\n"
+ " w_i(x,y,z)} \\\\\\\\ w_i(x,y,z) &=&\n"
+ " \\\\frac{d_i(x,y,z)^{-p}}{\\\\sum^N_{j=0}{d_j(x,y,z)^{-p}}} \\\\\\\\\n"
+ " d_i(x,y,z) &=& w_z \\\\left|z-z_i\\\\right| +\n"
+ " \\\\sqrt{\\\\left(x-x_i\\\\right)^2 + \\\\left(y-y_i\\\\right)^2}\n"
+ "\n"
+ "\n"
+ " :math:`N` is the number of stations\n"
+ "\n"
+ ":math:`P_i(t)` the meteorological value at time t, eg. Temperature, Humidity\n"
+ "\n"
+ ":math:`w_i` is the weight of station i\n"
+ "\n"
+ ":math:`d_i` is the distance from x,y,z to station i\n"
+ "\n"
+ ":math:`p` the power of the weighting function, usually 2.\n"
+ "\n"
+ ":math:`x_i,y_i,z_i` is the position of station i in space\n"
+ "\n"
+ ":math:`w_z` is a factor to weight the vertical distance between stations and\n"
+ "the cell. 0 results in a pure horizontal interpolation (normal IDW).\n"
+ "If :math:`w_z=1`, height difference is as important as horizontal distance,\n"
+ "and with :math:`w_z>1` the height difference is weighted more important than\n"
+ "horizontal distance See: IDW_Meteorology\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "z_weight: :math:`w_z` the weight of height difference between cell and\n"
+ "station\n"
+ "\n"
+ "power: the power of the distance weight \n"
+ ""},
+ { (char *)"project_use_nearest_rainfall", (PyCFunction) _wrap_project_use_nearest_rainfall, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "project_use_nearest_rainfall(project self, double z_weight=0)\n"
+ "\n"
+ "void\n"
+ "use_nearest_rainfall(double z_weight=0)\n"
+ "\n"
+ "Connects all cells of the project with its nearest rainfall station.\n"
+ "\n"
+ "Distance is calculated as follows: \n"
+ "\n"
+ ".. math::\n"
+ "\n"
+ " d_i(x,y,z) = w_z\n"
+ " \\\\left|z-z_i\\\\right| + \\\\sqrt{\\\\left(x-x_i\\\\right)^2 +\n"
+ " \\\\left(y-y_i\\\\right)^2} \n"
+ "\n"
+ ":math:`d_i` is the distance from x,y,z to\n"
+ "station i\n"
+ "\n"
+ ":math:`p` the power of the weighting function, usually 2.\n"
+ "\n"
+ ":math:`x_i,y_i,z_i` is the position of station i in space\n"
+ "\n"
+ ":math:`w_z` is a factor to weight the vertical distance between stations and\n"
+ "the cell. 0 results in a pure horizontal interpolation (normal IDW).\n"
+ "If :math:`w_z=1`, height difference is as important as horizontal distance,\n"
+ "and with :math:`w_z>1` the height difference is weighted more important than\n"
+ "horizontal distance\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "z_weight: :math:`w_z` the weight of height difference between cell and\n"
+ "station \n"
+ ""},
+ { (char *)"project_get_cell", (PyCFunction) _wrap_project_get_cell, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "project_get_cell(project self, ptrdiff_t index) -> Cell\n"
+ "\n"
+ "upslope::Cell&\n"
+ "get_cell(ptrdiff_t index)\n"
+ "\n"
+ "Returns the reference to the cell at index in the project. \n"
+ ""},
+ { (char *)"project_size", (PyCFunction)_wrap_project_size, METH_O, (char *)"\n"
+ "project_size(project self) -> size_t\n"
+ "\n"
+ "size_t size() const\n"
+ "\n"
+ "The number of cells in the project. \n"
+ ""},
+ { (char *)"new_project", (PyCFunction) _wrap_new_project, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "new_project(std::string solute_names) -> project\n"
+ "\n"
+ "project(std::string\n"
+ "solute_names=\"\")\n"
+ "\n"
+ "Creates a new project.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "solute_names: A string representing the names of the solutes to be\n"
+ "used in the project. Sepereate solute names with space. \n"
+ ""},
+ { (char *)"delete_project", (PyCFunction)_wrap_delete_project, METH_O, (char *)"\n"
+ "delete_project(project self)\n"
+ "\n"
+ "~project() \n"
+ ""},
+ { (char *)"project_NewCell", (PyCFunction) _wrap_project_NewCell, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "project_NewCell(project self, double x, double y, double z, double area, bool with_surfacewater=False) -> Cell\n"
+ "\n"
+ "cmf::upslope::Cell*\n"
+ "NewCell(double x, double y, double z, double area, bool\n"
+ "with_surfacewater=false)\n"
+ "\n"
+ "Creates a new cell.\n"
+ "\n"
+ "A new cell, owned by the project\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "x: y: z: Position of the cell center in project coordinates (m)\n"
+ "\n"
+ "area: Area of the cell in m^2\n"
+ "\n"
+ "with_surfacewater: If true, the cell will own a surfacewater storage\n"
+ "upon creation \n"
+ ""},
+ { (char *)"project_NewOutlet", (PyCFunction) _wrap_project_NewOutlet, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "project_NewOutlet(project self, std::string name, double x=0, double y=0, double z=0) -> cmf::water::DirichletBoundary::ptr\n"
+ "\n"
+ "cmf::water::DirichletBoundary::ptr NewOutlet(std::string name, double\n"
+ "x=0, double y=0, double z=0)\n"
+ "\n"
+ "Creates a new Dirichlet boundary condition and adds it to the list of\n"
+ "outlets The potential of the Dirichlet boundary equals z, but can be\n"
+ "changed.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "name: Name of the boundary condition for output\n"
+ "\n"
+ "x: y: z: Position of the boundary condition in project coordinates\n"
+ "\n"
+ ""},
+ { (char *)"project_NewStorage", (PyCFunction) _wrap_project_NewStorage, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "project_NewStorage(project self, std::string name, double x=0, double y=0, double z=0) -> cmf::water::WaterStorage::ptr\n"
+ "\n"
+ "cmf::water::WaterStorage::ptr NewStorage(std::string name, double x=0,\n"
+ "double y=0, double z=0)\n"
+ "\n"
+ "Creates a new generic water storage at position x,y,z.\n"
+ "\n"
+ "The storage is added to the project nodes A new water storage, owned\n"
+ "by the project\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "name: Name of the generic water storage for output\n"
+ "\n"
+ "x: y: z: Position of the generic water storage condition in project\n"
+ "coordinates \n"
+ ""},
+ { (char *)"project_NewOpenStorage", (PyCFunction) _wrap_project_NewOpenStorage, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "project_NewOpenStorage(project self, std::string name, double x, double y, double z, double area) -> cmf::river::OpenWaterStorage::ptr\n"
+ "\n"
+ "cmf::river::OpenWaterStorage::ptr NewOpenStorage(std::string name,\n"
+ "double x, double y, double z, double area)\n"
+ "\n"
+ "Creates a new open water storage with a prism geometry.\n"
+ "\n"
+ "The open water storage is added to the project nodes A new open water\n"
+ "storage, owned by the project\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "name: Name of the open water storage for output\n"
+ "\n"
+ "x: y: z: Position of the open water storage in project coordinates\n"
+ "\n"
+ "area: Surface area of the open water storage \n"
+ ""},
+ { (char *)"project_NewNeumannBoundary", (PyCFunction) _wrap_project_NewNeumannBoundary, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "project_NewNeumannBoundary(project self, std::string name, cmf::water::WaterStorage::ptr target) -> cmf::water::NeumannBoundary::ptr\n"
+ "\n"
+ "cmf::water::NeumannBoundary::ptr NewNeumannBoundary(std::string name,\n"
+ "cmf::water::WaterStorage::ptr target)\n"
+ "\n"
+ "Creates a new Neumann boundary for a target water storage.\n"
+ "\n"
+ "The boundary is stored with the project A new Neumann boundary\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "name: The name of the boundary condition\n"
+ "\n"
+ "target: The water storage to which the Neumann boundary is bound \n"
+ ""},
+ { (char *)"project_NewReach", (PyCFunction) _wrap_project_NewReach, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "project_NewReach(project self, double x, double y, double z, IChannel shape, bool diffusive=False) -> cmf::river::Reach::ptr\n"
+ "\n"
+ "cmf::river::Reach::ptr\n"
+ "NewReach(double x, double y, double z, cmf::river::IChannel &shape,\n"
+ "bool diffusive=false)\n"
+ "\n"
+ "Creates a new reach.\n"
+ "\n"
+ "A new reach, owned by the project\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "x: y: z: Position of the reach in project coordinates\n"
+ "\n"
+ "shape: Crossectional geometry of the river. Any class inheriting from\n"
+ "cmf::water::IChannel\n"
+ "\n"
+ "diffusive: If true, this reach uses by default a diffusive wave\n"
+ "connection \n"
+ ""},
+ { (char *)"project_get_reach", (PyCFunction) _wrap_project_get_reach, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "project_get_reach(project self, ptrdiff_t index) -> cmf::river::Reach::ptr\n"
+ "\n"
+ "cmf::river::Reach::ptr get_reach(ptrdiff_t index)\n"
+ "\n"
+ "Returns the reach at index. \n"
+ ""},
+ { (char *)"project_reach_count", (PyCFunction)_wrap_project_reach_count, METH_O, (char *)"\n"
+ "project_reach_count(project self) -> size_t\n"
+ "\n"
+ "size_t\n"
+ "reach_count() const\n"
+ "\n"
+ "Returns the number of reaches in this project. \n"
+ ""},
+ { (char *)"project_get_node", (PyCFunction) _wrap_project_get_node, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
+ "project_get_node(project self, ptrdiff_t index) -> cmf::water::flux_node::ptr\n"
+ "\n"
+ "cmf::water::flux_node::ptr get_node(ptrdiff_t index)\n"
+ "\n"
+ "Returns the node from the project nodes at index. \n"
+ ""},
+ { (char *)"project_node_count", (PyCFunction)_wrap_project_node_count, METH_O, (char *)"\n"
+ "project_node_count(project self) -> size_t\n"
+ "\n"
+ "size_t node_count()\n"
+ "const\n"
+ "\n"
+ "Returns the number of nodes saved with this project. \n"
+ ""},
+ { (char *)"project_get_storages", (PyCFunction)_wrap_project_get_storages, METH_O, (char *)"\n"
+ "project_get_storages(project self) -> node_list\n"
+ "\n"
+ "cmf::water::node_list get_storages()\n"
+ "\n"
+ "Returns a list of all storages of this project. \n"
+ ""},
{ (char *)"project_cells_get", (PyCFunction)_wrap_project_cells_get, METH_O, (char *)"project_cells_get(project self) -> cell_vector"},
{ (char *)"project_swigregister", project_swigregister, METH_VARARGS, NULL},
{ (char *)"project_swiginit", project_swiginit, METH_VARARGS, NULL},
- { (char *)"SoluteWaterIntegrator_copy", (PyCFunction)_wrap_SoluteWaterIntegrator_copy, METH_O, (char *)"SoluteWaterIntegrator_copy(SoluteWaterIntegrator self) -> SoluteWaterIntegrator"},
+ { (char *)"SoluteWaterIntegrator_copy", (PyCFunction)_wrap_SoluteWaterIntegrator_copy, METH_O, (char *)"\n"
+ "SoluteWaterIntegrator_copy(SoluteWaterIntegrator self) -> SoluteWaterIntegrator\n"
+ "\n"
+ "virtual cmf::math::SoluteWaterIntegrator* copy() const\n"
+ "\n"
+ "Polymorphic copy constructor. \n"
+ ""},
{ (char *)"new_SoluteWaterIntegrator", _wrap_new_SoluteWaterIntegrator, METH_VARARGS, (char *)"\n"
"SoluteWaterIntegrator(solute_vector solutes, Integrator water_integrator, Integrator solute_integrator)\n"
"new_SoluteWaterIntegrator(solute_vector solutes, Integrator water_integrator, Integrator solute_integrator, StateVariableOwner states) -> SoluteWaterIntegrator\n"
+ "\n"
+ "SoluteWaterIntegrator(cmf::water::solute_vector solutes, const\n"
+ "cmf::math::Integrator &water_integrator, const cmf::math::Integrator\n"
+ "&solute_integrator, cmf::math::StateVariableOwner &states)\n"
+ "\n"
+ "Creates a new SoluteWaterIntegrator.\n"
+ "\n"
+ "Parameters:\n"
+ "-----------\n"
+ "\n"
+ "solutes: Solutes of the project\n"
+ "\n"
+ "water_integrator: Template for the integrator of WaterStorage state\n"
+ "variables\n"
+ "\n"
+ "solute_integrator: Template for the integrator of soluteStorage state\n"
+ "variables\n"
+ "\n"
+ "states: States to be added to the integrators \n"
+ ""},
+ { (char *)"delete_SoluteWaterIntegrator", (PyCFunction)_wrap_delete_SoluteWaterIntegrator, METH_O, (char *)"\n"
+ "delete_SoluteWaterIntegrator(SoluteWaterIntegrator self)\n"
+ "\n"
+ "~SoluteWaterIntegrator() \n"
+ ""},
+ { (char *)"SoluteWaterIntegrator_to_string", (PyCFunction)_wrap_SoluteWaterIntegrator_to_string, METH_O, (char *)"\n"
+ "SoluteWaterIntegrator_to_string(SoluteWaterIntegrator self) -> std::string\n"
+ "\n"
+ "std::string to_string() const \n"
""},
- { (char *)"delete_SoluteWaterIntegrator", (PyCFunction)_wrap_delete_SoluteWaterIntegrator, METH_O, (char *)"delete_SoluteWaterIntegrator(SoluteWaterIntegrator self)"},
- { (char *)"SoluteWaterIntegrator_to_string", (PyCFunction)_wrap_SoluteWaterIntegrator_to_string, METH_O, (char *)"SoluteWaterIntegrator_to_string(SoluteWaterIntegrator self) -> std::string"},
{ (char *)"SoluteWaterIntegrator_swigregister", SoluteWaterIntegrator_swigregister, METH_VARARGS, NULL},
{ (char *)"SoluteWaterIntegrator_swiginit", SoluteWaterIntegrator_swiginit, METH_VARARGS, NULL},
{ NULL, NULL, 0, NULL }
diff --git a/cmf/cmf_core_src/math/statevariable.h b/cmf/cmf_core_src/math/statevariable.h
index 63bb7b15..e67f8b12 100644
--- a/cmf/cmf_core_src/math/statevariable.h
+++ b/cmf/cmf_core_src/math/statevariable.h
@@ -102,12 +102,17 @@ namespace cmf {
bool m_StateIsNew;
/// Holds the value of the Statevariable
real m_State;
+
protected:
virtual void StateChangeAction() {}
/// Sets the updated flag (m_StateIsNew) to false
void MarkStateChangeHandled() {m_StateIsNew=false;}
/// Returns if the state was currently updated
bool StateIsChanged() {return m_StateIsNew;}
+ // A scale to handle abstol issues with the CVode Solver and with the is_empty function
+ // By default, the scale is 1. Absolute tolerance is scale times rel tolerance
+ real m_Scale;
+
public:
typedef std::shared_ptr ptr;
/// Returns the derivate of the state variable at time @c time
@@ -118,11 +123,14 @@ namespace cmf {
void set_state(real newState);
virtual real get_abs_errtol(real rel_errtol) const{
- return rel_errtol;
+ return rel_errtol * m_Scale;
}
virtual std::string to_string() const=0;
/// ctor
- StateVariable(real InitialState=0) : m_State(InitialState),m_StateIsNew(true) {}
+ StateVariable(real InitialState=0, real scale=1)
+ : m_State(InitialState),m_StateIsNew(true), m_Scale(scale)
+ {}
+
virtual ~StateVariable() {}
};
diff --git a/cmf/cmf_core_src/upslope/cell.cpp b/cmf/cmf_core_src/upslope/cell.cpp
index f79fb714..81e1ed79 100644
--- a/cmf/cmf_core_src/upslope/cell.cpp
+++ b/cmf/cmf_core_src/upslope/cell.cpp
@@ -159,7 +159,9 @@ cmf::water::WaterStorage::ptr Cell::add_storage( std::string Name,char storage_r
if (isopenwater)
ws = cmf::river::OpenWaterStorage::create(get_project(),get_area());
else
- ws = WaterStorage::create(get_project());
+ // Create a water storage with a "standard storage" of 1mm for tolerances
+ ws = WaterStorage::create(get_project(), 0.0, /*scale=*/ get_area()/1000.);
+
ws->position=get_position();
ws->Name=Name;
if (storage_role=='C')
diff --git a/cmf/cmf_core_src/upslope/connections/surfacefluxes.cpp b/cmf/cmf_core_src/upslope/connections/surfacefluxes.cpp
index 6b77d039..0f8f0983 100644
--- a/cmf/cmf_core_src/upslope/connections/surfacefluxes.cpp
+++ b/cmf/cmf_core_src/upslope/connections/surfacefluxes.cpp
@@ -51,7 +51,7 @@ real cmf::upslope::connections::SimpleTindexSnowMelt::calc_q( cmf::math::Time t
// limit snow meltrate to current snow/(10 min)
return std::min(Snow->get_volume() * 24 * 6, potential_meltrate_m3);
}
- else
+ else // too cold, no melting
return 0.0;
}
diff --git a/cmf/cmf_core_src/water/WaterStorage.cpp b/cmf/cmf_core_src/water/WaterStorage.cpp
index a273e915..19367339 100644
--- a/cmf/cmf_core_src/water/WaterStorage.cpp
+++ b/cmf/cmf_core_src/water/WaterStorage.cpp
@@ -31,8 +31,9 @@ void WaterStorage::initializeSoluteStorages(const solute_vector& solutes) {
}
-WaterStorage::WaterStorage(cmf::project& _project, const std::string& _Name,double InitialState/*=0*/ )
-: cmf::math::StateVariable(InitialState),flux_node(_project) ,m_Concentrations(), m_state_variable_content('V')
+WaterStorage::WaterStorage(cmf::project& _project, const std::string& _Name,
+ double InitialState/*=0*/, double scale/*=1*/ )
+: cmf::math::StateVariable(InitialState, scale),flux_node(_project) ,m_Concentrations(), m_state_variable_content('V')
{
initializeSoluteStorages(_project.solutes);
this->Name = _Name;
diff --git a/cmf/cmf_core_src/water/WaterStorage.h b/cmf/cmf_core_src/water/WaterStorage.h
index 3f9403f1..de488eeb 100644
--- a/cmf/cmf_core_src/water/WaterStorage.h
+++ b/cmf/cmf_core_src/water/WaterStorage.h
@@ -68,9 +68,6 @@ namespace cmf {
virtual real volume_to_head(real volume) const;
public:
- real get_abs_errtol(real rel_errtol) const {
- return rel_errtol;
- }
/// @brief A character indicating the integrated variable (either 'V' for Volume or 'h' for head)
inline char get_state_variable_content() const {return m_state_variable_content;}
/// @brief A character indicating the integrated variable (either 'V' for Volume or 'h' for head)
@@ -82,7 +79,9 @@ namespace cmf {
/// @param project The project the waterstorage belongs to
/// @param Name Name of the water storage
/// @param InitialState Initial water content in m3
- WaterStorage(cmf::project& project,const std::string & Name="", double InitialState=0);
+ /// @param A kind of "standard size" in m3 of the water storage to scale tolerances, default 1m3
+ WaterStorage(cmf::project& project,const std::string & Name="",
+ double InitialState=0, double scale=1);
static std::shared_ptr from_node(cmf::water::flux_node::ptr node);
/// @brief Returns the water quality of the water storage.
@@ -153,9 +152,9 @@ namespace cmf {
{
return std::dynamic_pointer_cast(node);
}
- static std::shared_ptr create(cmf::project& _project, real initial_state=0.0)
+ static std::shared_ptr create(cmf::project& _project, real initial_state=0.0, real scale=1.0)
{
- return std::shared_ptr(new WaterStorage(_project,"unknown",initial_state));
+ return std::shared_ptr(new WaterStorage(_project,"unknown",initial_state, scale));
}
};
diff --git a/setup.py b/setup.py
index 57ba5388..c8830ad8 100644
--- a/setup.py
+++ b/setup.py
@@ -24,7 +24,7 @@
import io
import datetime
-version = '1.0.4a'
+version = '1.0.4'
# Try to import numpy, if it fails we have a problem
try: