From 4ed21feff2735caf0c79cb631198e11aae1d65d0 Mon Sep 17 00:00:00 2001 From: Philipp Kraft Date: Tue, 12 Dec 2017 10:41:03 +0100 Subject: [PATCH] Added a scale parameter to state variable (default=1) to scale absolute tolerances. Another take on #2. --- cmf/cmf_core.py | 8248 +++++++++++++++-- cmf/cmf_core_src/cmf.vcxproj | 3 +- cmf/cmf_core_src/cmf_wrap.cpp | 5541 ++++++++++- cmf/cmf_core_src/math/statevariable.h | 12 +- cmf/cmf_core_src/upslope/cell.cpp | 4 +- .../upslope/connections/surfacefluxes.cpp | 2 +- cmf/cmf_core_src/water/WaterStorage.cpp | 5 +- cmf/cmf_core_src/water/WaterStorage.h | 11 +- setup.py | 2 +- 9 files changed, 12667 insertions(+), 1161 deletions(-) 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: