# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (3, 0, 0):
    new_instancemethod = lambda func, inst, cls: _cmf_core.SWIG_PyInstanceMethod_New(func)
else:
    from new import instancemethod as new_instancemethod
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_cmf_core')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_cmf_core')
    _cmf_core = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_cmf_core', [dirname(__file__)])
        except ImportError:
            import _cmf_core
            return _cmf_core
        try:
            _mod = imp.load_module('_cmf_core', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _cmf_core = swig_import_helper()
    del swig_import_helper
else:
    import _cmf_core
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import builtins

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        object.__setattr__(self, name, value)
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except builtins.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_method(set):
    def set_attr(self, name, value):
        if (name == "thisown"):
            return self.this.own(value)
        if hasattr(self, name) or (name == "this"):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


SHARED_PTR_DISOWN = _cmf_core.SHARED_PTR_DISOWN

def get_parallel_threads(*args):
    """get_parallel_threads() -> int"""
    return _cmf_core.get_parallel_threads(*args)

def set_parallel_threads(*args, **kwargs):
    """set_parallel_threads(int numthreads) -> int"""
    return _cmf_core.set_parallel_threads(*args, **kwargs)
class cubicspline(object):
    """Proxy of C++ cmf::math::cubicspline 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::math::cubicspline self, cmf::math::num_array const & x, cmf::math::num_array const & y) -> cubicspline"""
        _cmf_core.cubicspline_swiginit(self, _cmf_core.new_cubicspline(*args, **kwargs))

    def generate(self, *args, **kwargs):
        """generate(cubicspline self)"""
        return _cmf_core.cubicspline_generate(self, *args, **kwargs)


    def size(self, *args, **kwargs):
        """size(cubicspline self) -> size_t"""
        return _cmf_core.cubicspline_size(self, *args, **kwargs)


    def __call__(self, *args, **kwargs):
        """__call__(cubicspline self, real x) -> real"""
        return _cmf_core.cubicspline___call__(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_cubicspline
cubicspline.generate = new_instancemethod(_cmf_core.cubicspline_generate, None, cubicspline)
cubicspline.size = new_instancemethod(_cmf_core.cubicspline_size, None, cubicspline)
cubicspline.__call__ = new_instancemethod(_cmf_core.cubicspline___call__, None, cubicspline)
cubicspline_swigregister = _cmf_core.cubicspline_swigregister
cubicspline_swigregister(cubicspline)

class point(object):
    """Proxy of C++ cmf::geometry::point class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = _swig_property(_cmf_core.point_x_get, _cmf_core.point_x_set)
    y = _swig_property(_cmf_core.point_y_get, _cmf_core.point_y_set)
    z = _swig_property(_cmf_core.point_z_get, _cmf_core.point_z_set)

    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
        """
        _cmf_core.point_swiginit(self, _cmf_core.new_point(*args))

    def distanceTo(self, *args, **kwargs):
        """distanceTo(point self, point p) -> double"""
        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"""
        return _cmf_core.point_z_weight_distance(self, *args, **kwargs)


    def distance3DTo(self, *args, **kwargs):
        """distance3DTo(point self, point p) -> double"""
        return _cmf_core.point_distance3DTo(self, *args, **kwargs)


    def distance(*args, **kwargs):
        """distance(point p1, point p2) -> double"""
        return _cmf_core.point_distance(*args, **kwargs)

    distance = staticmethod(distance)

    def distance_max(self, *args, **kwargs):
        """distance_max(point self, point p) -> double"""
        return _cmf_core.point_distance_max(self, *args, **kwargs)


    def azimuth(self, *args, **kwargs):
        """azimuth(point self, point p) -> double"""
        return _cmf_core.point_azimuth(self, *args, **kwargs)


    def angleToXAxis(self, *args, **kwargs):
        """angleToXAxis(point self, point p) -> double"""
        return _cmf_core.point_angleToXAxis(self, *args, **kwargs)


    def sum(self, *args, **kwargs):
        """sum(point self) -> double"""
        return _cmf_core.point_sum(self, *args, **kwargs)


    def length(self, *args, **kwargs):
        """length(point self) -> double"""
        return _cmf_core.point_length(self, *args, **kwargs)


    def __add__(self, *args, **kwargs):
        """__add__(point self, point p) -> point"""
        return _cmf_core.point___add__(self, *args, **kwargs)


    def __iadd__(self, *args, **kwargs):
        """__iadd__(point self, point left) -> point"""
        return _cmf_core.point___iadd__(self, *args, **kwargs)


    def __sub__(self, *args, **kwargs):
        """__sub__(point self, point p) -> point"""
        return _cmf_core.point___sub__(self, *args, **kwargs)


    def __isub__(self, *args, **kwargs):
        """__isub__(point self, point left) -> point"""
        return _cmf_core.point___isub__(self, *args, **kwargs)


    def __mul__(self, *args):
        """
        __mul__(point self, double left) -> point
        __mul__(point self, point p) -> point
        """
        return _cmf_core.point___mul__(self, *args)


    def __imul__(self, *args):
        """
        __imul__(point self, double left) -> point
        __imul__(point self, point left) -> point
        """
        return _cmf_core.point___imul__(self, *args)


    def __truediv__(self, *args):
        return _cmf_core.point___truediv__(self, *args)
    __div__ = __truediv__



    def __itruediv__(self, *args):
        return _cmf_core.point___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __eq__(self, *args, **kwargs):
        """__eq__(point self, point p) -> bool"""
        return _cmf_core.point___eq__(self, *args, **kwargs)


    def __ne__(self, *args, **kwargs):
        """__ne__(point self, point p) -> bool"""
        return _cmf_core.point___ne__(self, *args, **kwargs)


    def __len__(self, *args, **kwargs):
        """__len__(point self) -> int"""
        return _cmf_core.point___len__(self, *args, **kwargs)


    def __rmul__(self, *args, **kwargs):
        """__rmul__(point self, double val) -> point"""
        return _cmf_core.point___rmul__(self, *args, **kwargs)


    def __rdiv__(self, *args, **kwargs):
        """__rdiv__(point self, double val) -> point"""
        return _cmf_core.point___rdiv__(self, *args, **kwargs)


    def __getitem__(self,index) :
        if isinstance(index,slice):
            return [self[i] for i in range(*index.indices(len(self)))]
        if index==0 :
            return self.x
        elif index==1 :
            return self.y
        elif index==2 :
            return self.z
        else :
            raise IndexError("Only Index 0 .. 2 are allowed")
    def __setitem__(self,index,value) :
        if index==0 :
            self.x=value
        elif index==1 :
            self.y=value
        elif index==2 :
            self.z=value
        else :
            raise IndexError("Only Index 0 .. 2 are allowed")
    def __iter__(self):
        yield self.x
        yield self.y
        yield self.z
    def __repr__(self):
        return 'cmf.point(%g,%g,%g)' % (self.x,self.y,self.z)

    __swig_destroy__ = _cmf_core.delete_point
point.distanceTo = new_instancemethod(_cmf_core.point_distanceTo, None, point)
point.z_weight_distance = new_instancemethod(_cmf_core.point_z_weight_distance, None, point)
point.distance3DTo = new_instancemethod(_cmf_core.point_distance3DTo, None, point)
point.distance_max = new_instancemethod(_cmf_core.point_distance_max, None, point)
point.azimuth = new_instancemethod(_cmf_core.point_azimuth, None, point)
point.angleToXAxis = new_instancemethod(_cmf_core.point_angleToXAxis, None, point)
point.sum = new_instancemethod(_cmf_core.point_sum, None, point)
point.length = new_instancemethod(_cmf_core.point_length, None, point)
point.__add__ = new_instancemethod(_cmf_core.point___add__, None, point)
point.__iadd__ = new_instancemethod(_cmf_core.point___iadd__, None, point)
point.__sub__ = new_instancemethod(_cmf_core.point___sub__, None, point)
point.__isub__ = new_instancemethod(_cmf_core.point___isub__, None, point)
point.__mul__ = new_instancemethod(_cmf_core.point___mul__, None, point)
point.__imul__ = new_instancemethod(_cmf_core.point___imul__, None, point)
point.__eq__ = new_instancemethod(_cmf_core.point___eq__, None, point)
point.__ne__ = new_instancemethod(_cmf_core.point___ne__, None, point)
point.__len__ = new_instancemethod(_cmf_core.point___len__, None, point)
point.__rmul__ = new_instancemethod(_cmf_core.point___rmul__, None, point)
point.__rdiv__ = new_instancemethod(_cmf_core.point___rdiv__, None, point)
point_swigregister = _cmf_core.point_swigregister
point_swigregister(point)
cvar = _cmf_core.cvar
PI = cvar.PI

def point_distance(*args, **kwargs):
    """point_distance(point p1, point p2) -> double"""
    return _cmf_core.point_distance(*args, **kwargs)


def dot(*args, **kwargs):
    """dot(point p1, point p2) -> double"""
    return _cmf_core.dot(*args, **kwargs)

def distance(*args, **kwargs):
    """distance(point p1, point p2) -> double"""
    return _cmf_core.distance(*args, **kwargs)
class point_vector(object):
    """Proxy of C++ cmf::geometry::point_vector class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    X = _swig_property(_cmf_core.point_vector_X_get, _cmf_core.point_vector_X_set)
    Y = _swig_property(_cmf_core.point_vector_Y_get, _cmf_core.point_vector_Y_set)
    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"""
        _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"""
        return _cmf_core.point_vector_get(self, *args, **kwargs)


    def set(self, *args, **kwargs):
        """set(point_vector self, ptrdiff_t index, point p)"""
        return _cmf_core.point_vector_set(self, *args, **kwargs)


    def size(self, *args, **kwargs):
        """size(point_vector self) -> size_t"""
        return _cmf_core.point_vector_size(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_point_vector
point_vector.get = new_instancemethod(_cmf_core.point_vector_get, None, point_vector)
point_vector.set = new_instancemethod(_cmf_core.point_vector_set, None, point_vector)
point_vector.size = new_instancemethod(_cmf_core.point_vector_size, None, point_vector)
point_vector_swigregister = _cmf_core.point_vector_swigregister
point_vector_swigregister(point_vector)


import datetime
import struct


def minimum(*args, **kwargs):
    """minimum(real a, real b) -> real"""
    return _cmf_core.minimum(*args, **kwargs)

def maximum(*args, **kwargs):
    """maximum(real a, real b) -> real"""
    return _cmf_core.maximum(*args, **kwargs)

def minmax(*args, **kwargs):
    """minmax(real x, real min, real max) -> real"""
    return _cmf_core.minmax(*args, **kwargs)

def mean(*args, **kwargs):
    """mean(real a, real b) -> real"""
    return _cmf_core.mean(*args, **kwargs)

def geo_mean(*args, **kwargs):
    """geo_mean(real a, real b) -> real"""
    return _cmf_core.geo_mean(*args, **kwargs)

def harmonic_mean(*args, **kwargs):
    """harmonic_mean(real a, real b) -> real"""
    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"""
    return _cmf_core.piecewise_linear(*args, **kwargs)

def boltzmann(*args, **kwargs):
    """boltzmann(real x, real x_half, real tau) -> real"""
    return _cmf_core.boltzmann(*args, **kwargs)

def sign(*args, **kwargs):
    """sign(real x) -> real"""
    return _cmf_core.sign(*args, **kwargs)

def square(*args, **kwargs):
    """square(real x) -> real"""
    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."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ms_per_day = _cmf_core.Time_ms_per_day

    def __init__(self, *args):
        """
        __init__(cmf::math::Time self, int day, int month, int year, int hour=0, int minute=0, int second=0, int ms=0) -> Time
        __init__(cmf::math::Time self, Date date) -> Time
        __init__(cmf::math::Time self, Time t) -> Time
        __init__(cmf::math::Time self) -> Time
        """
        _cmf_core.Time_swiginit(self, _cmf_core.new_Time(*args))

    def AsDays(self, *args, **kwargs):
        """AsDays(Time self) -> double"""
        return _cmf_core.Time_AsDays(self, *args, **kwargs)


    def AsHours(self, *args, **kwargs):
        """AsHours(Time self) -> double"""
        return _cmf_core.Time_AsHours(self, *args, **kwargs)


    def AsMinutes(self, *args, **kwargs):
        """AsMinutes(Time self) -> double"""
        return _cmf_core.Time_AsMinutes(self, *args, **kwargs)


    def AsSeconds(self, *args, **kwargs):
        """AsSeconds(Time self) -> double"""
        return _cmf_core.Time_AsSeconds(self, *args, **kwargs)


    def AsMilliseconds(self, *args, **kwargs):
        """AsMilliseconds(Time self) -> long long"""
        return _cmf_core.Time_AsMilliseconds(self, *args, **kwargs)


    def AsDate(self, *args, **kwargs):
        """AsDate(Time self) -> Date"""
        return _cmf_core.Time_AsDate(self, *args, **kwargs)


    def to_string(self, *args, **kwargs):
        """to_string(Time self, char seperator) -> std::string"""
        return _cmf_core.Time_to_string(self, *args, **kwargs)


    def is_not_0(self, *args, **kwargs):
        """is_not_0(Time self) -> bool"""
        return _cmf_core.Time_is_not_0(self, *args, **kwargs)


    def DOY(self, *args, **kwargs):
        """DOY(Time self) -> double"""
        return _cmf_core.Time_DOY(self, *args, **kwargs)


    def __add__(self, *args, **kwargs):
        """__add__(Time self, Time t1) -> Time"""
        return _cmf_core.Time___add__(self, *args, **kwargs)


    def __sub__(self, *args, **kwargs):
        """__sub__(Time self, Time t1) -> Time"""
        return _cmf_core.Time___sub__(self, *args, **kwargs)


    def __iadd__(self, *args, **kwargs):
        """__iadd__(Time self, Time t1) -> Time"""
        return _cmf_core.Time___iadd__(self, *args, **kwargs)


    def __isub__(self, *args, **kwargs):
        """__isub__(Time self, Time t1) -> Time"""
        return _cmf_core.Time___isub__(self, *args, **kwargs)


    def __mod__(self, *args, **kwargs):
        """__mod__(Time self, Time t1) -> Time"""
        return _cmf_core.Time___mod__(self, *args, **kwargs)


    def __mul__(self, *args):
        """
        __mul__(Time self, double x) -> Time
        __mul__(Time self, long long x) -> Time
        __mul__(Time self, int x) -> Time
        """
        return _cmf_core.Time___mul__(self, *args)


    def __imul__(self, *args):
        """
        __imul__(Time self, double x) -> Time
        __imul__(Time self, long long x) -> Time
        __imul__(Time self, int x) -> Time
        """
        return _cmf_core.Time___imul__(self, *args)


    def __itruediv__(self, *args):
        return _cmf_core.Time___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __imod__(self, *args, **kwargs):
        """__imod__(Time self, Time t1) -> Time"""
        return _cmf_core.Time___imod__(self, *args, **kwargs)


    def __truediv__(self, *args):
        return _cmf_core.Time___truediv__(self, *args)
    __div__ = __truediv__



    def times_in(self, *args, **kwargs):
        """times_in(Time self, Time t1) -> long long"""
        return _cmf_core.Time_times_in(self, *args, **kwargs)


    def __lt__(self, *args, **kwargs):
        """__lt__(Time self, Time t1) -> bool"""
        return _cmf_core.Time___lt__(self, *args, **kwargs)


    def __gt__(self, *args, **kwargs):
        """__gt__(Time self, Time t1) -> bool"""
        return _cmf_core.Time___gt__(self, *args, **kwargs)


    def __le__(self, *args, **kwargs):
        """__le__(Time self, Time t1) -> bool"""
        return _cmf_core.Time___le__(self, *args, **kwargs)


    def __ge__(self, *args, **kwargs):
        """__ge__(Time self, Time t1) -> bool"""
        return _cmf_core.Time___ge__(self, *args, **kwargs)


    def __eq__(self, *args, **kwargs):
        """__eq__(Time self, Time t1) -> bool"""
        return _cmf_core.Time___eq__(self, *args, **kwargs)


    def __ne__(self, *args, **kwargs):
        """__ne__(Time self, Time t1) -> bool"""
        return _cmf_core.Time___ne__(self, *args, **kwargs)


    def __repr__(self):
        if self>year*40:
            return self.AsDate().to_string()
        else:
            return self.to_string()
    def __bool__(self):
        return self.is_not_0()
    def __rmul__(self,other):
        return self*other
    def __radd__(self,other):
        return self + other
    def AsPython(self):
        d=self.AsDate()
        return datetime.datetime(d.year,d.month,d.day,d.hour,d.minute,d.second,d.ms*1000)
    year   = property(lambda self: self.AsDate().year)
    month  = property(lambda self: self.AsDate().month)
    day    = property(lambda self: self.AsDate().day)
    hour   = property(lambda self: self.AsDate().hour)
    minute = property(lambda self: self.AsDate().minute)
    second = property(lambda self: self.AsDate().second)
    ms     = property(lambda self: self.AsDate().ms)

    __swig_destroy__ = _cmf_core.delete_Time
Time.AsDays = new_instancemethod(_cmf_core.Time_AsDays, None, Time)
Time.AsHours = new_instancemethod(_cmf_core.Time_AsHours, None, Time)
Time.AsMinutes = new_instancemethod(_cmf_core.Time_AsMinutes, None, Time)
Time.AsSeconds = new_instancemethod(_cmf_core.Time_AsSeconds, None, Time)
Time.AsMilliseconds = new_instancemethod(_cmf_core.Time_AsMilliseconds, None, Time)
Time.AsDate = new_instancemethod(_cmf_core.Time_AsDate, None, Time)
Time.to_string = new_instancemethod(_cmf_core.Time_to_string, None, Time)
Time.is_not_0 = new_instancemethod(_cmf_core.Time_is_not_0, None, Time)
Time.DOY = new_instancemethod(_cmf_core.Time_DOY, None, Time)
Time.__add__ = new_instancemethod(_cmf_core.Time___add__, None, Time)
Time.__sub__ = new_instancemethod(_cmf_core.Time___sub__, None, Time)
Time.__iadd__ = new_instancemethod(_cmf_core.Time___iadd__, None, Time)
Time.__isub__ = new_instancemethod(_cmf_core.Time___isub__, None, Time)
Time.__mod__ = new_instancemethod(_cmf_core.Time___mod__, None, Time)
Time.__mul__ = new_instancemethod(_cmf_core.Time___mul__, None, Time)
Time.__imul__ = new_instancemethod(_cmf_core.Time___imul__, None, Time)
Time.__imod__ = new_instancemethod(_cmf_core.Time___imod__, None, Time)
Time.times_in = new_instancemethod(_cmf_core.Time_times_in, None, Time)
Time.__lt__ = new_instancemethod(_cmf_core.Time___lt__, None, Time)
Time.__gt__ = new_instancemethod(_cmf_core.Time___gt__, None, Time)
Time.__le__ = new_instancemethod(_cmf_core.Time___le__, None, Time)
Time.__ge__ = new_instancemethod(_cmf_core.Time___ge__, None, Time)
Time.__eq__ = new_instancemethod(_cmf_core.Time___eq__, None, Time)
Time.__ne__ = new_instancemethod(_cmf_core.Time___ne__, None, Time)
Time_swigregister = _cmf_core.Time_swigregister
Time_swigregister(Time)
Debug = cvar.Debug
__compiledate__ = cvar.__compiledate__
Pi = cvar.Pi

class Date(object):
    """Proxy of C++ cmf::math::Date class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    year = _swig_property(_cmf_core.Date_year_get, _cmf_core.Date_year_set)
    month = _swig_property(_cmf_core.Date_month_get, _cmf_core.Date_month_set)
    day = _swig_property(_cmf_core.Date_day_get, _cmf_core.Date_day_set)
    hour = _swig_property(_cmf_core.Date_hour_get, _cmf_core.Date_hour_set)
    minute = _swig_property(_cmf_core.Date_minute_get, _cmf_core.Date_minute_set)
    second = _swig_property(_cmf_core.Date_second_get, _cmf_core.Date_second_set)
    ms = _swig_property(_cmf_core.Date_ms_get, _cmf_core.Date_ms_set)

    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
        """
        _cmf_core.Date_swiginit(self, _cmf_core.new_Date(*args))

    def ToTime(self, *args, **kwargs):
        """ToTime(Date self) -> Time"""
        return _cmf_core.Date_ToTime(self, *args, **kwargs)


    def DOY(self, *args, **kwargs):
        """DOY(Date self) -> double"""
        return _cmf_core.Date_DOY(self, *args, **kwargs)


    def to_string(self, *args, **kwargs):
        """to_string(Date self) -> std::string"""
        return _cmf_core.Date_to_string(self, *args, **kwargs)


    def __repr__(self):
        return self.to_string()
    def AsPython(self):
        return datetime.datetime(self.year,self.month,self.day,self.hour,self.minute,self.second,self.ms*1000)

    __swig_destroy__ = _cmf_core.delete_Date
Date.ToTime = new_instancemethod(_cmf_core.Date_ToTime, None, Date)
Date.DOY = new_instancemethod(_cmf_core.Date_DOY, None, Date)
Date.to_string = new_instancemethod(_cmf_core.Date_to_string, None, Date)
Date_swigregister = _cmf_core.Date_swigregister
Date_swigregister(Date)

class timeseries(object):
    """Proxy of C++ cmf::math::timeseries class."""

    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"""
        return _cmf_core.timeseries_interpolationpower(self, *args, **kwargs)


    def add(self, *args, **kwargs):
        """add(timeseries self, double Value)"""
        return _cmf_core.timeseries_add(self, *args, **kwargs)


    def is_empty(self, *args, **kwargs):
        """is_empty(timeseries self) -> bool"""
        return _cmf_core.timeseries_is_empty(self, *args, **kwargs)


    def clear(self, *args, **kwargs):
        """clear(timeseries self)"""
        return _cmf_core.timeseries_clear(self, *args, **kwargs)


    def adress(self, *args, **kwargs):
        """adress(timeseries self) -> size_t"""
        return _cmf_core.timeseries_adress(self, *args, **kwargs)


    def copy(self, *args, **kwargs):
        """copy(timeseries self) -> timeseries"""
        return _cmf_core.timeseries_copy(self, *args, **kwargs)


    def size(self, *args, **kwargs):
        """size(timeseries self) -> size_t"""
        return _cmf_core.timeseries_size(self, *args, **kwargs)


    def count_values(self, *args, **kwargs):
        """count_values(timeseries self) -> size_t"""
        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"""
        _cmf_core.timeseries_swiginit(self, _cmf_core.new_timeseries(*args, **kwargs))

    def from_array(*args, **kwargs):
        """from_array(Time begin, Time step, cmf::math::num_array const & data) -> timeseries"""
        return _cmf_core.timeseries_from_array(*args, **kwargs)

    from_array = staticmethod(from_array)

    def from_scalar(*args, **kwargs):
        """from_scalar(double scalar) -> timeseries"""
        return _cmf_core.timeseries_from_scalar(*args, **kwargs)

    from_scalar = staticmethod(from_scalar)

    def from_file(*args, **kwargs):
        """from_file(std::string filename) -> timeseries"""
        return _cmf_core.timeseries_from_file(*args, **kwargs)

    from_file = staticmethod(from_file)

    def get_t(self, *args, **kwargs):
        """get_t(timeseries self, Time t) -> double"""
        return _cmf_core.timeseries_get_t(self, *args, **kwargs)


    def get_i(self, *args, **kwargs):
        """get_i(timeseries self, ptrdiff_t i) -> double"""
        return _cmf_core.timeseries_get_i(self, *args, **kwargs)


    def set_t(self, *args, **kwargs):
        """set_t(timeseries self, 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)"""
        return _cmf_core.timeseries_set_i(self, *args, **kwargs)


    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
        """
        return _cmf_core.timeseries_get_slice(self, *args)


    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)
        """
        return _cmf_core.timeseries_set_slice(self, *args)


    def remove_nodata(self, *args, **kwargs):
        """remove_nodata(timeseries self, double nodata_value)"""
        return _cmf_core.timeseries_remove_nodata(self, *args, **kwargs)


    def __iadd__(self, *args):
        """
        __iadd__(timeseries self, timeseries arg2) -> timeseries
        __iadd__(timeseries self, double arg2) -> timeseries
        """
        return _cmf_core.timeseries___iadd__(self, *args)


    def __isub__(self, *args):
        """
        __isub__(timeseries self, timeseries arg2) -> timeseries
        __isub__(timeseries self, double arg2) -> timeseries
        """
        return _cmf_core.timeseries___isub__(self, *args)


    def __imul__(self, *args):
        """
        __imul__(timeseries self, timeseries arg2) -> timeseries
        __imul__(timeseries self, double arg2) -> timeseries
        """
        return _cmf_core.timeseries___imul__(self, *args)


    def __itruediv__(self, *args):
        return _cmf_core.timeseries___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __add__(self, *args):
        """
        __add__(timeseries self, timeseries arg2) -> timeseries
        __add__(timeseries self, double arg2) -> timeseries
        """
        return _cmf_core.timeseries___add__(self, *args)


    def __sub__(self, *args):
        """
        __sub__(timeseries self, timeseries arg2) -> timeseries
        __sub__(timeseries self, double arg2) -> timeseries
        """
        return _cmf_core.timeseries___sub__(self, *args)


    def __mul__(self, *args):
        """
        __mul__(timeseries self, timeseries arg2) -> timeseries
        __mul__(timeseries self, double arg2) -> timeseries
        """
        return _cmf_core.timeseries___mul__(self, *args)


    def __truediv__(self, *args):
        return _cmf_core.timeseries___truediv__(self, *args)
    __div__ = __truediv__



    def __neg__(self, *args, **kwargs):
        """__neg__(timeseries self) -> timeseries"""
        return _cmf_core.timeseries___neg__(self, *args, **kwargs)


    def inv(self, *args, **kwargs):
        """inv(timeseries self) -> timeseries"""
        return _cmf_core.timeseries_inv(self, *args, **kwargs)


    def reduce_min(self, *args, **kwargs):
        """reduce_min(timeseries self, Time begin, Time step) -> timeseries"""
        return _cmf_core.timeseries_reduce_min(self, *args, **kwargs)


    def reduce_max(self, *args, **kwargs):
        """reduce_max(timeseries self, Time begin, Time step) -> timeseries"""
        return _cmf_core.timeseries_reduce_max(self, *args, **kwargs)


    def reduce_sum(self, *args, **kwargs):
        """reduce_sum(timeseries self, Time begin, Time step) -> timeseries"""
        return _cmf_core.timeseries_reduce_sum(self, *args, **kwargs)


    def reduce_avg(self, *args, **kwargs):
        """reduce_avg(timeseries self, Time begin, Time step) -> timeseries"""
        return _cmf_core.timeseries_reduce_avg(self, *args, **kwargs)


    def floating_avg(self, *args):
        """
        floating_avg(timeseries self, Time window_width) -> timeseries
        floating_avg(timeseries self, size_t window_size) -> timeseries
        """
        return _cmf_core.timeseries_floating_avg(self, *args)


    def floating_max(self, *args, **kwargs):
        """floating_max(timeseries self, Time window_width) -> timeseries"""
        return _cmf_core.timeseries_floating_max(self, *args, **kwargs)


    def floating_min(self, *args, **kwargs):
        """floating_min(timeseries self, Time window_width) -> timeseries"""
        return _cmf_core.timeseries_floating_min(self, *args, **kwargs)


    def mean(self, *args, **kwargs):
        """mean(timeseries self) -> double"""
        return _cmf_core.timeseries_mean(self, *args, **kwargs)


    def min(self, *args, **kwargs):
        """min(timeseries self) -> double"""
        return _cmf_core.timeseries_min(self, *args, **kwargs)


    def max(self, *args, **kwargs):
        """max(timeseries self) -> double"""
        return _cmf_core.timeseries_max(self, *args, **kwargs)


    def log(self, *args, **kwargs):
        """log(timeseries self) -> timeseries"""
        return _cmf_core.timeseries_log(self, *args, **kwargs)


    def log10(self, *args, **kwargs):
        """log10(timeseries self) -> timeseries"""
        return _cmf_core.timeseries_log10(self, *args, **kwargs)


    def power(self, *args, **kwargs):
        """power(timeseries self, double exponent) -> timeseries"""
        return _cmf_core.timeseries_power(self, *args, **kwargs)


    def exp(self, *args, **kwargs):
        """exp(timeseries self) -> timeseries"""
        return _cmf_core.timeseries_exp(self, *args, **kwargs)

    begin = _swig_property(_cmf_core.timeseries_begin_get)
    step = _swig_property(_cmf_core.timeseries_step_get)
    end = _swig_property(_cmf_core.timeseries_end_get)

    def __len__(self, *args, **kwargs):
        """__len__(timeseries self) -> ptrdiff_t"""
        return _cmf_core.timeseries___len__(self, *args, **kwargs)


    def __repr__(self):
       return "cmf.timeseries(%s:%s:%s,count=%i)" % (self.begin,self.end,self.step,self.size())
    def extend(self,list) :
        """ Adds the values of a sequence to the timeseries"""
        for item in list :
            self.add(float(item))
    def __getitem__(self,index):
        if isinstance(index,int):
            return self.get_i(index)
        elif isinstance(index,slice):
            if index.step:
                return self.get_slice(index.start,index.stop,index.step)
            else:
                return self.get_slice(index.start,index.stop)
        else:
            return self.get_t(index)
    def __setitem__(self,index,value):
        if isinstance(index,int):
            self.set_i(index,value)
        elif isinstance(index,slice):
            if index.step:
                raise ValueError("Slices must be continous, when used for setting")
            else:
                if not isinstance(value,timeseries):
                    value=timeseries(value)
                self.set_slice(index.start,index.stop,value)
        else:
            self.set_t(index,value)
    def __iter__(self):
        for i in range(self.size()):
            yield self.get_i(i)
    def interpolate(self,begin,end,step):
        """ Returns a generator returning the interpolated values at the timesteps """
        if step>self.step():
            ts=self.reduce_avg(begin,step)
        else:
            ts=self
        for t in timerange(step,end,step):
            yield ts[t]
    def __radd__(self,other):
        return self + other;
    def __rmul__(self,other):
        return self + other;
    def __rsub__(self,other):
        res=-self
        res+=other
        return res
    def __rdiv__(self,other):
        res=self.inv() 
        res*=other
        return res
    def iter_time(self, as_float=0):
        """Returns an iterator to iterate over each timestep
        as_float if True, the timesteps will returned as floating point numbers representing the days after 1.1.0001 00:00
        """
        for i in range(len(self)):
            if as_float:
                yield ((self.begin + self.step * i) - cmf.Time(1,1,1)).AsDays()
            else:
                yield self.begin + self.step * i
    def to_buffer(self):
        """Returns a binary buffer filled with the data of self"""
        return struct.pack('qqqq%id' % self.size(),self.begin.AsMilliseconds(),self.step.AsMilliseconds(),self.interpolationpower(), *self)
    def to_file(self,f):
        """ Saves a timeseries in a special binary format.
        The format consists of 4 integers with 64 bit, indicating the milliseconds after the 31.12.1899 00:00 of the beginning of the timeseries, the milliseconds of the time step,
        the interpolation power and the number of values. The following 64 bit floats, are the values of the timeseries
        """
        if isinstance(f,str):
            f=open(f,'wb')
        elif not hasattr(f,'write'):
            raise TypeError("The file f must be either an object providing a write method, like a file, or a valid file name")
        f.write(struct.pack('qqqq%id' % self.size(),  self.size(), self.begin.AsMilliseconds(),self.step.AsMilliseconds(),self.interpolationpower(), *self))
    def to_pandas(self):
        """
        Returns the timeseries as a pandas Series object
        :return: A pandas.Series object with the timesteps as index
        """
        import pandas as pd
        import numpy as np

        return pd.Series(data=np.array(self),index=(t.AsPython() for t in self.iter_time()))

    @classmethod
    def from_sequence(cls,begin,step,sequence=[],interpolation_mode=1):
        res=cls(begin,step,interpolation_mode)
        res.extend(sequence)
        return res

    @classmethod
    def from_buffer(cls,buf):
        header_length=struct.calcsize('qqqq') 
        header=struct.unpack('qqqq',buffer[:header_length])
        res=cls(header[1]*ms,header[2]*ms,header[3])
        res.extend(struct.unpack('%id' % header[0],*buffer(buf,header_length,header[0]*8)))
        return res
    @classmethod
    def from_file(cls,f):
        """ Loads a timeseries saved with to_file from a file 
        Description of the file layout:
        byte: 
        0   Number of (int64)
        8   Begin of timeseries (in ms since 31.12.1899 00:00) (int64)
        16  Step size of timeseries (in ms) (int64)
        24  Interpolation power (int64)
        32  First value of timeseries (float64)
        """
        if isinstance(f,str):
            f=open(f,'rb')
        elif not hasattr(f,'read'):
            raise TypeError("The file f must either implement a 'read' method, like a file, or must be a vild file name")
        header_length=struct.calcsize('qqqq') 
        header=struct.unpack('qqqq',f.read(header_length))
        res=cls(header[1]*ms,header[2]*ms,header[3])
        res.extend(struct.unpack('%id' % header[0],f.read(-1)))
        return res

    __swig_destroy__ = _cmf_core.delete_timeseries
timeseries.interpolationpower = new_instancemethod(_cmf_core.timeseries_interpolationpower, None, timeseries)
timeseries.add = new_instancemethod(_cmf_core.timeseries_add, None, timeseries)
timeseries.is_empty = new_instancemethod(_cmf_core.timeseries_is_empty, None, timeseries)
timeseries.clear = new_instancemethod(_cmf_core.timeseries_clear, None, timeseries)
timeseries.adress = new_instancemethod(_cmf_core.timeseries_adress, None, timeseries)
timeseries.copy = new_instancemethod(_cmf_core.timeseries_copy, None, timeseries)
timeseries.size = new_instancemethod(_cmf_core.timeseries_size, None, timeseries)
timeseries.count_values = new_instancemethod(_cmf_core.timeseries_count_values, None, timeseries)
timeseries.get_t = new_instancemethod(_cmf_core.timeseries_get_t, None, timeseries)
timeseries.get_i = new_instancemethod(_cmf_core.timeseries_get_i, None, timeseries)
timeseries.set_t = new_instancemethod(_cmf_core.timeseries_set_t, None, timeseries)
timeseries.set_i = new_instancemethod(_cmf_core.timeseries_set_i, None, timeseries)
timeseries.get_slice = new_instancemethod(_cmf_core.timeseries_get_slice, None, timeseries)
timeseries.set_slice = new_instancemethod(_cmf_core.timeseries_set_slice, None, timeseries)
timeseries.remove_nodata = new_instancemethod(_cmf_core.timeseries_remove_nodata, None, timeseries)
timeseries.__iadd__ = new_instancemethod(_cmf_core.timeseries___iadd__, None, timeseries)
timeseries.__isub__ = new_instancemethod(_cmf_core.timeseries___isub__, None, timeseries)
timeseries.__imul__ = new_instancemethod(_cmf_core.timeseries___imul__, None, timeseries)
timeseries.__add__ = new_instancemethod(_cmf_core.timeseries___add__, None, timeseries)
timeseries.__sub__ = new_instancemethod(_cmf_core.timeseries___sub__, None, timeseries)
timeseries.__mul__ = new_instancemethod(_cmf_core.timeseries___mul__, None, timeseries)
timeseries.__neg__ = new_instancemethod(_cmf_core.timeseries___neg__, None, timeseries)
timeseries.inv = new_instancemethod(_cmf_core.timeseries_inv, None, timeseries)
timeseries.reduce_min = new_instancemethod(_cmf_core.timeseries_reduce_min, None, timeseries)
timeseries.reduce_max = new_instancemethod(_cmf_core.timeseries_reduce_max, None, timeseries)
timeseries.reduce_sum = new_instancemethod(_cmf_core.timeseries_reduce_sum, None, timeseries)
timeseries.reduce_avg = new_instancemethod(_cmf_core.timeseries_reduce_avg, None, timeseries)
timeseries.floating_avg = new_instancemethod(_cmf_core.timeseries_floating_avg, None, timeseries)
timeseries.floating_max = new_instancemethod(_cmf_core.timeseries_floating_max, None, timeseries)
timeseries.floating_min = new_instancemethod(_cmf_core.timeseries_floating_min, None, timeseries)
timeseries.mean = new_instancemethod(_cmf_core.timeseries_mean, None, timeseries)
timeseries.min = new_instancemethod(_cmf_core.timeseries_min, None, timeseries)
timeseries.max = new_instancemethod(_cmf_core.timeseries_max, None, timeseries)
timeseries.log = new_instancemethod(_cmf_core.timeseries_log, None, timeseries)
timeseries.log10 = new_instancemethod(_cmf_core.timeseries_log10, None, timeseries)
timeseries.power = new_instancemethod(_cmf_core.timeseries_power, None, timeseries)
timeseries.exp = new_instancemethod(_cmf_core.timeseries_exp, None, timeseries)
timeseries.__len__ = new_instancemethod(_cmf_core.timeseries___len__, None, timeseries)
timeseries_swigregister = _cmf_core.timeseries_swigregister
timeseries_swigregister(timeseries)
ms = cvar.ms
sec = cvar.sec
min = cvar.min
h = cvar.h
day = cvar.day
week = cvar.week
year = cvar.year
month = cvar.month
never = cvar.never

def timeseries_from_array(*args, **kwargs):
    """timeseries_from_array(Time begin, Time step, cmf::math::num_array const & data) -> timeseries"""
    return _cmf_core.timeseries_from_array(*args, **kwargs)

def timeseries_from_scalar(*args, **kwargs):
    """timeseries_from_scalar(double scalar) -> timeseries"""
    return _cmf_core.timeseries_from_scalar(*args, **kwargs)

def timeseries_from_file(*args, **kwargs):
    """timeseries_from_file(std::string filename) -> timeseries"""
    return _cmf_core.timeseries_from_file(*args, **kwargs)


def nash_sutcliffe(*args, **kwargs):
    """nash_sutcliffe(timeseries model, timeseries observation) -> double"""
    return _cmf_core.nash_sutcliffe(*args, **kwargs)

def AsCMFtime(date):
    """Converts a python datetime to cmf.Time"""
    return Time(date.day,date.month,date.year,date.hour,date.minute,date.second,date.microsecond/1000)
def timerange(start,end,step=day):
    """Creates a generator of cmf.Time, similar to the Python range function"""
    return [start+step*x for x in range(0,int((end-start)/step))]
def xtimerange(start,end,step=day):
    """Creates a generator of cmf.Time, similar to the Python range function"""
    return (start+step*x for x in range(0,int((end-start)/step)))

class integratable(object):
    """Proxy of C++ cmf::math::integratable class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def integrate(self, *args, **kwargs):
        """integrate(integratable self, Time t)"""
        return _cmf_core.integratable_integrate(self, *args, **kwargs)


    def reset(self, *args, **kwargs):
        """reset(integratable self, Time t)"""
        return _cmf_core.integratable_reset(self, *args, **kwargs)


    def sum(self, *args, **kwargs):
        """sum(integratable self) -> double"""
        return _cmf_core.integratable_sum(self, *args, **kwargs)


    def avg(self, *args, **kwargs):
        """avg(integratable self) -> double"""
        return _cmf_core.integratable_avg(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_integratable
integratable.integrate = new_instancemethod(_cmf_core.integratable_integrate, None, integratable)
integratable.reset = new_instancemethod(_cmf_core.integratable_reset, None, integratable)
integratable.sum = new_instancemethod(_cmf_core.integratable_sum, None, integratable)
integratable.avg = new_instancemethod(_cmf_core.integratable_avg, None, integratable)
integratable_swigregister = _cmf_core.integratable_swigregister
integratable_swigregister(integratable)

class integratable_list(object):
    """Proxy of C++ cmf::math::integratable_list class."""

    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)"""
        return _cmf_core.integratable_list_append(self, *args, **kwargs)


    def remove(self, *args, **kwargs):
        """remove(integratable_list self, cmf::math::integratable::ptr rm)"""
        return _cmf_core.integratable_list_remove(self, *args, **kwargs)


    def __getitem(self, *args, **kwargs):
        """__getitem(integratable_list self, int index) -> cmf::math::integratable::ptr"""
        return _cmf_core.integratable_list___getitem(self, *args, **kwargs)


    def size(self, *args, **kwargs):
        """size(integratable_list self) -> size_t"""
        return _cmf_core.integratable_list_size(self, *args, **kwargs)


    def avg(self, *args, **kwargs):
        """avg(integratable_list self) -> cmf::math::num_array"""
        return _cmf_core.integratable_list_avg(self, *args, **kwargs)


    def sum(self, *args, **kwargs):
        """sum(integratable_list self) -> cmf::math::num_array"""
        return _cmf_core.integratable_list_sum(self, *args, **kwargs)


    def reset(self, *args, **kwargs):
        """reset(integratable_list self, Time t)"""
        return _cmf_core.integratable_list_reset(self, *args, **kwargs)


    def integrate(self, *args, **kwargs):
        """integrate(integratable_list self, Time t)"""
        return _cmf_core.integratable_list_integrate(self, *args, **kwargs)


    def __init__(self, *args):
        """
        __init__(cmf::math::integratable_list self) -> integratable_list
        __init__(cmf::math::integratable_list self, integratable_list for_copy) -> integratable_list
        """
        _cmf_core.integratable_list_swiginit(self, _cmf_core.new_integratable_list(*args))

    def __len__(self, *args, **kwargs):
        """__len__(integratable_list self) -> size_t"""
        return _cmf_core.integratable_list___len__(self, *args, **kwargs)


    def __iter__(self):
        for i in range(len(self)):
            yield self[i]
    def __getitem__(self,index):
        if isinstance(index,slice):
            return [self.__getitem(i) for i in range(*index.indices(len(self)))]
        else:
            try:
                it=iter(index)
                return [self.__getitem(i) for i in it]
            except:
                return self.__getitem(index)

    __swig_destroy__ = _cmf_core.delete_integratable_list
integratable_list.append = new_instancemethod(_cmf_core.integratable_list_append, None, integratable_list)
integratable_list.remove = new_instancemethod(_cmf_core.integratable_list_remove, None, integratable_list)
integratable_list.__getitem = new_instancemethod(_cmf_core.integratable_list___getitem, None, integratable_list)
integratable_list.size = new_instancemethod(_cmf_core.integratable_list_size, None, integratable_list)
integratable_list.avg = new_instancemethod(_cmf_core.integratable_list_avg, None, integratable_list)
integratable_list.sum = new_instancemethod(_cmf_core.integratable_list_sum, None, integratable_list)
integratable_list.reset = new_instancemethod(_cmf_core.integratable_list_reset, None, integratable_list)
integratable_list.integrate = new_instancemethod(_cmf_core.integratable_list_integrate, None, integratable_list)
integratable_list.__len__ = new_instancemethod(_cmf_core.integratable_list___len__, None, integratable_list)
integratable_list_swigregister = _cmf_core.integratable_list_swigregister
integratable_list_swigregister(integratable_list)

class StateVariable(object):
    """Proxy of C++ cmf::math::StateVariable class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def dxdt(self, *args, **kwargs):
        """dxdt(StateVariable self, Time time) -> real"""
        return _cmf_core.StateVariable_dxdt(self, *args, **kwargs)


    def get_abs_errtol(self, *args, **kwargs):
        """get_abs_errtol(StateVariable self, real rel_errtol) -> real"""
        return _cmf_core.StateVariable_get_abs_errtol(self, *args, **kwargs)


    def to_string(self, *args, **kwargs):
        """to_string(StateVariable self) -> std::string"""
        return _cmf_core.StateVariable_to_string(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_StateVariable
    state = _swig_property(_cmf_core.StateVariable_state_get, _cmf_core.StateVariable_state_set)

    def __repr__(self): 
        return self.to_string()

StateVariable.dxdt = new_instancemethod(_cmf_core.StateVariable_dxdt, None, StateVariable)
StateVariable.get_abs_errtol = new_instancemethod(_cmf_core.StateVariable_get_abs_errtol, None, StateVariable)
StateVariable.to_string = new_instancemethod(_cmf_core.StateVariable_to_string, None, StateVariable)
StateVariable_swigregister = _cmf_core.StateVariable_swigregister
StateVariable_swigregister(StateVariable)

class StateVariableOwner(object):
    """Proxy of C++ cmf::math::StateVariableOwner class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def get_states(self, *args, **kwargs):
        """get_states(StateVariableOwner self) -> StateVariableList"""
        return _cmf_core.StateVariableOwner_get_states(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_StateVariableOwner
StateVariableOwner.get_states = new_instancemethod(_cmf_core.StateVariableOwner_get_states, None, StateVariableOwner)
StateVariableOwner_swigregister = _cmf_core.StateVariableOwner_swigregister
StateVariableOwner_swigregister(StateVariableOwner)

class StateVariableList(StateVariableOwner):
    """Proxy of C++ cmf::math::StateVariableList class."""

    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(StateVariableList self, cmf::math::StateVariable::ptr sv)"""
        return _cmf_core.StateVariableList_append(self, *args, **kwargs)


    def extend(self, *args, **kwargs):
        """extend(StateVariableList self, StateVariableOwner svo)"""
        return _cmf_core.StateVariableList_extend(self, *args, **kwargs)


    def __iadd__(self, *args):
        """
        __iadd__(StateVariableList self, StateVariableList food) -> StateVariableList
        __iadd__(StateVariableList self, StateVariableOwner svo) -> StateVariableList
        """
        return _cmf_core.StateVariableList___iadd__(self, *args)


    def size(self, *args, **kwargs):
        """size(StateVariableList self) -> size_t"""
        return _cmf_core.StateVariableList_size(self, *args, **kwargs)


    def __len__(self, *args, **kwargs):
        """__len__(StateVariableList self) -> size_t"""
        return _cmf_core.StateVariableList___len__(self, *args, **kwargs)


    def __init__(self, *args, **kwargs):
        """__init__(cmf::math::StateVariableList self) -> StateVariableList"""
        _cmf_core.StateVariableList_swiginit(self, _cmf_core.new_StateVariableList(*args, **kwargs))
    __swig_destroy__ = _cmf_core.delete_StateVariableList
StateVariableList.append = new_instancemethod(_cmf_core.StateVariableList_append, None, StateVariableList)
StateVariableList.extend = new_instancemethod(_cmf_core.StateVariableList_extend, None, StateVariableList)
StateVariableList.__iadd__ = new_instancemethod(_cmf_core.StateVariableList___iadd__, None, StateVariableList)
StateVariableList.size = new_instancemethod(_cmf_core.StateVariableList_size, None, StateVariableList)
StateVariableList.__len__ = new_instancemethod(_cmf_core.StateVariableList___len__, None, StateVariableList)
StateVariableList_swigregister = _cmf_core.StateVariableList_swigregister
StateVariableList_swigregister(StateVariableList)

class Integrator(StateVariableOwner):
    """Proxy of C++ cmf::math::Integrator class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def get_dxdt(self, *args, **kwargs):
        """get_dxdt(Integrator self, Time time) -> cmf::math::num_array"""
        return _cmf_core.Integrator_get_dxdt(self, *args, **kwargs)


    def add_states(self, *args, **kwargs):
        """add_states(Integrator self, StateVariableOwner stateOwner)"""
        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)"""
        return _cmf_core.Integrator_add_single_state(self, *args, **kwargs)

    integratables = _swig_property(_cmf_core.Integrator_integratables_get, _cmf_core.Integrator_integratables_set)
    reset_integratables = _swig_property(_cmf_core.Integrator_reset_integratables_get, _cmf_core.Integrator_reset_integratables_set)
    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"""
        return _cmf_core.Integrator_size(self, *args, **kwargs)


    def get_state(self, *args, **kwargs):
        """get_state(Integrator self, ptrdiff_t position) -> real"""
        return _cmf_core.Integrator_get_state(self, *args, **kwargs)


    def set_state(self, *args, **kwargs):
        """set_state(Integrator self, ptrdiff_t position, real newState)"""
        return _cmf_core.Integrator_set_state(self, *args, **kwargs)


    def get_states(self, *args):
        """
        get_states(Integrator self) -> cmf::math::num_array
        get_states(Integrator self) -> StateVariableList
        """
        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"""
        return _cmf_core.Integrator_get_t(self, *args, **kwargs)


    def set_t(self, *args, **kwargs):
        """set_t(Integrator self, Time val)"""
        return _cmf_core.Integrator_set_t(self, *args, **kwargs)


    def get_dt(self, *args, **kwargs):
        """get_dt(Integrator self) -> Time"""
        return _cmf_core.Integrator_get_dt(self, *args, **kwargs)


    def reset(self, *args, **kwargs):
        """reset(Integrator self)"""
        return _cmf_core.Integrator_reset(self, *args, **kwargs)


    def copy(self, *args, **kwargs):
        """copy(Integrator self) -> Integrator"""
        return _cmf_core.Integrator_copy(self, *args, **kwargs)


    def integrate(self, *args, **kwargs):
        """integrate(Integrator self, Time t_max, Time dt) -> int"""
        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)"""
        return _cmf_core.Integrator_integrate_until(self, *args, **kwargs)


    def __getitem__(self, *args, **kwargs):
        """__getitem__(Integrator self, int index) -> cmf::math::StateVariable::ptr"""
        return _cmf_core.Integrator___getitem__(self, *args, **kwargs)


    def __call__(self,t,reset=False):
        if t<self.t:
            self.integrate_until(self.t+t,reset=reset)
        else:
            self.integrate_until(t,reset=reset)
        return self.t
    t = property(get_t,set_t,doc="Sets the actual time of the solution")
    dt = property(get_dt,doc="Get the current time step of the solver")
    def run(self,start=None,end=None,step=day*1):
        if not start is None:
            self.t=start
        if end is None:
            end = self.t + 100*step
        while self.t<end:
            self(self.t+step)
            yield self.t

Integrator.get_dxdt = new_instancemethod(_cmf_core.Integrator_get_dxdt, None, Integrator)
Integrator.add_states = new_instancemethod(_cmf_core.Integrator_add_states, None, Integrator)
Integrator.add_single_state = new_instancemethod(_cmf_core.Integrator_add_single_state, None, Integrator)
Integrator.size = new_instancemethod(_cmf_core.Integrator_size, None, Integrator)
Integrator.get_state = new_instancemethod(_cmf_core.Integrator_get_state, None, Integrator)
Integrator.set_state = new_instancemethod(_cmf_core.Integrator_set_state, None, Integrator)
Integrator.get_states = new_instancemethod(_cmf_core.Integrator_get_states, None, Integrator)
Integrator.get_t = new_instancemethod(_cmf_core.Integrator_get_t, None, Integrator)
Integrator.set_t = new_instancemethod(_cmf_core.Integrator_set_t, None, Integrator)
Integrator.get_dt = new_instancemethod(_cmf_core.Integrator_get_dt, None, Integrator)
Integrator.reset = new_instancemethod(_cmf_core.Integrator_reset, None, Integrator)
Integrator.copy = new_instancemethod(_cmf_core.Integrator_copy, None, Integrator)
Integrator.integrate = new_instancemethod(_cmf_core.Integrator_integrate, None, Integrator)
Integrator.integrate_until = new_instancemethod(_cmf_core.Integrator_integrate_until, None, Integrator)
Integrator.__getitem__ = new_instancemethod(_cmf_core.Integrator___getitem__, None, Integrator)
Integrator_swigregister = _cmf_core.Integrator_swigregister
Integrator_swigregister(Integrator)

class BDF2(Integrator):
    """Proxy of C++ cmf::math::BDF2 class."""

    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"""
        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)

    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.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."""

    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):
        """
        __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
        """
        _cmf_core.ExplicitEuler_fixed_swiginit(self, _cmf_core.new_ExplicitEuler_fixed(*args))
    __swig_destroy__ = _cmf_core.delete_ExplicitEuler_fixed
ExplicitEuler_fixed_swigregister = _cmf_core.ExplicitEuler_fixed_swigregister
ExplicitEuler_fixed_swigregister(ExplicitEuler_fixed)

class HeunIntegrator(Integrator):
    """Proxy of C++ cmf::math::HeunIntegrator class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    alpha = _swig_property(_cmf_core.HeunIntegrator_alpha_get, _cmf_core.HeunIntegrator_alpha_set)

    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
        """
        _cmf_core.HeunIntegrator_swiginit(self, _cmf_core.new_HeunIntegrator(*args))
    __swig_destroy__ = _cmf_core.delete_HeunIntegrator
HeunIntegrator_swigregister = _cmf_core.HeunIntegrator_swigregister
HeunIntegrator_swigregister(HeunIntegrator)

class ImplicitEuler(Integrator):
    """Proxy of C++ cmf::math::ImplicitEuler class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    dt_min = _swig_property(_cmf_core.ImplicitEuler_dt_min_get, _cmf_core.ImplicitEuler_dt_min_set)

    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
        """
        _cmf_core.ImplicitEuler_swiginit(self, _cmf_core.new_ImplicitEuler(*args))
    __swig_destroy__ = _cmf_core.delete_ImplicitEuler
ImplicitEuler_swigregister = _cmf_core.ImplicitEuler_swigregister
ImplicitEuler_swigregister(ImplicitEuler)

class RKFIntegrator(Integrator):
    """Proxy of C++ cmf::math::RKFIntegrator 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):
        """
        __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
        """
        _cmf_core.RKFIntegrator_swiginit(self, _cmf_core.new_RKFIntegrator(*args))
    __swig_destroy__ = _cmf_core.delete_RKFIntegrator
RKFIntegrator_swigregister = _cmf_core.RKFIntegrator_swigregister
RKFIntegrator_swigregister(RKFIntegrator)

class CVodeIntegrator(Integrator):
    """Proxy of C++ cmf::math::CVodeIntegrator class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    preconditioner = _swig_property(_cmf_core.CVodeIntegrator_preconditioner_get, _cmf_core.CVodeIntegrator_preconditioner_set)
    MaxNonLinearIterations = _swig_property(_cmf_core.CVodeIntegrator_MaxNonLinearIterations_get, _cmf_core.CVodeIntegrator_MaxNonLinearIterations_set)
    MaxConvergenceFailures = _swig_property(_cmf_core.CVodeIntegrator_MaxConvergenceFailures_get, _cmf_core.CVodeIntegrator_MaxConvergenceFailures_set)
    MaxErrorTestFailures = _swig_property(_cmf_core.CVodeIntegrator_MaxErrorTestFailures_get, _cmf_core.CVodeIntegrator_MaxErrorTestFailures_set)
    maxl = _swig_property(_cmf_core.CVodeIntegrator_maxl_get, _cmf_core.CVodeIntegrator_maxl_set)
    LinearSolver = _swig_property(_cmf_core.CVodeIntegrator_LinearSolver_get, _cmf_core.CVodeIntegrator_LinearSolver_set)
    MaxOrder = _swig_property(_cmf_core.CVodeIntegrator_MaxOrder_get, _cmf_core.CVodeIntegrator_MaxOrder_set)
    max_step = _swig_property(_cmf_core.CVodeIntegrator_max_step_get, _cmf_core.CVodeIntegrator_max_step_set)

    def initialize(self, *args, **kwargs):
        """initialize(CVodeIntegrator self)"""
        return _cmf_core.CVodeIntegrator_initialize(self, *args, **kwargs)


    def release(self, *args, **kwargs):
        """release(CVodeIntegrator self)"""
        return _cmf_core.CVodeIntegrator_release(self, *args, **kwargs)


    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
        """
        _cmf_core.CVodeIntegrator_swiginit(self, _cmf_core.new_CVodeIntegrator(*args))

    def get_error(self, *args, **kwargs):
        """get_error(CVodeIntegrator self) -> cmf::math::num_array"""
        return _cmf_core.CVodeIntegrator_get_error(self, *args, **kwargs)


    def get_nonlinear_iterations(self, *args, **kwargs):
        """get_nonlinear_iterations(CVodeIntegrator self) -> int"""
        return _cmf_core.CVodeIntegrator_get_nonlinear_iterations(self, *args, **kwargs)


    def get_rhsevals(self, *args, **kwargs):
        """get_rhsevals(CVodeIntegrator self) -> int"""
        return _cmf_core.CVodeIntegrator_get_rhsevals(self, *args, **kwargs)


    def copy(self, *args, **kwargs):
        """copy(CVodeIntegrator self) -> CVodeIntegrator"""
        return _cmf_core.CVodeIntegrator_copy(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_CVodeIntegrator
    order = _swig_property(_cmf_core.CVodeIntegrator_order_get)
CVodeIntegrator.initialize = new_instancemethod(_cmf_core.CVodeIntegrator_initialize, None, CVodeIntegrator)
CVodeIntegrator.release = new_instancemethod(_cmf_core.CVodeIntegrator_release, None, CVodeIntegrator)
CVodeIntegrator.get_error = new_instancemethod(_cmf_core.CVodeIntegrator_get_error, None, CVodeIntegrator)
CVodeIntegrator.get_nonlinear_iterations = new_instancemethod(_cmf_core.CVodeIntegrator_get_nonlinear_iterations, None, CVodeIntegrator)
CVodeIntegrator.get_rhsevals = new_instancemethod(_cmf_core.CVodeIntegrator_get_rhsevals, None, CVodeIntegrator)
CVodeIntegrator.copy = new_instancemethod(_cmf_core.CVodeIntegrator_copy, None, CVodeIntegrator)
CVodeIntegrator_swigregister = _cmf_core.CVodeIntegrator_swigregister
CVodeIntegrator_swigregister(CVodeIntegrator)

class MultiIntegrator(Integrator):
    """Proxy of C++ cmf::math::MultiIntegrator class."""

    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"""
        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)"""
        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"""
        _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)
MultiIntegrator.add_states_to_integrator = new_instancemethod(_cmf_core.MultiIntegrator_add_states_to_integrator, None, MultiIntegrator)
MultiIntegrator_swigregister = _cmf_core.MultiIntegrator_swigregister
MultiIntegrator_swigregister(MultiIntegrator)

class Adsorption(object):
    """Proxy of C++ cmf::water::Adsorption class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def freesolute(self, *args, **kwargs):
        """freesolute(Adsorption self, real xt, real V) -> real"""
        return _cmf_core.Adsorption_freesolute(self, *args, **kwargs)


    def totalsolute(self, *args, **kwargs):
        """totalsolute(Adsorption self, real xf, real V) -> real"""
        return _cmf_core.Adsorption_totalsolute(self, *args, **kwargs)


    def copy(self, *args, **kwargs):
        """copy(Adsorption self, real m=-1) -> Adsorption"""
        return _cmf_core.Adsorption_copy(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_Adsorption
Adsorption.freesolute = new_instancemethod(_cmf_core.Adsorption_freesolute, None, Adsorption)
Adsorption.totalsolute = new_instancemethod(_cmf_core.Adsorption_totalsolute, None, Adsorption)
Adsorption.copy = new_instancemethod(_cmf_core.Adsorption_copy, None, Adsorption)
Adsorption_swigregister = _cmf_core.Adsorption_swigregister
Adsorption_swigregister(Adsorption)

class NullAdsorption(Adsorption):
    """Proxy of C++ cmf::water::NullAdsorption class."""

    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"""
        return _cmf_core.NullAdsorption_copy(self, *args, **kwargs)


    def __init__(self, *args, **kwargs):
        """__init__(cmf::water::NullAdsorption self) -> NullAdsorption"""
        _cmf_core.NullAdsorption_swiginit(self, _cmf_core.new_NullAdsorption(*args, **kwargs))
    __swig_destroy__ = _cmf_core.delete_NullAdsorption
NullAdsorption.copy = new_instancemethod(_cmf_core.NullAdsorption_copy, None, NullAdsorption)
NullAdsorption_swigregister = _cmf_core.NullAdsorption_swigregister
NullAdsorption_swigregister(NullAdsorption)

class LinearAdsorption(Adsorption):
    """Proxy of C++ cmf::water::LinearAdsorption class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    K = _swig_property(_cmf_core.LinearAdsorption_K_get, _cmf_core.LinearAdsorption_K_set)
    m = _swig_property(_cmf_core.LinearAdsorption_m_get, _cmf_core.LinearAdsorption_m_set)

    def __init__(self, *args):
        """
        __init__(cmf::water::LinearAdsorption self, real K, real m) -> LinearAdsorption
        __init__(cmf::water::LinearAdsorption self, LinearAdsorption other) -> LinearAdsorption
        """
        _cmf_core.LinearAdsorption_swiginit(self, _cmf_core.new_LinearAdsorption(*args))

    def copy(self, *args, **kwargs):
        """copy(LinearAdsorption self, real m=-1) -> LinearAdsorption"""
        return _cmf_core.LinearAdsorption_copy(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_LinearAdsorption
LinearAdsorption.copy = new_instancemethod(_cmf_core.LinearAdsorption_copy, None, LinearAdsorption)
LinearAdsorption_swigregister = _cmf_core.LinearAdsorption_swigregister
LinearAdsorption_swigregister(LinearAdsorption)

class FreundlichAdsorbtion(Adsorption):
    """Proxy of C++ cmf::water::FreundlichAdsorbtion class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    K = _swig_property(_cmf_core.FreundlichAdsorbtion_K_get, _cmf_core.FreundlichAdsorbtion_K_set)
    n = _swig_property(_cmf_core.FreundlichAdsorbtion_n_get, _cmf_core.FreundlichAdsorbtion_n_set)
    m = _swig_property(_cmf_core.FreundlichAdsorbtion_m_get, _cmf_core.FreundlichAdsorbtion_m_set)
    epsilon = _swig_property(_cmf_core.FreundlichAdsorbtion_epsilon_get, _cmf_core.FreundlichAdsorbtion_epsilon_set)
    maxiter = _swig_property(_cmf_core.FreundlichAdsorbtion_maxiter_get, _cmf_core.FreundlichAdsorbtion_maxiter_set)

    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
        """
        _cmf_core.FreundlichAdsorbtion_swiginit(self, _cmf_core.new_FreundlichAdsorbtion(*args))

    def copy(self, *args, **kwargs):
        """copy(FreundlichAdsorbtion self, real m=-1) -> FreundlichAdsorbtion"""
        return _cmf_core.FreundlichAdsorbtion_copy(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_FreundlichAdsorbtion
FreundlichAdsorbtion.copy = new_instancemethod(_cmf_core.FreundlichAdsorbtion_copy, None, FreundlichAdsorbtion)
FreundlichAdsorbtion_swigregister = _cmf_core.FreundlichAdsorbtion_swigregister
FreundlichAdsorbtion_swigregister(FreundlichAdsorbtion)

class LangmuirAdsorption(Adsorption):
    """Proxy of C++ cmf::water::LangmuirAdsorption class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    K = _swig_property(_cmf_core.LangmuirAdsorption_K_get, _cmf_core.LangmuirAdsorption_K_set)
    m = _swig_property(_cmf_core.LangmuirAdsorption_m_get, _cmf_core.LangmuirAdsorption_m_set)

    def __init__(self, *args):
        """
        __init__(cmf::water::LangmuirAdsorption self, real K, real m) -> LangmuirAdsorption
        __init__(cmf::water::LangmuirAdsorption self, LangmuirAdsorption other) -> LangmuirAdsorption
        """
        _cmf_core.LangmuirAdsorption_swiginit(self, _cmf_core.new_LangmuirAdsorption(*args))

    def copy(self, *args, **kwargs):
        """copy(LangmuirAdsorption self, real m=-1) -> LangmuirAdsorption"""
        return _cmf_core.LangmuirAdsorption_copy(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_LangmuirAdsorption
LangmuirAdsorption.copy = new_instancemethod(_cmf_core.LangmuirAdsorption_copy, None, LangmuirAdsorption)
LangmuirAdsorption_swigregister = _cmf_core.LangmuirAdsorption_swigregister
LangmuirAdsorption_swigregister(LangmuirAdsorption)

class solute(object):
    """Proxy of C++ cmf::water::solute class."""

    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"""
        _cmf_core.solute_swiginit(self, _cmf_core.new_solute(*args, **kwargs))

    def __eq__(self, *args, **kwargs):
        """__eq__(solute self, solute cmp) -> bool"""
        return _cmf_core.solute___eq__(self, *args, **kwargs)


    def __lt__(self, *args, **kwargs):
        """__lt__(solute self, solute cmp) -> bool"""
        return _cmf_core.solute___lt__(self, *args, **kwargs)


    def __gt__(self, *args, **kwargs):
        """__gt__(solute self, solute cmp) -> bool"""
        return _cmf_core.solute___gt__(self, *args, **kwargs)


    def __le__(self, *args, **kwargs):
        """__le__(solute self, solute cmp) -> bool"""
        return _cmf_core.solute___le__(self, *args, **kwargs)


    def __ge__(self, *args, **kwargs):
        """__ge__(solute self, solute cmp) -> bool"""
        return _cmf_core.solute___ge__(self, *args, **kwargs)


    def __ne__(self, *args, **kwargs):
        """__ne__(solute self, solute cmp) -> bool"""
        return _cmf_core.solute___ne__(self, *args, **kwargs)

    Name = _swig_property(_cmf_core.solute_Name_get, _cmf_core.solute_Name_set)
    Unit = _swig_property(_cmf_core.solute_Unit_get, _cmf_core.solute_Unit_set)
    Uptake = _swig_property(_cmf_core.solute_Uptake_get, _cmf_core.solute_Uptake_set)
    Id = _swig_property(_cmf_core.solute_Id_get)

    def __repr__(self, *args, **kwargs):
        """__repr__(solute self) -> std::string"""
        return _cmf_core.solute___repr__(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_solute
solute.__eq__ = new_instancemethod(_cmf_core.solute___eq__, None, solute)
solute.__lt__ = new_instancemethod(_cmf_core.solute___lt__, None, solute)
solute.__gt__ = new_instancemethod(_cmf_core.solute___gt__, None, solute)
solute.__le__ = new_instancemethod(_cmf_core.solute___le__, None, solute)
solute.__ge__ = new_instancemethod(_cmf_core.solute___ge__, None, solute)
solute.__ne__ = new_instancemethod(_cmf_core.solute___ne__, None, solute)
solute.__repr__ = new_instancemethod(_cmf_core.solute___repr__, None, solute)
solute_swigregister = _cmf_core.solute_swigregister
solute_swigregister(solute)

class solute_vector(object):
    """Proxy of C++ cmf::water::solute_vector class."""

    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"""
        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"""
        _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"""
        return _cmf_core.solute_vector_get_solute(self, *args, **kwargs)


    def __getitem__(self, *args, **kwargs):
        """__getitem__(solute_vector self, int i) -> solute"""
        return _cmf_core.solute_vector___getitem__(self, *args, **kwargs)


    def __len__(self, *args, **kwargs):
        """__len__(solute_vector self) -> size_t"""
        return _cmf_core.solute_vector___len__(self, *args, **kwargs)


    def __iter__(self):
        for i in range(len(self)):
            yield self[i]
    def __repr__(self):
        return str([s.Name for s in self])

    __swig_destroy__ = _cmf_core.delete_solute_vector
solute_vector.size = new_instancemethod(_cmf_core.solute_vector_size, None, solute_vector)
solute_vector.get_solute = new_instancemethod(_cmf_core.solute_vector_get_solute, None, solute_vector)
solute_vector.__getitem__ = new_instancemethod(_cmf_core.solute_vector___getitem__, None, solute_vector)
solute_vector.__len__ = new_instancemethod(_cmf_core.solute_vector___len__, None, solute_vector)
solute_vector_swigregister = _cmf_core.solute_vector_swigregister
solute_vector_swigregister(solute_vector)

class SoluteTimeseries(object):
    """Proxy of C++ cmf::water::SoluteTimeseries class."""

    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"""
        return _cmf_core.SoluteTimeseries_conc(self, *args, **kwargs)


    def size(self, *args, **kwargs):
        """size(SoluteTimeseries self) -> size_t"""
        return _cmf_core.SoluteTimeseries_size(self, *args, **kwargs)


    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
        """
        _cmf_core.SoluteTimeseries_swiginit(self, _cmf_core.new_SoluteTimeseries(*args))

    def __getitem__(self, *args, **kwargs):
        """__getitem__(SoluteTimeseries self, solute solute) -> timeseries"""
        return _cmf_core.SoluteTimeseries___getitem__(self, *args, **kwargs)


    def __setitem__(self, *args, **kwargs):
        """__setitem__(SoluteTimeseries self, solute solute, timeseries concentration)"""
        return _cmf_core.SoluteTimeseries___setitem__(self, *args, **kwargs)


    def __len__(self, *args, **kwargs):
        """__len__(SoluteTimeseries self) -> size_t"""
        return _cmf_core.SoluteTimeseries___len__(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_SoluteTimeseries
SoluteTimeseries.conc = new_instancemethod(_cmf_core.SoluteTimeseries_conc, None, SoluteTimeseries)
SoluteTimeseries.size = new_instancemethod(_cmf_core.SoluteTimeseries_size, None, SoluteTimeseries)
SoluteTimeseries.__getitem__ = new_instancemethod(_cmf_core.SoluteTimeseries___getitem__, None, SoluteTimeseries)
SoluteTimeseries.__setitem__ = new_instancemethod(_cmf_core.SoluteTimeseries___setitem__, None, SoluteTimeseries)
SoluteTimeseries.__len__ = new_instancemethod(_cmf_core.SoluteTimeseries___len__, None, SoluteTimeseries)
SoluteTimeseries_swigregister = _cmf_core.SoluteTimeseries_swigregister
SoluteTimeseries_swigregister(SoluteTimeseries)

class SoluteStorage(StateVariable):
    """Proxy of C++ cmf::water::SoluteStorage class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def set_adsorption(self, *args, **kwargs):
        """set_adsorption(SoluteStorage self, 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)
    source = _swig_property(_cmf_core.SoluteStorage_source_get, _cmf_core.SoluteStorage_source_set)
    Solute = _swig_property(_cmf_core.SoluteStorage_Solute_get)

    def conc(self, *args, **kwargs):
        """conc(SoluteStorage self) -> real"""
        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)

    __swig_destroy__ = _cmf_core.delete_SoluteStorage
SoluteStorage.set_adsorption = new_instancemethod(_cmf_core.SoluteStorage_set_adsorption, None, SoluteStorage)
SoluteStorage.conc = new_instancemethod(_cmf_core.SoluteStorage_conc, None, SoluteStorage)
SoluteStorage.set_conc = new_instancemethod(_cmf_core.SoluteStorage_set_conc, None, SoluteStorage)
SoluteStorage_swigregister = _cmf_core.SoluteStorage_swigregister
SoluteStorage_swigregister(SoluteStorage)

class flux_node(object):
    """Proxy of C++ cmf::water::flux_node class."""

    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"""
        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"""
        return _cmf_core.flux_node_to_string(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_flux_node

    def __eq__(self, *args, **kwargs):
        """__eq__(flux_node self, flux_node other) -> bool"""
        return _cmf_core.flux_node___eq__(self, *args, **kwargs)


    def RecalcFluxes(self, *args, **kwargs):
        """RecalcFluxes(flux_node self, Time t) -> bool"""
        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"""
        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"""
        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"""
        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"""
        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"""
        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"""
        return _cmf_core.flux_node_waterbalance(self, *args, **kwargs)


    def __call__(self, *args, **kwargs):
        """__call__(flux_node self, Time t) -> real"""
        return _cmf_core.flux_node___call__(self, *args, **kwargs)


    def conc(self, *args, **kwargs):
        """conc(flux_node self, Time t, solute Solute) -> real"""
        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"""
        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"""
        _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)
    connections = _swig_property(_cmf_core.flux_node_connections_get)

    def __repr__(self): return self.to_string()
    def fluxes(self,t):
        return [(con.q(self,t),con[self]) for con in self.connections]
    @property
    def connected_nodes(self):
        return [con[self] for con in self.connections]

flux_node.is_storage = new_instancemethod(_cmf_core.flux_node_is_storage, None, flux_node)
flux_node.to_string = new_instancemethod(_cmf_core.flux_node_to_string, None, flux_node)
flux_node.__eq__ = new_instancemethod(_cmf_core.flux_node___eq__, None, flux_node)
flux_node.RecalcFluxes = new_instancemethod(_cmf_core.flux_node_RecalcFluxes, None, flux_node)
flux_node.connection_to = new_instancemethod(_cmf_core.flux_node_connection_to, None, flux_node)
flux_node.remove_connection = new_instancemethod(_cmf_core.flux_node_remove_connection, None, flux_node)
flux_node.flux_to = new_instancemethod(_cmf_core.flux_node_flux_to, None, flux_node)
flux_node.flux3d_to = new_instancemethod(_cmf_core.flux_node_flux3d_to, None, flux_node)
flux_node.get_3d_flux = new_instancemethod(_cmf_core.flux_node_get_3d_flux, None, flux_node)
flux_node.waterbalance = new_instancemethod(_cmf_core.flux_node_waterbalance, None, flux_node)
flux_node.__call__ = new_instancemethod(_cmf_core.flux_node___call__, None, flux_node)
flux_node.conc = new_instancemethod(_cmf_core.flux_node_conc, None, flux_node)
flux_node.is_empty = new_instancemethod(_cmf_core.flux_node_is_empty, None, flux_node)
flux_node_swigregister = _cmf_core.flux_node_swigregister
flux_node_swigregister(flux_node)


def count_node_references(*args, **kwargs):
    """count_node_references(cmf::water::flux_node::ptr node) -> int"""
    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"""
    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"""
    return _cmf_core.get_lower_node(*args, **kwargs)
class waterbalance_integrator(integratable):
    """Proxy of C++ cmf::water::waterbalance_integrator class."""

    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"""
        return _cmf_core.waterbalance_integrator_integration_t(self, *args, **kwargs)


    def t0(self, *args, **kwargs):
        """t0(waterbalance_integrator self) -> Time"""
        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"""
        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)"""
        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"""
        _cmf_core.waterbalance_integrator_swiginit(self, _cmf_core.new_waterbalance_integrator(*args, **kwargs))

    node = _swig_property(_cmf_core.waterbalance_integrator___get_node,
                          _cmf_core.waterbalance_integrator___set_node)

    __swig_destroy__ = _cmf_core.delete_waterbalance_integrator
waterbalance_integrator.integration_t = new_instancemethod(_cmf_core.waterbalance_integrator_integration_t, None, waterbalance_integrator)
waterbalance_integrator.t0 = new_instancemethod(_cmf_core.waterbalance_integrator_t0, None, waterbalance_integrator)
waterbalance_integrator.__get_node = new_instancemethod(_cmf_core.waterbalance_integrator___get_node, None, waterbalance_integrator)
waterbalance_integrator.__set_node = new_instancemethod(_cmf_core.waterbalance_integrator___set_node, None, waterbalance_integrator)
waterbalance_integrator_swigregister = _cmf_core.waterbalance_integrator_swigregister
waterbalance_integrator_swigregister(waterbalance_integrator)

class flux_connection(object):
    """Proxy of C++ cmf::water::flux_connection class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def left_node(self, *args, **kwargs):
        """left_node(flux_connection self) -> cmf::water::flux_node::ptr"""
        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"""
        return _cmf_core.flux_connection_right_node(self, *args, **kwargs)


    def kill_me(self, *args, **kwargs):
        """kill_me(flux_connection self) -> bool"""
        return _cmf_core.flux_connection_kill_me(self, *args, **kwargs)


    def refresh(self, *args, **kwargs):
        """refresh(flux_connection self, Time t)"""
        return _cmf_core.flux_connection_refresh(self, *args, **kwargs)

    connection_id = _swig_property(_cmf_core.flux_connection_connection_id_get)

    def __eq__(self, *args, **kwargs):
        """__eq__(flux_connection self, flux_connection other) -> bool"""
        return _cmf_core.flux_connection___eq__(self, *args, **kwargs)


    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
        """
        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)"""
        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"""
        return _cmf_core.flux_connection_q(self, *args, **kwargs)


    def conc(self, *args, **kwargs):
        """conc(flux_connection self, Time t, solute _Solute) -> real"""
        return _cmf_core.flux_connection_conc(self, *args, **kwargs)

    type = _swig_property(_cmf_core.flux_connection_type_get)

    def get_tracer_filter(self, *args):
        """
        get_tracer_filter(flux_connection self) -> real
        get_tracer_filter(flux_connection self, solute S) -> real
        """
        return _cmf_core.flux_connection_get_tracer_filter(self, *args)


    def set_tracer_filter(self, *args):
        """
        set_tracer_filter(flux_connection self, real value)
        set_tracer_filter(flux_connection self, 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"""
        return _cmf_core.flux_connection_to_string(self, *args, **kwargs)


    def short_string(self, *args, **kwargs):
        """short_string(flux_connection self) -> std::string"""
        return _cmf_core.flux_connection_short_string(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_flux_connection

    def __repr__(self):
        return self.to_string()
    def __getitem__(self,index):
        return self.get_target(index)
    def __iter__(self):
        yield self.get_target(0)
        yield self.get_target(1)
    def __contains__(self,cmp):
        return cmp==self[0] or cmp==self[1]

flux_connection.left_node = new_instancemethod(_cmf_core.flux_connection_left_node, None, flux_connection)
flux_connection.right_node = new_instancemethod(_cmf_core.flux_connection_right_node, None, flux_connection)
flux_connection.kill_me = new_instancemethod(_cmf_core.flux_connection_kill_me, None, flux_connection)
flux_connection.refresh = new_instancemethod(_cmf_core.flux_connection_refresh, None, flux_connection)
flux_connection.__eq__ = new_instancemethod(_cmf_core.flux_connection___eq__, None, flux_connection)
flux_connection.get_target = new_instancemethod(_cmf_core.flux_connection_get_target, None, flux_connection)
flux_connection.exchange_target = new_instancemethod(_cmf_core.flux_connection_exchange_target, None, flux_connection)
flux_connection.q = new_instancemethod(_cmf_core.flux_connection_q, None, flux_connection)
flux_connection.conc = new_instancemethod(_cmf_core.flux_connection_conc, None, flux_connection)
flux_connection.get_tracer_filter = new_instancemethod(_cmf_core.flux_connection_get_tracer_filter, None, flux_connection)
flux_connection.set_tracer_filter = new_instancemethod(_cmf_core.flux_connection_set_tracer_filter, None, flux_connection)
flux_connection.to_string = new_instancemethod(_cmf_core.flux_connection_to_string, None, flux_connection)
flux_connection.short_string = new_instancemethod(_cmf_core.flux_connection_short_string, None, flux_connection)
flux_connection_swigregister = _cmf_core.flux_connection_swigregister
flux_connection_swigregister(flux_connection)


def replace_node(*args, **kwargs):
    """replace_node(cmf::water::flux_node::ptr oldnode, cmf::water::flux_node::ptr newnode) -> int"""
    return _cmf_core.replace_node(*args, **kwargs)
class connection_list(object):
    """Proxy of C++ cmf::water::connection_list class."""

    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"""
        return _cmf_core.connection_list_append(self, *args, **kwargs)


    def extend(self, *args, **kwargs):
        """extend(connection_list self, 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"""
        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"""
        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)"""
        return _cmf_core.connection_list_do_action(self, *args, **kwargs)


    def size(self, *args, **kwargs):
        """size(connection_list self) -> size_t"""
        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"""
        return _cmf_core.connection_list_at(self, *args, **kwargs)


    def begin(self, *args):
        """
        begin(connection_list self) -> cmf::water::connection_list::iterator
        begin(connection_list self) -> cmf::water::connection_list::const_iterator
        """
        return _cmf_core.connection_list_begin(self, *args)


    def end(self, *args):
        """
        end(connection_list self) -> cmf::water::connection_list::iterator
        end(connection_list self) -> cmf::water::connection_list::const_iterator
        """
        return _cmf_core.connection_list_end(self, *args)


    def __len__(self, *args, **kwargs):
        """__len__(connection_list self) -> size_t"""
        return _cmf_core.connection_list___len__(self, *args, **kwargs)


    def __contains__(self, *args, **kwargs):
        """__contains__(connection_list self, cmf::water::flux_connection::ptr const & con) -> bool"""
        return _cmf_core.connection_list___contains__(self, *args, **kwargs)


    def __repr__(self):
        return repr(list(self)) + "<cmf.connection_list>"
    def __getitem__(self,index):
        return self.at(index)
    def __iter__(self):
        for i in range(len(self)):
            yield self.at(i)


    def __init__(self, *args, **kwargs):
        """__init__(cmf::water::connection_list self) -> connection_list"""
        _cmf_core.connection_list_swiginit(self, _cmf_core.new_connection_list(*args, **kwargs))
    __swig_destroy__ = _cmf_core.delete_connection_list
connection_list.append = new_instancemethod(_cmf_core.connection_list_append, None, connection_list)
connection_list.extend = new_instancemethod(_cmf_core.connection_list_extend, None, connection_list)
connection_list.contains = new_instancemethod(_cmf_core.connection_list_contains, None, connection_list)
connection_list.remove = new_instancemethod(_cmf_core.connection_list_remove, None, connection_list)
connection_list.do_action = new_instancemethod(_cmf_core.connection_list_do_action, None, connection_list)
connection_list.size = new_instancemethod(_cmf_core.connection_list_size, None, connection_list)
connection_list.at = new_instancemethod(_cmf_core.connection_list_at, None, connection_list)
connection_list.begin = new_instancemethod(_cmf_core.connection_list_begin, None, connection_list)
connection_list.end = new_instancemethod(_cmf_core.connection_list_end, None, connection_list)
connection_list.__len__ = new_instancemethod(_cmf_core.connection_list___len__, None, connection_list)
connection_list.__contains__ = new_instancemethod(_cmf_core.connection_list___contains__, None, connection_list)
connection_list_swigregister = _cmf_core.connection_list_swigregister
connection_list_swigregister(connection_list)

class flux_integrator(integratable):
    """Proxy of C++ cmf::water::flux_integrator class."""

    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"""
        return _cmf_core.flux_integrator_integration_t(self, *args, **kwargs)


    def t0(self, *args, **kwargs):
        """t0(flux_integrator self) -> Time"""
        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"""
        return _cmf_core.flux_integrator_connection(self, *args, **kwargs)


    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
        """
        _cmf_core.flux_integrator_swiginit(self, _cmf_core.new_flux_integrator(*args))
    __swig_destroy__ = _cmf_core.delete_flux_integrator
flux_integrator.integration_t = new_instancemethod(_cmf_core.flux_integrator_integration_t, None, flux_integrator)
flux_integrator.t0 = new_instancemethod(_cmf_core.flux_integrator_t0, None, flux_integrator)
flux_integrator.connection = new_instancemethod(_cmf_core.flux_integrator_connection, None, flux_integrator)
flux_integrator_swigregister = _cmf_core.flux_integrator_swigregister
flux_integrator_swigregister(flux_integrator)

class linear_scale(object):
    """Proxy of C++ cmf::water::linear_scale class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    displacement = _swig_property(_cmf_core.linear_scale_displacement_get, _cmf_core.linear_scale_displacement_set)
    slope = _swig_property(_cmf_core.linear_scale_slope_get, _cmf_core.linear_scale_slope_set)

    def __call__(self, *args, **kwargs):
        """__call__(linear_scale self, real value) -> real"""
        return _cmf_core.linear_scale___call__(self, *args, **kwargs)


    def __init__(self, *args, **kwargs):
        """__init__(cmf::water::linear_scale self, real _slope=1, real _displacement=0) -> linear_scale"""
        _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)
linear_scale_swigregister = _cmf_core.linear_scale_swigregister
linear_scale_swigregister(linear_scale)

class DirichletBoundary(flux_node):
    """Proxy of C++ cmf::water::DirichletBoundary class."""

    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)"""
        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"""
        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"""
        _cmf_core.DirichletBoundary_swiginit(self, _cmf_core.new_DirichletBoundary(*args, **kwargs))

    def __repr__(self): 
        return self.to_string()

    __swig_destroy__ = _cmf_core.delete_DirichletBoundary
DirichletBoundary.set_conc = new_instancemethod(_cmf_core.DirichletBoundary_set_conc, None, DirichletBoundary)
DirichletBoundary.RecalcFluxes = new_instancemethod(_cmf_core.DirichletBoundary_RecalcFluxes, None, DirichletBoundary)
DirichletBoundary_swigregister = _cmf_core.DirichletBoundary_swigregister
DirichletBoundary_swigregister(DirichletBoundary)

class NeumannBoundary(flux_node):
    """Proxy of C++ cmf::water::NeumannBoundary class."""

    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"""
        return _cmf_core.NeumannBoundary_get_flux(self, *args, **kwargs)


    def set_flux(self, *args):
        """
        set_flux(NeumannBoundary self, timeseries new_flux)
        set_flux(NeumannBoundary self, double new_flux)
        """
        return _cmf_core.NeumannBoundary_set_flux(self, *args)

    flux_scale = _swig_property(_cmf_core.NeumannBoundary_flux_scale_get, _cmf_core.NeumannBoundary_flux_scale_set)
    concentration = _swig_property(_cmf_core.NeumannBoundary_concentration_get, _cmf_core.NeumannBoundary_concentration_set)

    def __call__(self, *args, **kwargs):
        """__call__(NeumannBoundary self, Time t) -> real"""
        return _cmf_core.NeumannBoundary___call__(self, *args, **kwargs)


    def connect_to(self, *args, **kwargs):
        """connect_to(NeumannBoundary self, cmf::water::flux_node::ptr target)"""
        return _cmf_core.NeumannBoundary_connect_to(self, *args, **kwargs)


    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
        """
        _cmf_core.NeumannBoundary_swiginit(self, _cmf_core.new_NeumannBoundary(*args))

    def create(*args, **kwargs):
        """create(cmf::water::flux_node::ptr target) -> cmf::water::NeumannBoundary::ptr"""
        return _cmf_core.NeumannBoundary_create(*args, **kwargs)

    create = staticmethod(create)

    def __repr__(self): 
        return self.to_string()


    flux = property(get_flux,set_flux,"The flux over the boundary condition")

    __swig_destroy__ = _cmf_core.delete_NeumannBoundary
NeumannBoundary.get_flux = new_instancemethod(_cmf_core.NeumannBoundary_get_flux, None, NeumannBoundary)
NeumannBoundary.set_flux = new_instancemethod(_cmf_core.NeumannBoundary_set_flux, None, NeumannBoundary)
NeumannBoundary.__call__ = new_instancemethod(_cmf_core.NeumannBoundary___call__, None, NeumannBoundary)
NeumannBoundary.connect_to = new_instancemethod(_cmf_core.NeumannBoundary_connect_to, None, NeumannBoundary)
NeumannBoundary_swigregister = _cmf_core.NeumannBoundary_swigregister
NeumannBoundary_swigregister(NeumannBoundary)

def NeumannBoundary_create(*args, **kwargs):
    """NeumannBoundary_create(cmf::water::flux_node::ptr target) -> cmf::water::NeumannBoundary::ptr"""
    return _cmf_core.NeumannBoundary_create(*args, **kwargs)

class NeumannFlux(flux_connection):
    """Proxy of C++ cmf::water::NeumannFlux 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::NeumannFlux self, std::shared_ptr< cmf::water::NeumannBoundary > left, cmf::water::flux_node::ptr right) -> NeumannFlux"""
        _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))

    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
        """
        return _cmf_core.WaterStorage_Solute(self, *args)


    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)
        """
        return _cmf_core.WaterStorage_conc(self, *args)


    def cast(*args, **kwargs):
        """cast(std::shared_ptr< cmf::water::flux_node > node) -> std::shared_ptr< cmf::water::WaterStorage >"""
        return _cmf_core.WaterStorage_cast(*args, **kwargs)

    cast = staticmethod(cast)

    def create(*args, **kwargs):
        """create(project _project, real initial_state=0.0) -> std::shared_ptr< cmf::water::WaterStorage >"""
        return _cmf_core.WaterStorage_create(*args, **kwargs)

    create = staticmethod(create)
    volume = _swig_property(_cmf_core.WaterStorage_volume_get, _cmf_core.WaterStorage_volume_set)
    statevariable = _swig_property(_cmf_core.WaterStorage_statevariable_get, _cmf_core.WaterStorage_statevariable_set)

    def __repr__(self): 
        return self.to_string()

    __swig_destroy__ = _cmf_core.delete_WaterStorage
WaterStorage.Solute = new_instancemethod(_cmf_core.WaterStorage_Solute, None, WaterStorage)
WaterStorage.conc = new_instancemethod(_cmf_core.WaterStorage_conc, None, WaterStorage)
WaterStorage_swigregister = _cmf_core.WaterStorage_swigregister
WaterStorage_swigregister(WaterStorage)

def WaterStorage_from_node(*args, **kwargs):
    """WaterStorage_from_node(cmf::water::flux_node::ptr node) -> std::shared_ptr< cmf::water::WaterStorage >"""
    return _cmf_core.WaterStorage_from_node(*args, **kwargs)

def WaterStorage_cast(*args, **kwargs):
    """WaterStorage_cast(std::shared_ptr< cmf::water::flux_node > node) -> std::shared_ptr< cmf::water::WaterStorage >"""
    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 >"""
    return _cmf_core.WaterStorage_create(*args, **kwargs)

class waterbalance_connection(flux_connection):
    """Proxy of C++ cmf::water::waterbalance_connection 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::waterbalance_connection self, cmf::water::flux_node::ptr source, cmf::water::flux_node::ptr target) -> waterbalance_connection"""
        _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."""

    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"""
        _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
external_control_connection_swigregister(external_control_connection)


def set_flux(*args, **kwargs):
    """set_flux(cmf::water::flux_node::ptr source, cmf::water::flux_node::ptr target, real flux_value)"""
    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"""
    return _cmf_core.can_set_flux(*args, **kwargs)
class kinematic_wave(flux_connection):
    """Proxy of C++ cmf::water::kinematic_wave class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    residencetime = _swig_property(_cmf_core.kinematic_wave_residencetime_get, _cmf_core.kinematic_wave_residencetime_set)
    exponent = _swig_property(_cmf_core.kinematic_wave_exponent_get, _cmf_core.kinematic_wave_exponent_set)
    residual = _swig_property(_cmf_core.kinematic_wave_residual_get, _cmf_core.kinematic_wave_residual_set)
    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"""
        _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 bidirectional_kinematic_exchange(flux_connection):
    """Proxy of C++ cmf::water::bidirectional_kinematic_exchange class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Vmaxsuc = _swig_property(_cmf_core.bidirectional_kinematic_exchange_Vmaxsuc_get, _cmf_core.bidirectional_kinematic_exchange_Vmaxsuc_set)
    Vminspill = _swig_property(_cmf_core.bidirectional_kinematic_exchange_Vminspill_get, _cmf_core.bidirectional_kinematic_exchange_Vminspill_set)
    qspill = _swig_property(_cmf_core.bidirectional_kinematic_exchange_qspill_get, _cmf_core.bidirectional_kinematic_exchange_qspill_set)
    qsuc = _swig_property(_cmf_core.bidirectional_kinematic_exchange_qsuc_get, _cmf_core.bidirectional_kinematic_exchange_qsuc_set)
    beta_suc = _swig_property(_cmf_core.bidirectional_kinematic_exchange_beta_suc_get, _cmf_core.bidirectional_kinematic_exchange_beta_suc_set)
    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"""
        _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."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    residencetime = _swig_property(_cmf_core.constraint_kinematic_wave_residencetime_get, _cmf_core.constraint_kinematic_wave_residencetime_set)
    beta = _swig_property(_cmf_core.constraint_kinematic_wave_beta_get, _cmf_core.constraint_kinematic_wave_beta_set)
    residual = _swig_property(_cmf_core.constraint_kinematic_wave_residual_get, _cmf_core.constraint_kinematic_wave_residual_set)
    V0 = _swig_property(_cmf_core.constraint_kinematic_wave_V0_get, _cmf_core.constraint_kinematic_wave_V0_set)
    Vrmax = _swig_property(_cmf_core.constraint_kinematic_wave_Vrmax_get, _cmf_core.constraint_kinematic_wave_Vrmax_set)
    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"""
        _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."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    MaxFlux = _swig_property(_cmf_core.TechnicalFlux_MaxFlux_get, _cmf_core.TechnicalFlux_MaxFlux_set)
    MinState = _swig_property(_cmf_core.TechnicalFlux_MinState_get, _cmf_core.TechnicalFlux_MinState_set)
    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"""
        _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."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    K = _swig_property(_cmf_core.generic_gradient_connection_K_get, _cmf_core.generic_gradient_connection_K_set)
    A = _swig_property(_cmf_core.generic_gradient_connection_A_get, _cmf_core.generic_gradient_connection_A_set)
    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"""
        _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."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    reaction_time = _swig_property(_cmf_core.statecontrol_connection_reaction_time_get, _cmf_core.statecontrol_connection_reaction_time_set)
    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"""
        _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."""

    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"""
        return _cmf_core.node_list_size(self, *args, **kwargs)


    def __init__(self, *args):
        """
        __init__(cmf::water::node_list self) -> node_list
        __init__(cmf::water::node_list self, node_list forcopy) -> node_list
        """
        _cmf_core.node_list_swiginit(self, _cmf_core.new_node_list(*args))

    def __iadd__(self, *args, **kwargs):
        """__iadd__(node_list self, node_list right) -> node_list"""
        return _cmf_core.node_list___iadd__(self, *args, **kwargs)


    def __add__(self, *args, **kwargs):
        """__add__(node_list self, node_list right) -> node_list"""
        return _cmf_core.node_list___add__(self, *args, **kwargs)


    def __get(self, *args, **kwargs):
        """__get(node_list self, ptrdiff_t index) -> cmf::water::flux_node::ptr"""
        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"""
        return _cmf_core.node_list___getslice(self, *args, **kwargs)


    def append(self, *args, **kwargs):
        """append(node_list self, cmf::water::flux_node::ptr node)"""
        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"""
        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"""
        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"""
        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"""
        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"""
        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"""
        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"""
        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"""
        return _cmf_core.node_list_get_fluxes3d(self, *args, **kwargs)


    def get_positions(self, *args, **kwargs):
        """get_positions(node_list self) -> point_vector"""
        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)

    def __getitem__(self,index):
        if isinstance(index,slice):
            return self.__getslice(*index.indices(self.size())) 
        else:
            try:
                it = iter(index)
                return node_list(self.__get(i) for i in it)
            except:
                return self.__get(index)

    def __len__(self):
        return self.size()       
    def __iter__(self):
        for i in range(self.size()):
            yield self[i]
    def __repr__(self):
        if len(self): return "[%i nodes: %s ... %s]" % (len(self),self[0], self[-1])
        else: return "[empty node list]"
    def extend(self,sequence):
        """Extends the node list with the sequence (any iterable will do) """
        for o in sequence:
            self.append(o)
    @staticmethod
    def from_sequence(sequence):
        """Returns a new node list populated from the sequence (any iterable will do) """
        nl=node_list()
        nl.extend(sequence)
        return nl

    __swig_destroy__ = _cmf_core.delete_node_list
node_list.size = new_instancemethod(_cmf_core.node_list_size, None, node_list)
node_list.__iadd__ = new_instancemethod(_cmf_core.node_list___iadd__, None, node_list)
node_list.__add__ = new_instancemethod(_cmf_core.node_list___add__, None, node_list)
node_list.__get = new_instancemethod(_cmf_core.node_list___get, None, node_list)
node_list.__getslice = new_instancemethod(_cmf_core.node_list___getslice, None, node_list)
node_list.append = new_instancemethod(_cmf_core.node_list_append, None, node_list)
node_list.remove = new_instancemethod(_cmf_core.node_list_remove, None, node_list)
node_list.global_water_balance = new_instancemethod(_cmf_core.node_list_global_water_balance, None, node_list)
node_list.water_balance = new_instancemethod(_cmf_core.node_list_water_balance, None, node_list)
node_list.conc = new_instancemethod(_cmf_core.node_list_conc, None, node_list)
node_list.set_solute_source = new_instancemethod(_cmf_core.node_list_set_solute_source, None, node_list)
node_list.get_fluxes_to = new_instancemethod(_cmf_core.node_list_get_fluxes_to, None, node_list)
node_list.get_fluxes3d_to = new_instancemethod(_cmf_core.node_list_get_fluxes3d_to, None, node_list)
node_list.get_fluxes3d = new_instancemethod(_cmf_core.node_list_get_fluxes3d, None, node_list)
node_list.get_positions = new_instancemethod(_cmf_core.node_list_get_positions, None, node_list)
node_list_swigregister = _cmf_core.node_list_swigregister
node_list_swigregister(node_list)

class NeumannBoundary_list(object):
    """Proxy of C++ cmf::water::NeumannBoundary_list class."""

    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"""
        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"""
        return _cmf_core.NeumannBoundary_list_get_fluxes(self, *args, **kwargs)


    def append(self, *args, **kwargs):
        """append(NeumannBoundary_list self, cmf::water::NeumannBoundary::ptr nbc)"""
        return _cmf_core.NeumannBoundary_list_append(self, *args, **kwargs)


    def size(self, *args, **kwargs):
        """size(NeumannBoundary_list self) -> size_t"""
        return _cmf_core.NeumannBoundary_list_size(self, *args, **kwargs)


    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
        """
        _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"""
        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"""
        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"""
        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)

    def __getitem__(self,index):
        return self.get(index)
    def __len__(self):
        return self.size()       
    def __iter__(self):
        for i in range(self.size()):
            yield self[i]
    def extend(self,sequence):
        """Extends the list of Neumann boundaries with the sequence (any iterable will do) """
        for o in sequence:
            self.append(o)
    @staticmethod
    def from_sequence(sequence):
        """Returns a new list of Neumann boundaries populated from the sequence (any iterable will do) """
        nl=NeumannBoundary_list()
        nl.extend(sequence)
        return nl

    __swig_destroy__ = _cmf_core.delete_NeumannBoundary_list
NeumannBoundary_list.get = new_instancemethod(_cmf_core.NeumannBoundary_list_get, None, NeumannBoundary_list)
NeumannBoundary_list.get_fluxes = new_instancemethod(_cmf_core.NeumannBoundary_list_get_fluxes, None, NeumannBoundary_list)
NeumannBoundary_list.append = new_instancemethod(_cmf_core.NeumannBoundary_list_append, None, NeumannBoundary_list)
NeumannBoundary_list.size = new_instancemethod(_cmf_core.NeumannBoundary_list_size, None, NeumannBoundary_list)
NeumannBoundary_list.to_node_list = new_instancemethod(_cmf_core.NeumannBoundary_list_to_node_list, None, NeumannBoundary_list)
NeumannBoundary_list.global_water_balance = new_instancemethod(_cmf_core.NeumannBoundary_list_global_water_balance, None, NeumannBoundary_list)
NeumannBoundary_list.water_balance = new_instancemethod(_cmf_core.NeumannBoundary_list_water_balance, None, NeumannBoundary_list)
NeumannBoundary_list_swigregister = _cmf_core.NeumannBoundary_list_swigregister
NeumannBoundary_list_swigregister(NeumannBoundary_list)

class SystemBridge(flux_node):
    """Proxy of C++ cmf::water::SystemBridge class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def get_upper_node(self, *args, **kwargs):
        """get_upper_node(SystemBridge self) -> cmf::water::flux_node::ptr"""
        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"""
        return _cmf_core.SystemBridge_get_lower_node(self, *args, **kwargs)


    def get_down_flux(self, *args, **kwargs):
        """get_down_flux(SystemBridge self) -> double"""
        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"""
        return _cmf_core.SystemBridge_down_flux_integrator(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_SystemBridge
SystemBridge.get_upper_node = new_instancemethod(_cmf_core.SystemBridge_get_upper_node, None, SystemBridge)
SystemBridge.get_lower_node = new_instancemethod(_cmf_core.SystemBridge_get_lower_node, None, SystemBridge)
SystemBridge.get_down_flux = new_instancemethod(_cmf_core.SystemBridge_get_down_flux, None, SystemBridge)
SystemBridge.down_flux_integrator = new_instancemethod(_cmf_core.SystemBridge_down_flux_integrator, None, SystemBridge)
SystemBridge_swigregister = _cmf_core.SystemBridge_swigregister
SystemBridge_swigregister(SystemBridge)

class SystemBridgeConnection(flux_connection):
    """Proxy of C++ cmf::water::SystemBridgeConnection class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _cmf_core.delete_SystemBridgeConnection
SystemBridgeConnection_swigregister = _cmf_core.SystemBridgeConnection_swigregister
SystemBridgeConnection_swigregister(SystemBridgeConnection)


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"""
    return _cmf_core.system_bridge(*args, **kwargs)

def integrate_over(item,solver=None):
    """Returns a suitable cmf.integratable implementation for item, if available.
    The created integratable is integrated by solver, if given"""
    try:
        it = iter(item)
    except:
        it=None
    if it:
        res = integratable_list()
        for i in it:
            integ = integrate_over(i,solver)
            res.append(integ)
        return res
    elif isinstance(item,flux_node):
        res = waterbalance_integrator(item)
    elif isinstance(item,flux_connection):
        res = flux_integrator(item)
    else:
        raise TypeError("""Only the waterbalance of flux_nodes and the flux of flux_connections
            are integratable. Received: """ + str(item))
    if isinstance(solver,Integrator):
        solver.integratables.append(res)
    return res


def vapour_pressure(*args, **kwargs):
    """vapour_pressure(double T) -> double"""
    return _cmf_core.vapour_pressure(*args, **kwargs)

def vpd_from_rH(*args, **kwargs):
    """vpd_from_rH(double T, double rH) -> double"""
    return _cmf_core.vpd_from_rH(*args, **kwargs)

def rH_from_vpd(*args, **kwargs):
    """rH_from_vpd(double T, double vpd) -> 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"""
    return _cmf_core.global_radiation(*args, **kwargs)

def Pressure(*args, **kwargs):
    """Pressure(double height) -> double"""
    return _cmf_core.Pressure(*args, **kwargs)
class Weather(object):
    """Proxy of C++ cmf::atmosphere::Weather class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    T = _swig_property(_cmf_core.Weather_T_get, _cmf_core.Weather_T_set)
    Tmax = _swig_property(_cmf_core.Weather_Tmax_get, _cmf_core.Weather_Tmax_set)
    Tmin = _swig_property(_cmf_core.Weather_Tmin_get, _cmf_core.Weather_Tmin_set)
    Tground = _swig_property(_cmf_core.Weather_Tground_get, _cmf_core.Weather_Tground_set)
    Windspeed = _swig_property(_cmf_core.Weather_Windspeed_get, _cmf_core.Weather_Windspeed_set)
    e_a = _swig_property(_cmf_core.Weather_e_a_get, _cmf_core.Weather_e_a_set)
    e_s = _swig_property(_cmf_core.Weather_e_s_get, _cmf_core.Weather_e_s_set)
    sunshine = _swig_property(_cmf_core.Weather_sunshine_get, _cmf_core.Weather_sunshine_set)
    Rs = _swig_property(_cmf_core.Weather_Rs_get, _cmf_core.Weather_Rs_set)
    daylength = _swig_property(_cmf_core.Weather_daylength_get, _cmf_core.Weather_daylength_set)
    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"""
        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"""
        _cmf_core.Weather_swiginit(self, _cmf_core.new_Weather(*args, **kwargs))

    def to_string(self, *args, **kwargs):
        """to_string(Weather self) -> std::string"""
        return _cmf_core.Weather_to_string(self, *args, **kwargs)


    def set_snow_threshold(*args, **kwargs):
        """set_snow_threshold(double new_threshold)"""
        return _cmf_core.Weather_set_snow_threshold(*args, **kwargs)

    set_snow_threshold = staticmethod(set_snow_threshold)

    def get_snow_threshold(*args, **kwargs):
        """get_snow_threshold() -> double"""
        return _cmf_core.Weather_get_snow_threshold(*args, **kwargs)

    get_snow_threshold = staticmethod(get_snow_threshold)

    def __iadd__(self, *args, **kwargs):
        """__iadd__(Weather self, Weather w) -> Weather"""
        return _cmf_core.Weather___iadd__(self, *args, **kwargs)


    def __imul__(self, *args, **kwargs):
        """__imul__(Weather self, double factor) -> Weather"""
        return _cmf_core.Weather___imul__(self, *args, **kwargs)


    def __add__(self, *args, **kwargs):
        """__add__(Weather self, Weather w) -> Weather"""
        return _cmf_core.Weather___add__(self, *args, **kwargs)


    def __mul__(self, *args, **kwargs):
        """__mul__(Weather self, double factor) -> Weather"""
        return _cmf_core.Weather___mul__(self, *args, **kwargs)


    def __repr__(self):
        return "cmf.Weather(Tmin=%0.2f,Tmax=%0.2f)" % (self.Tmin,self.Tmax)
    def __str__(self):
        return self.to_string()

    __swig_destroy__ = _cmf_core.delete_Weather
Weather.Rn = new_instancemethod(_cmf_core.Weather_Rn, None, Weather)
Weather.to_string = new_instancemethod(_cmf_core.Weather_to_string, None, Weather)
Weather.__iadd__ = new_instancemethod(_cmf_core.Weather___iadd__, None, Weather)
Weather.__imul__ = new_instancemethod(_cmf_core.Weather___imul__, None, Weather)
Weather.__add__ = new_instancemethod(_cmf_core.Weather___add__, None, Weather)
Weather.__mul__ = new_instancemethod(_cmf_core.Weather___mul__, None, Weather)
Weather_swigregister = _cmf_core.Weather_swigregister
Weather_swigregister(Weather)

def Weather_set_snow_threshold(*args, **kwargs):
    """Weather_set_snow_threshold(double new_threshold)"""
    return _cmf_core.Weather_set_snow_threshold(*args, **kwargs)

def Weather_get_snow_threshold(*args):
    """Weather_get_snow_threshold() -> double"""
    return _cmf_core.Weather_get_snow_threshold(*args)

class Meteorology(object):
    """Proxy of C++ cmf::atmosphere::Meteorology class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def __call__(self, *args, **kwargs):
        """__call__(Meteorology self, Time t) -> Weather"""
        return _cmf_core.Meteorology___call__(self, *args, **kwargs)


    def get_weather(self, *args, **kwargs):
        """get_weather(Meteorology self, Time t) -> Weather"""
        return _cmf_core.Meteorology_get_weather(self, *args, **kwargs)


    def copy(self, *args, **kwargs):
        """copy(Meteorology self) -> Meteorology"""
        return _cmf_core.Meteorology_copy(self, *args, **kwargs)


    def get_instrument_height(self, *args, **kwargs):
        """get_instrument_height(Meteorology self) -> real"""
        return _cmf_core.Meteorology_get_instrument_height(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_Meteorology
Meteorology.__call__ = new_instancemethod(_cmf_core.Meteorology___call__, None, Meteorology)
Meteorology.get_weather = new_instancemethod(_cmf_core.Meteorology_get_weather, None, Meteorology)
Meteorology.copy = new_instancemethod(_cmf_core.Meteorology_copy, None, Meteorology)
Meteorology.get_instrument_height = new_instancemethod(_cmf_core.Meteorology_get_instrument_height, None, Meteorology)
Meteorology_swigregister = _cmf_core.Meteorology_swigregister
Meteorology_swigregister(Meteorology)

class ConstantMeteorology(Meteorology):
    """Proxy of C++ cmf::atmosphere::ConstantMeteorology class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    weather = _swig_property(_cmf_core.ConstantMeteorology_weather_get, _cmf_core.ConstantMeteorology_weather_set)

    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
        """
        _cmf_core.ConstantMeteorology_swiginit(self, _cmf_core.new_ConstantMeteorology(*args))

    def copy(self, *args, **kwargs):
        """copy(ConstantMeteorology self) -> ConstantMeteorology"""
        return _cmf_core.ConstantMeteorology_copy(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_ConstantMeteorology
ConstantMeteorology.copy = new_instancemethod(_cmf_core.ConstantMeteorology_copy, None, ConstantMeteorology)
ConstantMeteorology_swigregister = _cmf_core.ConstantMeteorology_swigregister
ConstantMeteorology_swigregister(ConstantMeteorology)

class MeteoStation(object):
    """Proxy of C++ cmf::atmosphere::MeteoStation class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Latitude = _swig_property(_cmf_core.MeteoStation_Latitude_get, _cmf_core.MeteoStation_Latitude_set)
    Longitude = _swig_property(_cmf_core.MeteoStation_Longitude_get, _cmf_core.MeteoStation_Longitude_set)
    Timezone = _swig_property(_cmf_core.MeteoStation_Timezone_get, _cmf_core.MeteoStation_Timezone_set)
    x = _swig_property(_cmf_core.MeteoStation_x_get, _cmf_core.MeteoStation_x_set)
    y = _swig_property(_cmf_core.MeteoStation_y_get, _cmf_core.MeteoStation_y_set)
    z = _swig_property(_cmf_core.MeteoStation_z_get, _cmf_core.MeteoStation_z_set)
    Name = _swig_property(_cmf_core.MeteoStation_Name_get, _cmf_core.MeteoStation_Name_set)

    def get_position(self, *args, **kwargs):
        """get_position(MeteoStation self) -> point"""
        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"""
        _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"""
        return _cmf_core.MeteoStation_get_data(self, *args, **kwargs)


    def use_for_cell(self, *args, **kwargs):
        """use_for_cell(MeteoStation self, Cell c)"""
        return _cmf_core.MeteoStation_use_for_cell(self, *args, **kwargs)


    def SetSunshineFraction(self, *args, **kwargs):
        """SetSunshineFraction(MeteoStation self, timeseries sunshine_duration)"""
        return _cmf_core.MeteoStation_SetSunshineFraction(self, *args, **kwargs)

    T = _swig_property(_cmf_core.MeteoStation_T_get, _cmf_core.MeteoStation_T_set)
    Tmax = _swig_property(_cmf_core.MeteoStation_Tmax_get, _cmf_core.MeteoStation_Tmax_set)
    Tmin = _swig_property(_cmf_core.MeteoStation_Tmin_get, _cmf_core.MeteoStation_Tmin_set)
    Tground = _swig_property(_cmf_core.MeteoStation_Tground_get, _cmf_core.MeteoStation_Tground_set)
    Windspeed = _swig_property(_cmf_core.MeteoStation_Windspeed_get, _cmf_core.MeteoStation_Windspeed_set)
    rHmean = _swig_property(_cmf_core.MeteoStation_rHmean_get, _cmf_core.MeteoStation_rHmean_set)
    rHmin = _swig_property(_cmf_core.MeteoStation_rHmin_get, _cmf_core.MeteoStation_rHmin_set)
    rHmax = _swig_property(_cmf_core.MeteoStation_rHmax_get, _cmf_core.MeteoStation_rHmax_set)
    Tdew = _swig_property(_cmf_core.MeteoStation_Tdew_get, _cmf_core.MeteoStation_Tdew_set)
    Sunshine = _swig_property(_cmf_core.MeteoStation_Sunshine_get, _cmf_core.MeteoStation_Sunshine_set)
    Rs = _swig_property(_cmf_core.MeteoStation_Rs_get, _cmf_core.MeteoStation_Rs_set)
    T_lapse = _swig_property(_cmf_core.MeteoStation_T_lapse_get, _cmf_core.MeteoStation_T_lapse_set)

    def TimeseriesDictionary(self):
        return {"Tmin":self.Tmin,
                "Tmax":self.Tmax,
                "Tdew":self.Tdew,
                "T":self.T,
                "rHmean":self.rHmean,
                "rHmax":self.rHmax,
                "rHmin":self.rHmin,
                "Sunshine":self.Sunshine,
                "Windspeed":self.Windspeed,
                "Rs" : self.Rs}
    def __repr__(self):
        return "cmf.MeteoStation(%s,lat=%0.5g,lon=%0.5g,z=%6.1f)" % (self.Name,self.Latitude,self.Longitude,self.z)

    __swig_destroy__ = _cmf_core.delete_MeteoStation
MeteoStation.get_position = new_instancemethod(_cmf_core.MeteoStation_get_position, None, MeteoStation)
MeteoStation.get_data = new_instancemethod(_cmf_core.MeteoStation_get_data, None, MeteoStation)
MeteoStation.use_for_cell = new_instancemethod(_cmf_core.MeteoStation_use_for_cell, None, MeteoStation)
MeteoStation.SetSunshineFraction = new_instancemethod(_cmf_core.MeteoStation_SetSunshineFraction, None, MeteoStation)
MeteoStation_swigregister = _cmf_core.MeteoStation_swigregister
MeteoStation_swigregister(MeteoStation)

class MeteoStationReference(Meteorology):
    """Proxy of C++ cmf::atmosphere::MeteoStationReference class."""

    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"""
        return _cmf_core.MeteoStationReference_get_station(self, *args, **kwargs)


    def get_position(self, *args, **kwargs):
        """get_position(MeteoStationReference self) -> point"""
        return _cmf_core.MeteoStationReference_get_position(self, *args, **kwargs)


    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
        """
        _cmf_core.MeteoStationReference_swiginit(self, _cmf_core.new_MeteoStationReference(*args))

    def copy(self, *args, **kwargs):
        """copy(MeteoStationReference self) -> MeteoStationReference"""
        return _cmf_core.MeteoStationReference_copy(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_MeteoStationReference
MeteoStationReference.get_station = new_instancemethod(_cmf_core.MeteoStationReference_get_station, None, MeteoStationReference)
MeteoStationReference.get_position = new_instancemethod(_cmf_core.MeteoStationReference_get_position, None, MeteoStationReference)
MeteoStationReference.copy = new_instancemethod(_cmf_core.MeteoStationReference_copy, None, MeteoStationReference)
MeteoStationReference_swigregister = _cmf_core.MeteoStationReference_swigregister
MeteoStationReference_swigregister(MeteoStationReference)

class MeteoStationList(object):
    """Proxy of C++ cmf::atmosphere::MeteoStationList class."""

    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"""
        return _cmf_core.MeteoStationList___len__(self, *args, **kwargs)


    def __getitem__(self, *args):
        """
        __getitem__(MeteoStationList self, ptrdiff_t index) -> cmf::atmosphere::MeteoStation::ptr
        __getitem__(MeteoStationList self, std::string const & Name) -> cmf::atmosphere::MeteoStation::ptr
        """
        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 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"""
        return _cmf_core.MeteoStationList_add_station(self, *args, **kwargs)


    def remove_station(self, *args, **kwargs):
        """remove_station(MeteoStationList self, ptrdiff_t index) -> ptrdiff_t"""
        return _cmf_core.MeteoStationList_remove_station(self, *args, **kwargs)


    def __init__(self, *args):
        """
        __init__(cmf::atmosphere::MeteoStationList self) -> MeteoStationList
        __init__(cmf::atmosphere::MeteoStationList self, MeteoStationList copy) -> MeteoStationList
        """
        _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"""
        return _cmf_core.MeteoStationList_reference_to_nearest(self, *args, **kwargs)


    def __iter__(self):
        for i in range(len(self)):
            yield self[i]
    def __repr__(self):
        return "list of %i cmf meteorological stations" % len(self)

    __swig_destroy__ = _cmf_core.delete_MeteoStationList
MeteoStationList.__len__ = new_instancemethod(_cmf_core.MeteoStationList___len__, None, MeteoStationList)
MeteoStationList.__getitem__ = new_instancemethod(_cmf_core.MeteoStationList___getitem__, None, MeteoStationList)
MeteoStationList.calculate_Temp_lapse = new_instancemethod(_cmf_core.MeteoStationList_calculate_Temp_lapse, None, MeteoStationList)
MeteoStationList.add_station = new_instancemethod(_cmf_core.MeteoStationList_add_station, None, MeteoStationList)
MeteoStationList.remove_station = new_instancemethod(_cmf_core.MeteoStationList_remove_station, None, MeteoStationList)
MeteoStationList.reference_to_nearest = new_instancemethod(_cmf_core.MeteoStationList_reference_to_nearest, None, MeteoStationList)
MeteoStationList_swigregister = _cmf_core.MeteoStationList_swigregister
MeteoStationList_swigregister(MeteoStationList)

class IDW_Meteorology(Meteorology):
    """Proxy of C++ cmf::atmosphere::IDW_Meteorology 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):
        """
        __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
        """
        _cmf_core.IDW_Meteorology_swiginit(self, _cmf_core.new_IDW_Meteorology(*args))

    def copy(self, *args, **kwargs):
        """copy(IDW_Meteorology self) -> IDW_Meteorology"""
        return _cmf_core.IDW_Meteorology_copy(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_IDW_Meteorology
IDW_Meteorology.copy = new_instancemethod(_cmf_core.IDW_Meteorology_copy, None, IDW_Meteorology)
IDW_Meteorology_swigregister = _cmf_core.IDW_Meteorology_swigregister
IDW_Meteorology_swigregister(IDW_Meteorology)

class aerodynamic_resistance(object):
    """Proxy of C++ cmf::atmosphere::aerodynamic_resistance class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def get_aerodynamic_resistance(self, *args, **kwargs):
        """get_aerodynamic_resistance(aerodynamic_resistance self, double & r_ag, double & r_ac, Time t)"""
        return _cmf_core.aerodynamic_resistance_get_aerodynamic_resistance(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_aerodynamic_resistance
aerodynamic_resistance.get_aerodynamic_resistance = new_instancemethod(_cmf_core.aerodynamic_resistance_get_aerodynamic_resistance, None, aerodynamic_resistance)
aerodynamic_resistance_swigregister = _cmf_core.aerodynamic_resistance_swigregister
aerodynamic_resistance_swigregister(aerodynamic_resistance)

class RainSource(flux_node):
    """Proxy of C++ cmf::atmosphere::RainSource class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def __call__(self, *args, **kwargs):
        """__call__(RainSource self, Time t) -> real"""
        return _cmf_core.RainSource___call__(self, *args, **kwargs)


    def get_intensity(self, *args, **kwargs):
        """get_intensity(RainSource self, Time t) -> real"""
        return _cmf_core.RainSource_get_intensity(self, *args, **kwargs)


    def __repr__(self): 
        return self.to_string()

    __swig_destroy__ = _cmf_core.delete_RainSource
RainSource.__call__ = new_instancemethod(_cmf_core.RainSource___call__, None, RainSource)
RainSource.get_intensity = new_instancemethod(_cmf_core.RainSource_get_intensity, None, RainSource)
RainSource_swigregister = _cmf_core.RainSource_swigregister
RainSource_swigregister(RainSource)

class ConstantRainSource(RainSource):
    """Proxy of C++ cmf::atmosphere::ConstantRainSource class."""

    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"""
        _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)"""
        return _cmf_core.ConstantRainSource_set_conc(self, *args, **kwargs)


    def __repr__(self): 
        return self.to_string()

    __swig_destroy__ = _cmf_core.delete_ConstantRainSource
ConstantRainSource.set_conc = new_instancemethod(_cmf_core.ConstantRainSource_set_conc, None, ConstantRainSource)
ConstantRainSource_swigregister = _cmf_core.ConstantRainSource_swigregister
ConstantRainSource_swigregister(ConstantRainSource)

class TimeseriesRainSource(RainSource):
    """Proxy of C++ cmf::atmosphere::TimeseriesRainSource class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    data = _swig_property(_cmf_core.TimeseriesRainSource_data_get, _cmf_core.TimeseriesRainSource_data_set)
    concentrations = _swig_property(_cmf_core.TimeseriesRainSource_concentrations_get, _cmf_core.TimeseriesRainSource_concentrations_set)
    __swig_destroy__ = _cmf_core.delete_TimeseriesRainSource
TimeseriesRainSource_swigregister = _cmf_core.TimeseriesRainSource_swigregister
TimeseriesRainSource_swigregister(TimeseriesRainSource)

class RainfallStation(object):
    """Proxy of C++ cmf::atmosphere::RainfallStation class."""

    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)

    def create(*args, **kwargs):
        """create(size_t Id, std::string Name, timeseries Data, point position) -> cmf::atmosphere::RainfallStation::ptr"""
        return _cmf_core.RainfallStation_create(*args, **kwargs)

    create = staticmethod(create)
    id = _swig_property(_cmf_core.RainfallStation_id_get)
    name = _swig_property(_cmf_core.RainfallStation_name_get)
    data = _swig_property(_cmf_core.RainfallStation_data_get, _cmf_core.RainfallStation_data_set)

    def __repr__(self, *args, **kwargs):
        """__repr__(RainfallStation self) -> std::string"""
        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)"""
        return _cmf_core.RainfallStation_use_for_cell(self, *args, **kwargs)


    def __init__(self, *args, **kwargs):
        """__init__(cmf::atmosphere::RainfallStation self, RainfallStation copy) -> RainfallStation"""
        _cmf_core.RainfallStation_swiginit(self, _cmf_core.new_RainfallStation(*args, **kwargs))

    def __call__(self, *args, **kwargs):
        """__call__(RainfallStation self, Time t) -> double"""
        return _cmf_core.RainfallStation___call__(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_RainfallStation
RainfallStation.__repr__ = new_instancemethod(_cmf_core.RainfallStation___repr__, None, RainfallStation)
RainfallStation.use_for_cell = new_instancemethod(_cmf_core.RainfallStation_use_for_cell, None, RainfallStation)
RainfallStation.__call__ = new_instancemethod(_cmf_core.RainfallStation___call__, None, RainfallStation)
RainfallStation_swigregister = _cmf_core.RainfallStation_swigregister
RainfallStation_swigregister(RainfallStation)

def RainfallStation_create(*args, **kwargs):
    """RainfallStation_create(size_t Id, std::string Name, timeseries Data, point position) -> cmf::atmosphere::RainfallStation::ptr"""
    return _cmf_core.RainfallStation_create(*args, **kwargs)

class RainfallStationList(object):
    """Proxy of C++ cmf::atmosphere::RainfallStationList class."""

    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"""
        return _cmf_core.RainfallStationList___len__(self, *args, **kwargs)


    def __getitem__(self, *args):
        """
        __getitem__(RainfallStationList self, ptrdiff_t index) -> cmf::atmosphere::RainfallStation::ptr
        __getitem__(RainfallStationList self, ptrdiff_t index) -> cmf::atmosphere::RainfallStation::ptr const
        """
        return _cmf_core.RainfallStationList___getitem__(self, *args)


    def add(self, *args, **kwargs):
        """add(RainfallStationList self, std::string Name, timeseries Data, point Position) -> cmf::atmosphere::RainfallStation::ptr"""
        return _cmf_core.RainfallStationList_add(self, *args, **kwargs)


    def remove(self, *args, **kwargs):
        """remove(RainfallStationList self, ptrdiff_t index)"""
        return _cmf_core.RainfallStationList_remove(self, *args, **kwargs)


    def __repr__(self):
        return repr(list(self))
    def __iter__(self):
        for i in range(len(self)):
            yield self[i]


    def __init__(self, *args, **kwargs):
        """__init__(cmf::atmosphere::RainfallStationList self) -> RainfallStationList"""
        _cmf_core.RainfallStationList_swiginit(self, _cmf_core.new_RainfallStationList(*args, **kwargs))
    __swig_destroy__ = _cmf_core.delete_RainfallStationList
RainfallStationList.__len__ = new_instancemethod(_cmf_core.RainfallStationList___len__, None, RainfallStationList)
RainfallStationList.__getitem__ = new_instancemethod(_cmf_core.RainfallStationList___getitem__, None, RainfallStationList)
RainfallStationList.add = new_instancemethod(_cmf_core.RainfallStationList_add, None, RainfallStationList)
RainfallStationList.remove = new_instancemethod(_cmf_core.RainfallStationList_remove, None, RainfallStationList)
RainfallStationList_swigregister = _cmf_core.RainfallStationList_swigregister
RainfallStationList_swigregister(RainfallStationList)

class RainfallStationReference(RainSource):
    """Proxy of C++ cmf::atmosphere::RainfallStationReference class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def from_nearest_station(*args, **kwargs):
        """from_nearest_station(project project, point position, double z_weight) -> cmf::atmosphere::RainfallStationReference::ptr"""
        return _cmf_core.RainfallStationReference_from_nearest_station(*args, **kwargs)

    from_nearest_station = staticmethod(from_nearest_station)

    def from_station_id(*args, **kwargs):
        """from_station_id(project project, point position, size_t id) -> cmf::atmosphere::RainfallStationReference::ptr"""
        return _cmf_core.RainfallStationReference_from_station_id(*args, **kwargs)

    from_station_id = staticmethod(from_station_id)

    def __repr__(self): 
        return self.to_string()

    __swig_destroy__ = _cmf_core.delete_RainfallStationReference
RainfallStationReference_swigregister = _cmf_core.RainfallStationReference_swigregister
RainfallStationReference_swigregister(RainfallStationReference)

def RainfallStationReference_from_nearest_station(*args, **kwargs):
    """RainfallStationReference_from_nearest_station(project project, point position, double z_weight) -> cmf::atmosphere::RainfallStationReference::ptr"""
    return _cmf_core.RainfallStationReference_from_nearest_station(*args, **kwargs)

def RainfallStationReference_from_station_id(*args, **kwargs):
    """RainfallStationReference_from_station_id(project project, point position, size_t id) -> cmf::atmosphere::RainfallStationReference::ptr"""
    return _cmf_core.RainfallStationReference_from_station_id(*args, **kwargs)

class IDWRainfall(RainSource):
    """Proxy of C++ cmf::atmosphere::IDWRainfall class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def create(*args, **kwargs):
        """create(project project, point position, double z_weight, double power) -> cmf::atmosphere::RainSource::ptr"""
        return _cmf_core.IDWRainfall_create(*args, **kwargs)

    create = staticmethod(create)

    def __repr__(self): 
        return self.to_string()

    __swig_destroy__ = _cmf_core.delete_IDWRainfall
IDWRainfall_swigregister = _cmf_core.IDWRainfall_swigregister
IDWRainfall_swigregister(IDWRainfall)

def IDWRainfall_create(*args, **kwargs):
    """IDWRainfall_create(project project, point position, double z_weight, double power) -> cmf::atmosphere::RainSource::ptr"""
    return _cmf_core.IDWRainfall_create(*args, **kwargs)

class Vegetation(object):
    """Proxy of C++ cmf::upslope::vegetation::Vegetation class."""

    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)
    Height = _swig_property(_cmf_core.Vegetation_Height_get, _cmf_core.Vegetation_Height_set)
    albedo = _swig_property(_cmf_core.Vegetation_albedo_get, _cmf_core.Vegetation_albedo_set)
    snow_albedo = _swig_property(_cmf_core.Vegetation_snow_albedo_get, _cmf_core.Vegetation_snow_albedo_set)
    CanopyCapacityPerLAI = _swig_property(_cmf_core.Vegetation_CanopyCapacityPerLAI_get, _cmf_core.Vegetation_CanopyCapacityPerLAI_set)
    RootDepth = _swig_property(_cmf_core.Vegetation_RootDepth_get, _cmf_core.Vegetation_RootDepth_set)
    RootContent = _swig_property(_cmf_core.Vegetation_RootContent_get, _cmf_core.Vegetation_RootContent_set)
    fraction_at_rootdepth = _swig_property(_cmf_core.Vegetation_fraction_at_rootdepth_get, _cmf_core.Vegetation_fraction_at_rootdepth_set)
    StomatalResistance = _swig_property(_cmf_core.Vegetation_StomatalResistance_get, _cmf_core.Vegetation_StomatalResistance_set)
    CanopyClosure = _swig_property(_cmf_core.Vegetation_CanopyClosure_get, _cmf_core.Vegetation_CanopyClosure_set)
    CanopyPARExtinction = _swig_property(_cmf_core.Vegetation_CanopyPARExtinction_get, _cmf_core.Vegetation_CanopyPARExtinction_set)
    LeafWidth = _swig_property(_cmf_core.Vegetation_LeafWidth_get, _cmf_core.Vegetation_LeafWidth_set)

    def RootLength(self, *args, **kwargs):
        """RootLength(Vegetation self) -> double"""
        return _cmf_core.Vegetation_RootLength(self, *args, **kwargs)


    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
        """
        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"""
        _cmf_core.Vegetation_swiginit(self, _cmf_core.new_Vegetation(*args, **kwargs))

    def __repr__(self, *args, **kwargs):
        """__repr__(Vegetation self) -> std::string"""
        return _cmf_core.Vegetation___repr__(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_Vegetation
Vegetation.RootLength = new_instancemethod(_cmf_core.Vegetation_RootLength, None, Vegetation)
Vegetation.RootFraction = new_instancemethod(_cmf_core.Vegetation_RootFraction, None, Vegetation)
Vegetation.__repr__ = new_instancemethod(_cmf_core.Vegetation___repr__, None, Vegetation)
Vegetation_swigregister = _cmf_core.Vegetation_swigregister
Vegetation_swigregister(Vegetation)

class CellConnector(object):
    """Proxy of C++ cmf::upslope::CellConnector 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::upslope::CellConnector self, cmf::upslope::connectorfunction connector) -> CellConnector"""
        _cmf_core.CellConnector_swiginit(self, _cmf_core.new_CellConnector(*args, **kwargs))

    def __call__(self, *args, **kwargs):
        """__call__(CellConnector self, Cell cell1, Cell cell2, ptrdiff_t start_at_layer=0)"""
        return _cmf_core.CellConnector___call__(self, *args, **kwargs)


    def connect(self, *args, **kwargs):
        """connect(CellConnector self, Cell cell1, Cell cell2, ptrdiff_t start_at_layer=0)"""
        return _cmf_core.CellConnector_connect(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_CellConnector
CellConnector.__call__ = new_instancemethod(_cmf_core.CellConnector___call__, None, CellConnector)
CellConnector.connect = new_instancemethod(_cmf_core.CellConnector_connect, None, CellConnector)
CellConnector_swigregister = _cmf_core.CellConnector_swigregister
CellConnector_swigregister(CellConnector)

class Cell(StateVariableOwner):
    """Proxy of C++ cmf::upslope::Cell class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = _swig_property(_cmf_core.Cell_x_get, _cmf_core.Cell_x_set)
    y = _swig_property(_cmf_core.Cell_y_get, _cmf_core.Cell_y_set)
    z = _swig_property(_cmf_core.Cell_z_get, _cmf_core.Cell_z_set)

    def get_position(self, *args, **kwargs):
        """get_position(Cell self) -> point"""
        return _cmf_core.Cell_get_position(self, *args, **kwargs)


    def m3_to_mm(self, *args, **kwargs):
        """m3_to_mm(Cell self, double volume) -> double"""
        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"""
        return _cmf_core.Cell_mm_to_m3(self, *args, **kwargs)


    def InvalidateSatDepth(self, *args, **kwargs):
        """InvalidateSatDepth(Cell self)"""
        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)"""
        return _cmf_core.Cell_set_aerodynamic_resistance(self, *args, **kwargs)


    def set_weather(self, *args, **kwargs):
        """set_weather(Cell self, Weather weather)"""
        return _cmf_core.Cell_set_weather(self, *args, **kwargs)


    def set_rainfall(self, *args, **kwargs):
        """set_rainfall(Cell self, double rainfall)"""
        return _cmf_core.Cell_set_rainfall(self, *args, **kwargs)


    def get_rainfall(self, *args, **kwargs):
        """get_rainfall(Cell self, Time t) -> double"""
        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)"""
        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"""
        return _cmf_core.Cell___get_rain_source(self, *args, **kwargs)


    def set_uptakestress(self, *args, **kwargs):
        """set_uptakestress(Cell self, RootUptakeStessFunction stressfunction)"""
        return _cmf_core.Cell_set_uptakestress(self, *args, **kwargs)


    def __get_evaporation(self, *args, **kwargs):
        """__get_evaporation(Cell self) -> cmf::water::flux_node::ptr"""
        return _cmf_core.Cell___get_evaporation(self, *args, **kwargs)


    def __get_transpiration(self, *args, **kwargs):
        """__get_transpiration(Cell self) -> cmf::water::flux_node::ptr"""
        return _cmf_core.Cell___get_transpiration(self, *args, **kwargs)


    def get_surfacewater(self, *args, **kwargs):
        """get_surfacewater(Cell self) -> cmf::water::flux_node::ptr"""
        return _cmf_core.Cell_get_surfacewater(self, *args, **kwargs)


    def surfacewater_as_storage(self, *args, **kwargs):
        """surfacewater_as_storage(Cell self)"""
        return _cmf_core.Cell_surfacewater_as_storage(self, *args, **kwargs)


    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
        """
        return _cmf_core.Cell_add_storage(self, *args)


    def remove_storage(self, *args, **kwargs):
        """remove_storage(Cell self, 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"""
        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"""
        return _cmf_core.Cell_get_storage(self, *args, **kwargs)


    def get_canopy(self, *args, **kwargs):
        """get_canopy(Cell self) -> cmf::water::WaterStorage::ptr"""
        return _cmf_core.Cell_get_canopy(self, *args, **kwargs)


    def get_snow(self, *args, **kwargs):
        """get_snow(Cell self) -> cmf::water::WaterStorage::ptr"""
        return _cmf_core.Cell_get_snow(self, *args, **kwargs)


    def snow_coverage(self, *args, **kwargs):
        """snow_coverage(Cell self) -> real"""
        return _cmf_core.Cell_snow_coverage(self, *args, **kwargs)


    def albedo(self, *args, **kwargs):
        """albedo(Cell self) -> real"""
        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"""
        return _cmf_core.Cell_surface_water_coverage(self, *args, **kwargs)


    def heat_flux(self, *args, **kwargs):
        """heat_flux(Cell self, Time t) -> real"""
        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"""
        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"""
        return _cmf_core.Cell_get_weather(self, *args, **kwargs)


    def layer_count(self, *args, **kwargs):
        """layer_count(Cell self) -> size_t"""
        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"""
        return _cmf_core.Cell_get_layer(self, *args, **kwargs)


    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
        """
        return _cmf_core.Cell_add_layer(self, *args)


    def remove_last_layer(self, *args, **kwargs):
        """remove_last_layer(Cell self)"""
        return _cmf_core.Cell_remove_last_layer(self, *args, **kwargs)


    def remove_layers(self, *args, **kwargs):
        """remove_layers(Cell self)"""
        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"""
        _cmf_core.Cell_swiginit(self, _cmf_core.new_Cell(*args, **kwargs))

    def to_string(self, *args, **kwargs):
        """to_string(Cell self) -> std::string"""
        return _cmf_core.Cell_to_string(self, *args, **kwargs)

    topology = _swig_property(_cmf_core.Cell_topology_get)

    evaporation = _swig_property(_cmf_core.Cell___get_evaporation)


    transpiration = _swig_property(_cmf_core.Cell___get_transpiration)

    meteorology = _swig_property(_cmf_core.Cell_meteorology_get, _cmf_core.Cell_meteorology_set)

    rain_source = _swig_property(_cmf_core.Cell___get_rain_source,
                          _cmf_core.Cell___set_rain_source)

    layers = _swig_property(_cmf_core.Cell_layers_get)
    project = _swig_property(_cmf_core.Cell_project_get)
    saturated_depth = _swig_property(_cmf_core.Cell_saturated_depth_get, _cmf_core.Cell_saturated_depth_set)
    area = _swig_property(_cmf_core.Cell_area_get)
    soildepth = _swig_property(_cmf_core.Cell_soildepth_get)

    @property
    def surface_storages(self):
        "Provides access to all surface storages of the cell, like canopy, snow, surface water etc"
        return [self.get_storage(i) for i in range(self.storage_count())]
    @property
    def storages(self):
        "Provides access to all storages of the cell (surface storages and layers)"
        return self.surface_storages + list(self.layers)

    @property
    def neighbors(self):
        c_iter=neighbor_iterator(self)
        while c_iter.valid():
            yield (c_iter.cell(),c_iter.flowwidth())
            next(c_iter)

    surfacewater=property(get_surfacewater,None,"Gives access to the surface water, which is either a distributing flux node, or the storage for all surface water")
    canopy=property(get_canopy,None,"The canopy water storage of the cell, if it exists")
    snow=property(get_snow,None,"The snow pack of the cell, if a storage for the snow exists")

    contributing_area=property(lambda self:self.topology.ContributingArea(),None,"Contributing area of this cell m2")
    main_outlet=property(lambda self:self.topology.MainOutlet(),None,"The main outlet of the surface water of this cell")

    def connect_soil_with_node(self,node,ctype,flowwidth,distance,upper_boundary=0,lower_boundary=None):
        """Connects all layers between the boundaries with a node using a flux connection
        node: Target node (flux_node)
        type: Type of the connection (e.g. cmf.Richards_lateral)
        flowwidth: Width of the connection
        distance: distance of the connection
        upper_boundary: Connect only layers, whose lower depth is greater then this value
        lower_boundary: Connect only  layers, whose upper depth is smaller then this value
        """
        if lower_boundary is None:
            lower_boundary=self.soildepth
        connections=[ctype(l,node,flowwidth,distance) 
                     for l in self.layers 
                     if     l.boundary[0]<lower_boundary 
                        and l.boundary[1]>upper_boundary 
                    ]

    def install_connection(self,connection_type):
        """Calls the static use_for_cell method of the connection_type, if present.
        The use_for_cell method might do quite a lot of stuff, please consult the docs for the connection.
        Eg. >>>help(Richards.use_for_cell) 
        """
        if hasattr(connection_type,"use_for_cell"):
            connection_type.use_for_cell(self)
        else:
            raise TypeError("Only connection types implementing a static use_for_cell function can be used")
    def __hash__(self):
        return hash((self.x,self.y,self.Id))
    def __eq__(self,cmp):
        return hash(self)==hash(cmp)
    def __repr__(self):
        return "cell #%i(%g,%g,%g)" % (self.Id,self.x,self.y,self.z)

Cell.get_position = new_instancemethod(_cmf_core.Cell_get_position, None, Cell)
Cell.m3_to_mm = new_instancemethod(_cmf_core.Cell_m3_to_mm, None, Cell)
Cell.mm_to_m3 = new_instancemethod(_cmf_core.Cell_mm_to_m3, None, Cell)
Cell.InvalidateSatDepth = new_instancemethod(_cmf_core.Cell_InvalidateSatDepth, None, Cell)
Cell.set_aerodynamic_resistance = new_instancemethod(_cmf_core.Cell_set_aerodynamic_resistance, None, Cell)
Cell.set_weather = new_instancemethod(_cmf_core.Cell_set_weather, None, Cell)
Cell.set_rainfall = new_instancemethod(_cmf_core.Cell_set_rainfall, None, Cell)
Cell.get_rainfall = new_instancemethod(_cmf_core.Cell_get_rainfall, None, Cell)
Cell.__set_rain_source = new_instancemethod(_cmf_core.Cell___set_rain_source, None, Cell)
Cell.__get_rain_source = new_instancemethod(_cmf_core.Cell___get_rain_source, None, Cell)
Cell.set_uptakestress = new_instancemethod(_cmf_core.Cell_set_uptakestress, None, Cell)
Cell.__get_evaporation = new_instancemethod(_cmf_core.Cell___get_evaporation, None, Cell)
Cell.__get_transpiration = new_instancemethod(_cmf_core.Cell___get_transpiration, None, Cell)
Cell.get_surfacewater = new_instancemethod(_cmf_core.Cell_get_surfacewater, None, Cell)
Cell.surfacewater_as_storage = new_instancemethod(_cmf_core.Cell_surfacewater_as_storage, None, Cell)
Cell.add_storage = new_instancemethod(_cmf_core.Cell_add_storage, None, Cell)
Cell.remove_storage = new_instancemethod(_cmf_core.Cell_remove_storage, None, Cell)
Cell.storage_count = new_instancemethod(_cmf_core.Cell_storage_count, None, Cell)
Cell.get_storage = new_instancemethod(_cmf_core.Cell_get_storage, None, Cell)
Cell.get_canopy = new_instancemethod(_cmf_core.Cell_get_canopy, None, Cell)
Cell.get_snow = new_instancemethod(_cmf_core.Cell_get_snow, None, Cell)
Cell.snow_coverage = new_instancemethod(_cmf_core.Cell_snow_coverage, None, Cell)
Cell.albedo = new_instancemethod(_cmf_core.Cell_albedo, None, Cell)
Cell.surface_water_coverage = new_instancemethod(_cmf_core.Cell_surface_water_coverage, None, Cell)
Cell.heat_flux = new_instancemethod(_cmf_core.Cell_heat_flux, None, Cell)
Cell.leave_wetness = new_instancemethod(_cmf_core.Cell_leave_wetness, None, Cell)
Cell.get_weather = new_instancemethod(_cmf_core.Cell_get_weather, None, Cell)
Cell.layer_count = new_instancemethod(_cmf_core.Cell_layer_count, None, Cell)
Cell.get_layer = new_instancemethod(_cmf_core.Cell_get_layer, None, Cell)
Cell.add_layer = new_instancemethod(_cmf_core.Cell_add_layer, None, Cell)
Cell.remove_last_layer = new_instancemethod(_cmf_core.Cell_remove_last_layer, None, Cell)
Cell.remove_layers = new_instancemethod(_cmf_core.Cell_remove_layers, None, Cell)
Cell.to_string = new_instancemethod(_cmf_core.Cell_to_string, None, Cell)
Cell_swigregister = _cmf_core.Cell_swigregister
Cell_swigregister(Cell)

class Topology(object):
    """Proxy of C++ cmf::upslope::Topology class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    cell = _swig_property(_cmf_core.Topology_cell_get)
    x = _swig_property(_cmf_core.Topology_x_get, _cmf_core.Topology_x_set)
    y = _swig_property(_cmf_core.Topology_y_get, _cmf_core.Topology_y_set)
    z = _swig_property(_cmf_core.Topology_z_get, _cmf_core.Topology_z_set)

    def get_position(self, *args, **kwargs):
        """get_position(Topology self) -> point"""
        return _cmf_core.Topology_get_position(self, *args, **kwargs)


    def flowwidth(self, *args):
        """
        flowwidth(Topology self, Cell target) -> double
        flowwidth(Topology self, Topology target) -> double
        """
        return _cmf_core.Topology_flowwidth(self, *args)


    def AddNeighbor(self, *args):
        """
        AddNeighbor(Topology self, Cell target, double flowwidth)
        AddNeighbor(Topology self, Topology target, double flowwidth)
        """
        return _cmf_core.Topology_AddNeighbor(self, *args)


    def RemoveNeighbor(self, *args, **kwargs):
        """RemoveNeighbor(Topology self, Topology target)"""
        return _cmf_core.Topology_RemoveNeighbor(self, *args, **kwargs)


    def neighbor_count(self, *args, **kwargs):
        """neighbor_count(Topology self) -> size_t"""
        return _cmf_core.Topology_neighbor_count(self, *args, **kwargs)


    def MainOutlet(self, *args, **kwargs):
        """MainOutlet(Topology self, bool forceRecalc=False) -> Cell"""
        return _cmf_core.Topology_MainOutlet(self, *args, **kwargs)


    def ContributingArea(self, *args, **kwargs):
        """ContributingArea(Topology self) -> double"""
        return _cmf_core.Topology_ContributingArea(self, *args, **kwargs)


    def calculate_contributing_area(*args, **kwargs):
        """calculate_contributing_area(cell_vector arg1)"""
        return _cmf_core.Topology_calculate_contributing_area(*args, **kwargs)

    calculate_contributing_area = staticmethod(calculate_contributing_area)

    def __eq__(self, *args, **kwargs):
        """__eq__(Topology self, Topology cmp) -> bool"""
        return _cmf_core.Topology___eq__(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_Topology
Topology.get_position = new_instancemethod(_cmf_core.Topology_get_position, None, Topology)
Topology.flowwidth = new_instancemethod(_cmf_core.Topology_flowwidth, None, Topology)
Topology.AddNeighbor = new_instancemethod(_cmf_core.Topology_AddNeighbor, None, Topology)
Topology.RemoveNeighbor = new_instancemethod(_cmf_core.Topology_RemoveNeighbor, None, Topology)
Topology.neighbor_count = new_instancemethod(_cmf_core.Topology_neighbor_count, None, Topology)
Topology.MainOutlet = new_instancemethod(_cmf_core.Topology_MainOutlet, None, Topology)
Topology.ContributingArea = new_instancemethod(_cmf_core.Topology_ContributingArea, None, Topology)
Topology.__eq__ = new_instancemethod(_cmf_core.Topology___eq__, None, Topology)
Topology_swigregister = _cmf_core.Topology_swigregister
Topology_swigregister(Topology)

def Topology_calculate_contributing_area(*args, **kwargs):
    """Topology_calculate_contributing_area(cell_vector arg2)"""
    return _cmf_core.Topology_calculate_contributing_area(*args, **kwargs)

class neighbor_iterator(object):
    """Proxy of C++ cmf::upslope::neighbor_iterator 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::upslope::neighbor_iterator self, Cell cell) -> neighbor_iterator"""
        _cmf_core.neighbor_iterator_swiginit(self, _cmf_core.new_neighbor_iterator(*args, **kwargs))

    def cell(self, *args, **kwargs):
        """cell(neighbor_iterator self) -> Cell"""
        return _cmf_core.neighbor_iterator_cell(self, *args, **kwargs)


    def flowwidth(self, *args, **kwargs):
        """flowwidth(neighbor_iterator self) -> double"""
        return _cmf_core.neighbor_iterator_flowwidth(self, *args, **kwargs)


    def valid(self, *args, **kwargs):
        """valid(neighbor_iterator self) -> bool"""
        return _cmf_core.neighbor_iterator_valid(self, *args, **kwargs)


    def next(self, *args, **kwargs):
        """next(neighbor_iterator self) -> neighbor_iterator"""
        return _cmf_core.neighbor_iterator_next(self, *args, **kwargs)


    def __eq__(self, *args, **kwargs):
        """__eq__(neighbor_iterator self, neighbor_iterator cmp) -> bool"""
        return _cmf_core.neighbor_iterator___eq__(self, *args, **kwargs)


    def __neq__(self, *args, **kwargs):
        """__neq__(neighbor_iterator self, neighbor_iterator cmp) -> bool"""
        return _cmf_core.neighbor_iterator___neq__(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_neighbor_iterator
neighbor_iterator.cell = new_instancemethod(_cmf_core.neighbor_iterator_cell, None, neighbor_iterator)
neighbor_iterator.flowwidth = new_instancemethod(_cmf_core.neighbor_iterator_flowwidth, None, neighbor_iterator)
neighbor_iterator.valid = new_instancemethod(_cmf_core.neighbor_iterator_valid, None, neighbor_iterator)
neighbor_iterator.next = new_instancemethod(_cmf_core.neighbor_iterator_next, None, neighbor_iterator)
neighbor_iterator.__eq__ = new_instancemethod(_cmf_core.neighbor_iterator___eq__, None, neighbor_iterator)
neighbor_iterator.__neq__ = new_instancemethod(_cmf_core.neighbor_iterator___neq__, None, neighbor_iterator)
neighbor_iterator_swigregister = _cmf_core.neighbor_iterator_swigregister
neighbor_iterator_swigregister(neighbor_iterator)

class cell_vector(StateVariableOwner):
    """Proxy of C++ cmf::upslope::cell_vector 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):
        """
        __init__(cmf::upslope::cell_vector self) -> cell_vector
        __init__(cmf::upslope::cell_vector self, cell_vector copy) -> cell_vector
        """
        _cmf_core.cell_vector_swiginit(self, _cmf_core.new_cell_vector(*args))

    def __getitem__(self, *args):
        """
        __getitem__(cell_vector self, ptrdiff_t index) -> Cell
        __getitem__(cell_vector self, ptrdiff_t index) -> Cell
        """
        return _cmf_core.cell_vector___getitem__(self, *args)


    def append(self, *args, **kwargs):
        """append(cell_vector self, Cell cell)"""
        return _cmf_core.cell_vector_append(self, *args, **kwargs)


    def remove(self, *args):
        """
        remove(cell_vector self, ptrdiff_t index)
        remove(cell_vector self, Cell cell)
        """
        return _cmf_core.cell_vector_remove(self, *args)


    def pop(self, *args, **kwargs):
        """pop(cell_vector self) -> Cell"""
        return _cmf_core.cell_vector_pop(self, *args, **kwargs)


    def __len__(self, *args, **kwargs):
        """__len__(cell_vector self) -> size_t"""
        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"""
        return _cmf_core.cell_vector___getslice__(self, *args, **kwargs)


    def get_area(self, *args, **kwargs):
        """get_area(cell_vector self) -> double"""
        return _cmf_core.cell_vector_get_area(self, *args, **kwargs)


    def __contains__(self, *args, **kwargs):
        """__contains__(cell_vector self, Cell cell) -> bool"""
        return _cmf_core.cell_vector___contains__(self, *args, **kwargs)

    lowest = _swig_property(_cmf_core.cell_vector_lowest_get)
    highest = _swig_property(_cmf_core.cell_vector_highest_get)

    def __iter__(self):
        for i in range(len(self)):
            yield self[i]   
    def __repr__(self):
        if len(self):
            return "[%i cells, %0.0fm2, %0.0f - %0.0f m asl.]" % (len(self),self.get_area(),self.lowest.z,self.highest.z)
        else:
            return "<empty cell vector>"        

    __swig_destroy__ = _cmf_core.delete_cell_vector
cell_vector.__getitem__ = new_instancemethod(_cmf_core.cell_vector___getitem__, None, cell_vector)
cell_vector.append = new_instancemethod(_cmf_core.cell_vector_append, None, cell_vector)
cell_vector.remove = new_instancemethod(_cmf_core.cell_vector_remove, None, cell_vector)
cell_vector.pop = new_instancemethod(_cmf_core.cell_vector_pop, None, cell_vector)
cell_vector.__len__ = new_instancemethod(_cmf_core.cell_vector___len__, None, cell_vector)
cell_vector.__getslice__ = new_instancemethod(_cmf_core.cell_vector___getslice__, None, cell_vector)
cell_vector.get_area = new_instancemethod(_cmf_core.cell_vector_get_area, None, cell_vector)
cell_vector.__contains__ = new_instancemethod(_cmf_core.cell_vector___contains__, None, cell_vector)
cell_vector_swigregister = _cmf_core.cell_vector_swigregister
cell_vector_swigregister(cell_vector)


def find_cell(*args, **kwargs):
    """find_cell(cell_vector arg1, point p, double max_dist=1e20) -> Cell"""
    return _cmf_core.find_cell(*args, **kwargs)

def get_boundary_cells(*args, **kwargs):
    """get_boundary_cells(cell_vector cells) -> cell_vector"""
    return _cmf_core.get_boundary_cells(*args, **kwargs)

def get_connections(*args, **kwargs):
    """get_connections(cell_vector cells) -> connection_list"""
    return _cmf_core.get_connections(*args, **kwargs)

def connect_cells_with_flux(*args, **kwargs):
    """connect_cells_with_flux(cell_vector cells, CellConnector connect, int start_at_layer=0)"""
    return _cmf_core.connect_cells_with_flux(*args, **kwargs)

def fill_sinks(*args, **kwargs):
    """fill_sinks(cell_vector cells, double min_difference=0.001) -> int"""
    return _cmf_core.fill_sinks(*args, **kwargs)

def get_area(*args, **kwargs):
    """get_area(cell_vector cells) -> double"""
    return _cmf_core.get_area(*args, **kwargs)

def get_center(*args, **kwargs):
    """get_center(cell_vector cells) -> point"""
    return _cmf_core.get_center(*args, **kwargs)

def cell_positions(*args, **kwargs):
    """cell_positions(cell_vector cells) -> point_vector"""
    return _cmf_core.cell_positions(*args, **kwargs)

def cell_flux_directions(*args, **kwargs):
    """cell_flux_directions(cell_vector cells, Time arg2) -> point_vector"""
    return _cmf_core.cell_flux_directions(*args, **kwargs)

def cell2cellflux(*args, **kwargs):
    """cell2cellflux(Cell source, Cell target, Time t, bool subsurface_only=False) -> cmf::math::num_array"""
    return _cmf_core.cell2cellflux(*args, **kwargs)

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."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    pourpoint = _swig_property(_cmf_core.subcatchment_pourpoint_get)
    inflowcells = _swig_property(_cmf_core.subcatchment_inflowcells_get, _cmf_core.subcatchment_inflowcells_set)
    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"""
        _cmf_core.subcatchment_swiginit(self, _cmf_core.new_subcatchment(*args, **kwargs))
    __swig_destroy__ = _cmf_core.delete_subcatchment
subcatchment_swigregister = _cmf_core.subcatchment_swigregister
subcatchment_swigregister(subcatchment)


def pressure_to_waterhead(*args, **kwargs):
    """pressure_to_waterhead(double Pressure) -> double"""
    return _cmf_core.pressure_to_waterhead(*args, **kwargs)

def waterhead_to_pressure(*args, **kwargs):
    """waterhead_to_pressure(double waterhead) -> double"""
    return _cmf_core.waterhead_to_pressure(*args, **kwargs)

def pF_to_waterhead(*args, **kwargs):
    """pF_to_waterhead(double pF) -> double"""
    return _cmf_core.pF_to_waterhead(*args, **kwargs)

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."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def K(self, *args):
        """
        K(RetentionCurve self, real wetness) -> real
        K(RetentionCurve self, cmf::math::num_array const & wetness) -> cmf::math::num_array
        """
        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"""
        return _cmf_core.RetentionCurve_Wetness_eff(self, *args, **kwargs)


    def Porosity(self, *args, **kwargs):
        """Porosity(RetentionCurve self, real depth=0.0) -> real"""
        return _cmf_core.RetentionCurve_Porosity(self, *args, **kwargs)


    def VoidVolume(self, *args, **kwargs):
        """VoidVolume(RetentionCurve self, real upperDepth, real lowerDepth, real Area) -> real"""
        return _cmf_core.RetentionCurve_VoidVolume(self, *args, **kwargs)


    def FillHeight(self, *args, **kwargs):
        """FillHeight(RetentionCurve self, real lowerDepth, real Area, real Volume) -> real"""
        return _cmf_core.RetentionCurve_FillHeight(self, *args, **kwargs)


    def Diffusivity(self, *args):
        """
        Diffusivity(RetentionCurve self, real wetness) -> real
        Diffusivity(RetentionCurve self, cmf::math::num_array & wetness) -> cmf::math::num_array
        """
        return _cmf_core.RetentionCurve_Diffusivity(self, *args)


    def Wetness(self, *args):
        """
        Wetness(RetentionCurve self, real suction) -> real
        Wetness(RetentionCurve self, cmf::math::num_array const & suction) -> cmf::math::num_array
        """
        return _cmf_core.RetentionCurve_Wetness(self, *args)


    def theta(self, *args):
        """
        theta(RetentionCurve self, real wetness) -> real
        theta(RetentionCurve self, cmf::math::num_array const & wetness) -> cmf::math::num_array
        """
        return _cmf_core.RetentionCurve_theta(self, *args)


    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
        """
        return _cmf_core.RetentionCurve_dPsiM_dW(self, *args)


    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
        """
        return _cmf_core.RetentionCurve_Wetness_pF(self, *args)


    def MatricPotential(self, *args):
        """
        MatricPotential(RetentionCurve self, real wetness) -> real
        MatricPotential(RetentionCurve self, cmf::math::num_array const & wetness) -> cmf::math::num_array
        """
        return _cmf_core.RetentionCurve_MatricPotential(self, *args)


    def copy(self, *args, **kwargs):
        """copy(RetentionCurve self) -> RetentionCurve"""
        return _cmf_core.RetentionCurve_copy(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_RetentionCurve
RetentionCurve.K = new_instancemethod(_cmf_core.RetentionCurve_K, None, RetentionCurve)
RetentionCurve.Wetness_eff = new_instancemethod(_cmf_core.RetentionCurve_Wetness_eff, None, RetentionCurve)
RetentionCurve.Porosity = new_instancemethod(_cmf_core.RetentionCurve_Porosity, None, RetentionCurve)
RetentionCurve.VoidVolume = new_instancemethod(_cmf_core.RetentionCurve_VoidVolume, None, RetentionCurve)
RetentionCurve.FillHeight = new_instancemethod(_cmf_core.RetentionCurve_FillHeight, None, RetentionCurve)
RetentionCurve.Diffusivity = new_instancemethod(_cmf_core.RetentionCurve_Diffusivity, None, RetentionCurve)
RetentionCurve.Wetness = new_instancemethod(_cmf_core.RetentionCurve_Wetness, None, RetentionCurve)
RetentionCurve.theta = new_instancemethod(_cmf_core.RetentionCurve_theta, None, RetentionCurve)
RetentionCurve.dPsiM_dW = new_instancemethod(_cmf_core.RetentionCurve_dPsiM_dW, None, RetentionCurve)
RetentionCurve.Wetness_pF = new_instancemethod(_cmf_core.RetentionCurve_Wetness_pF, None, RetentionCurve)
RetentionCurve.MatricPotential = new_instancemethod(_cmf_core.RetentionCurve_MatricPotential, None, RetentionCurve)
RetentionCurve.copy = new_instancemethod(_cmf_core.RetentionCurve_copy, None, RetentionCurve)
RetentionCurve_swigregister = _cmf_core.RetentionCurve_swigregister
RetentionCurve_swigregister(RetentionCurve)
rho_wg = cvar.rho_wg

class BrooksCoreyRetentionCurve(RetentionCurve):
    """Proxy of C++ cmf::upslope::BrooksCoreyRetentionCurve class."""

    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)"""
        return _cmf_core.BrooksCoreyRetentionCurve_SetPorosity(self, *args, **kwargs)


    def Transmissivity(self, *args, **kwargs):
        """Transmissivity(BrooksCoreyRetentionCurve self, real upperDepth, real lowerDepth, real theta) -> real"""
        return _cmf_core.BrooksCoreyRetentionCurve_Transmissivity(self, *args, **kwargs)

    wetness_X = _swig_property(_cmf_core.BrooksCoreyRetentionCurve_wetness_X_get, _cmf_core.BrooksCoreyRetentionCurve_wetness_X_set)
    Psi_X = _swig_property(_cmf_core.BrooksCoreyRetentionCurve_Psi_X_get, _cmf_core.BrooksCoreyRetentionCurve_Psi_X_set)
    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"""
        _cmf_core.BrooksCoreyRetentionCurve_swiginit(self, _cmf_core.new_BrooksCoreyRetentionCurve(*args, **kwargs))

    def CreateFrom2Points(*args, **kwargs):
        """CreateFrom2Points(real ksat, real porosity, real theta1, real theta2, real psi_1, real psi_2) -> BrooksCoreyRetentionCurve"""
        return _cmf_core.BrooksCoreyRetentionCurve_CreateFrom2Points(*args, **kwargs)

    CreateFrom2Points = staticmethod(CreateFrom2Points)

    def copy(self, *args, **kwargs):
        """copy(BrooksCoreyRetentionCurve self) -> BrooksCoreyRetentionCurve"""
        return _cmf_core.BrooksCoreyRetentionCurve_copy(self, *args, **kwargs)

    b = _swig_property(_cmf_core.BrooksCoreyRetentionCurve_b_get, _cmf_core.BrooksCoreyRetentionCurve_b_set)

    def __repr__(self):
        return "cmf.BrooksCoreyRetentionCurve(Ksat=%g,phi=%g,b=%g,wfp0=%0.1f,pF0=%0.2f)" % (self.Ksat,self.Porosity(0.0),self.b,self.wetness_X,waterhead_to_pF(self.Psi_X))
    def __str__(self):
        return "Brooks-Corey retention curve: Ksat=%0.3g m/day,por.=%0.0f%%,b=%g,%0.1f%% water content at pF%0.2f)" % (self.Ksat,self.Porosity(0.0)*100,self.b,self.wetness_X * self.Porosity(0.0) * 100,waterhead_to_pF(self.Psi_X))

    __swig_destroy__ = _cmf_core.delete_BrooksCoreyRetentionCurve
BrooksCoreyRetentionCurve.SetPorosity = new_instancemethod(_cmf_core.BrooksCoreyRetentionCurve_SetPorosity, None, BrooksCoreyRetentionCurve)
BrooksCoreyRetentionCurve.Transmissivity = new_instancemethod(_cmf_core.BrooksCoreyRetentionCurve_Transmissivity, None, BrooksCoreyRetentionCurve)
BrooksCoreyRetentionCurve.copy = new_instancemethod(_cmf_core.BrooksCoreyRetentionCurve_copy, None, BrooksCoreyRetentionCurve)
BrooksCoreyRetentionCurve_swigregister = _cmf_core.BrooksCoreyRetentionCurve_swigregister
BrooksCoreyRetentionCurve_swigregister(BrooksCoreyRetentionCurve)

def BrooksCoreyRetentionCurve_CreateFrom2Points(*args, **kwargs):
    """BrooksCoreyRetentionCurve_CreateFrom2Points(real ksat, real porosity, real theta1, real theta2, real psi_1, real psi_2) -> BrooksCoreyRetentionCurve"""
    return _cmf_core.BrooksCoreyRetentionCurve_CreateFrom2Points(*args, **kwargs)

class VanGenuchtenMualem(RetentionCurve):
    """Proxy of C++ cmf::upslope::VanGenuchtenMualem class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    alpha = _swig_property(_cmf_core.VanGenuchtenMualem_alpha_get, _cmf_core.VanGenuchtenMualem_alpha_set)
    n = _swig_property(_cmf_core.VanGenuchtenMualem_n_get, _cmf_core.VanGenuchtenMualem_n_set)
    Ksat = _swig_property(_cmf_core.VanGenuchtenMualem_Ksat_get, _cmf_core.VanGenuchtenMualem_Ksat_set)
    Phi = _swig_property(_cmf_core.VanGenuchtenMualem_Phi_get, _cmf_core.VanGenuchtenMualem_Phi_set)
    m = _swig_property(_cmf_core.VanGenuchtenMualem_m_get, _cmf_core.VanGenuchtenMualem_m_set)
    l = _swig_property(_cmf_core.VanGenuchtenMualem_l_get, _cmf_core.VanGenuchtenMualem_l_set)
    theta_r = _swig_property(_cmf_core.VanGenuchtenMualem_theta_r_get, _cmf_core.VanGenuchtenMualem_theta_r_set)
    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"""
        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"""
        return _cmf_core.VanGenuchtenMualem_fit_w0(self, *args, **kwargs)


    def copy(self, *args, **kwargs):
        """copy(VanGenuchtenMualem self) -> VanGenuchtenMualem"""
        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"""
        _cmf_core.VanGenuchtenMualem_swiginit(self, _cmf_core.new_VanGenuchtenMualem(*args, **kwargs))

    def __repr__(self):
        return "cmf.VanGenuchtenMualem(Ksat=%0.3g,Phi=%0.3g,alpha=%0.3g,n=%0.3g,m=%0.3g)" % (self.Ksat,self.Phi,self.alpha,self.n,self.m)
    def __str__(self):
    	return "VanGenuchten / Mualem retention curve: Ksat=%0.3g m/day, %0.3g%% Pores, alpha=%0.3g 1/cm, n=%0.3g" % (self.Ksat,self.Phi*100,self.alpha,self.n) 

    __swig_destroy__ = _cmf_core.delete_VanGenuchtenMualem
VanGenuchtenMualem.Transmissivity = new_instancemethod(_cmf_core.VanGenuchtenMualem_Transmissivity, None, VanGenuchtenMualem)
VanGenuchtenMualem.fit_w0 = new_instancemethod(_cmf_core.VanGenuchtenMualem_fit_w0, None, VanGenuchtenMualem)
VanGenuchtenMualem.copy = new_instancemethod(_cmf_core.VanGenuchtenMualem_copy, None, VanGenuchtenMualem)
VanGenuchtenMualem_swigregister = _cmf_core.VanGenuchtenMualem_swigregister
VanGenuchtenMualem_swigregister(VanGenuchtenMualem)

class LinearRetention(RetentionCurve):
    """Proxy of C++ cmf::upslope::LinearRetention class."""

    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.LinearRetention_Ksat_get, _cmf_core.LinearRetention_Ksat_set)
    porosity = _swig_property(_cmf_core.LinearRetention_porosity_get, _cmf_core.LinearRetention_porosity_set)
    thickness = _swig_property(_cmf_core.LinearRetention_thickness_get, _cmf_core.LinearRetention_thickness_set)
    residual_wetness = _swig_property(_cmf_core.LinearRetention_residual_wetness_get, _cmf_core.LinearRetention_residual_wetness_set)
    porosity_decay = _swig_property(_cmf_core.LinearRetention_porosity_decay_get, _cmf_core.LinearRetention_porosity_decay_set)
    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"""
        return _cmf_core.LinearRetention_Transmissivity(self, *args, **kwargs)


    def copy(self, *args, **kwargs):
        """copy(LinearRetention self) -> LinearRetention"""
        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"""
        _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)
LinearRetention.copy = new_instancemethod(_cmf_core.LinearRetention_copy, None, LinearRetention)
LinearRetention_swigregister = _cmf_core.LinearRetention_swigregister
LinearRetention_swigregister(LinearRetention)

class SoilLayer(WaterStorage):
    """Proxy of C++ cmf::upslope::SoilLayer class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    Position = _swig_property(_cmf_core.SoilLayer_Position_get)
    cell = _swig_property(_cmf_core.SoilLayer_cell_get)

    def __get_upper(self, *args, **kwargs):
        """__get_upper(SoilLayer self) -> cmf::upslope::SoilLayer::ptr"""
        return _cmf_core.SoilLayer___get_upper(self, *args, **kwargs)


    def __get_lower(self, *args, **kwargs):
        """__get_lower(SoilLayer self) -> cmf::upslope::SoilLayer::ptr"""
        return _cmf_core.SoilLayer___get_lower(self, *args, **kwargs)


    def get_soil(self, *args, **kwargs):
        """get_soil(SoilLayer self) -> RetentionCurve"""
        return _cmf_core.SoilLayer_get_soil(self, *args, **kwargs)


    def set_soil(self, *args, **kwargs):
        """set_soil(SoilLayer self, 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"""
        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"""
        return _cmf_core.SoilLayer_get_capacity(self, *args, **kwargs)


    def get_saturated_depth(self, *args, **kwargs):
        """get_saturated_depth(SoilLayer self) -> real"""
        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"""
        return _cmf_core.SoilLayer_get_flow_crosssection(self, *args, **kwargs)


    def cast(*args, **kwargs):
        """cast(cmf::water::flux_node::ptr node) -> cmf::upslope::SoilLayer::ptr"""
        return _cmf_core.SoilLayer_cast(*args, **kwargs)

    cast = staticmethod(cast)
    gravitational_potential = _swig_property(_cmf_core.SoilLayer_gravitational_potential_get)
    matrix_potential = _swig_property(_cmf_core.SoilLayer_matrix_potential_get)
    wetness = _swig_property(_cmf_core.SoilLayer_wetness_get, _cmf_core.SoilLayer_wetness_set)
    theta = _swig_property(_cmf_core.SoilLayer_theta_get, _cmf_core.SoilLayer_theta_set)
    K = _swig_property(_cmf_core.SoilLayer_K_get)
    Ksat = _swig_property(_cmf_core.SoilLayer_Ksat_get)
    thickness = _swig_property(_cmf_core.SoilLayer_thickness_get)
    lower_boundary = _swig_property(_cmf_core.SoilLayer_lower_boundary_get)
    upper_boundary = _swig_property(_cmf_core.SoilLayer_upper_boundary_get)
    porosity = _swig_property(_cmf_core.SoilLayer_porosity_get)
    ice_fraction = _swig_property(_cmf_core.SoilLayer_ice_fraction_get, _cmf_core.SoilLayer_ice_fraction_set)
    rootfraction = _swig_property(_cmf_core.SoilLayer_rootfraction_get, _cmf_core.SoilLayer_rootfraction_set)

    upper = _swig_property(_cmf_core.SoilLayer___get_upper)


    lower = _swig_property(_cmf_core.SoilLayer___get_lower)


    boundary=property(lambda self:(self.upper_boundary,self.lower_boundary),None,"Returns the upper and lower boundary of the layer")
    pF=property(lambda self : waterhead_to_pF(self.matrix_potential),None,"The actual pF value")
    soil=property(get_soil,set_soil,"The retention curve of the layer")


    def __repr__(self): 
        return self.to_string()

    __swig_destroy__ = _cmf_core.delete_SoilLayer
SoilLayer.__get_upper = new_instancemethod(_cmf_core.SoilLayer___get_upper, None, SoilLayer)
SoilLayer.__get_lower = new_instancemethod(_cmf_core.SoilLayer___get_lower, None, SoilLayer)
SoilLayer.get_soil = new_instancemethod(_cmf_core.SoilLayer_get_soil, None, SoilLayer)
SoilLayer.set_soil = new_instancemethod(_cmf_core.SoilLayer_set_soil, None, SoilLayer)
SoilLayer.get_K = new_instancemethod(_cmf_core.SoilLayer_get_K, None, SoilLayer)
SoilLayer.get_capacity = new_instancemethod(_cmf_core.SoilLayer_get_capacity, None, SoilLayer)
SoilLayer.get_saturated_depth = new_instancemethod(_cmf_core.SoilLayer_get_saturated_depth, None, SoilLayer)
SoilLayer.get_flow_crosssection = new_instancemethod(_cmf_core.SoilLayer_get_flow_crosssection, None, SoilLayer)
SoilLayer_swigregister = _cmf_core.SoilLayer_swigregister
SoilLayer_swigregister(SoilLayer)

def SoilLayer_cast(*args, **kwargs):
    """SoilLayer_cast(cmf::water::flux_node::ptr node) -> cmf::upslope::SoilLayer::ptr"""
    return _cmf_core.SoilLayer_cast(*args, **kwargs)

class layer_list(object):
    """Proxy of C++ cmf::upslope::layer_list 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):
        """
        __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
        """
        _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"""
        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"""
        return _cmf_core.layer_list_append(self, *args, **kwargs)


    def extend(self, *args):
        """
        extend(layer_list self, layer_list ll) -> layer_list
        extend(layer_list self, node_list nl) -> layer_list
        """
        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"""
        return _cmf_core.layer_list_get_slice(self, *args, **kwargs)


    def clear(self, *args, **kwargs):
        """clear(layer_list self)"""
        return _cmf_core.layer_list_clear(self, *args, **kwargs)


    def size(self, *args, **kwargs):
        """size(layer_list self) -> size_t"""
        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)"""
        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)"""
        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)"""
        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"""
        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)"""
        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)"""
        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)"""
        return _cmf_core.layer_list_set_rootfraction(self, *args, **kwargs)

    gravitational_potential = _swig_property(_cmf_core.layer_list_gravitational_potential_get)
    matrix_potential = _swig_property(_cmf_core.layer_list_matrix_potential_get)
    wetness = _swig_property(_cmf_core.layer_list_wetness_get)
    volume = _swig_property(_cmf_core.layer_list_volume_get)
    potential = _swig_property(_cmf_core.layer_list_potential_get)
    K = _swig_property(_cmf_core.layer_list_K_get)
    Ksat = _swig_property(_cmf_core.layer_list_Ksat_get)
    thickness = _swig_property(_cmf_core.layer_list_thickness_get)
    lower_boundary = _swig_property(_cmf_core.layer_list_lower_boundary_get)
    upper_boundary = _swig_property(_cmf_core.layer_list_upper_boundary_get)
    porosity = _swig_property(_cmf_core.layer_list_porosity_get)
    ice_fraction = _swig_property(_cmf_core.layer_list_ice_fraction_get)
    theta = _swig_property(_cmf_core.layer_list_theta_get)
    root = _swig_property(_cmf_core.layer_list_root_get)

    def __get(self, *args, **kwargs):
        """__get(layer_list self, int index) -> cmf::upslope::SoilLayer::ptr"""
        return _cmf_core.layer_list___get(self, *args, **kwargs)


    __repr__=lambda self: repr(list(self))
    __str__ =lambda self: str(list(self))
    __len__=lambda self: self.size()
    def __iadd__(self,other):
        self.append(other)
        return self
    def __add__(self,other):
        res = layer_list(self)
        res.append(other)
        return res
    def __iter__(self):
        for i in range(len(self)):
            yield self[i]
    def __getitem__(self,index):
        if (type(index)==slice):
            return self.get_slice(*index.indices(len(self)))
        try:
            gen=iter(index)
            return [self.__get(it) for it in gen]
        except TypeError:
             return self.__get(index)      

    __swig_destroy__ = _cmf_core.delete_layer_list
layer_list.pop = new_instancemethod(_cmf_core.layer_list_pop, None, layer_list)
layer_list.append = new_instancemethod(_cmf_core.layer_list_append, None, layer_list)
layer_list.extend = new_instancemethod(_cmf_core.layer_list_extend, None, layer_list)
layer_list.get_slice = new_instancemethod(_cmf_core.layer_list_get_slice, None, layer_list)
layer_list.clear = new_instancemethod(_cmf_core.layer_list_clear, None, layer_list)
layer_list.size = new_instancemethod(_cmf_core.layer_list_size, None, layer_list)
layer_list.set_wetness = new_instancemethod(_cmf_core.layer_list_set_wetness, None, layer_list)
layer_list.set_potential = new_instancemethod(_cmf_core.layer_list_set_potential, None, layer_list)
layer_list.set_volume = new_instancemethod(_cmf_core.layer_list_set_volume, None, layer_list)
layer_list.get_percolation = new_instancemethod(_cmf_core.layer_list_get_percolation, None, layer_list)
layer_list.set_theta = new_instancemethod(_cmf_core.layer_list_set_theta, None, layer_list)
layer_list.set_ice_fraction = new_instancemethod(_cmf_core.layer_list_set_ice_fraction, None, layer_list)
layer_list.set_rootfraction = new_instancemethod(_cmf_core.layer_list_set_rootfraction, None, layer_list)
layer_list.__get = new_instancemethod(_cmf_core.layer_list___get, None, layer_list)
layer_list_swigregister = _cmf_core.layer_list_swigregister
layer_list_swigregister(layer_list)

class MacroPore(WaterStorage):
    """Proxy of C++ cmf::upslope::MacroPore class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    porefraction_min = _swig_property(_cmf_core.MacroPore_porefraction_min_get, _cmf_core.MacroPore_porefraction_min_set)
    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"""
        return _cmf_core.MacroPore___get_layer(self, *args, **kwargs)


    def get_porefraction(self, *args, **kwargs):
        """get_porefraction(MacroPore self) -> real"""
        return _cmf_core.MacroPore_get_porefraction(self, *args, **kwargs)

    density = _swig_property(_cmf_core.MacroPore_density_get, _cmf_core.MacroPore_density_set)
    Ksat = _swig_property(_cmf_core.MacroPore_Ksat_get, _cmf_core.MacroPore_Ksat_set)
    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"""
        return _cmf_core.MacroPore_get_K(self, *args, **kwargs)


    def get_crackwidth(self, *args, **kwargs):
        """get_crackwidth(MacroPore self) -> real"""
        return _cmf_core.MacroPore_get_crackwidth(self, *args, **kwargs)


    def get_flowwidth(self, *args, **kwargs):
        """get_flowwidth(MacroPore self) -> real"""
        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)

    def create(*args, **kwargs):
        """create(cmf::upslope::SoilLayer::ptr layer, real porefraction=0.05, real Ksat=10, real density=0.05, real porefraction_wilt=-1., real K_shape=0.0) -> cmf::upslope::MacroPore::ptr"""
        return _cmf_core.MacroPore_create(*args, **kwargs)

    create = staticmethod(create)

    def cast(*args, **kwargs):
        """cast(cmf::water::flux_node::ptr node) -> cmf::upslope::MacroPore::ptr"""
        return _cmf_core.MacroPore_cast(*args, **kwargs)

    cast = staticmethod(cast)

    def __repr__(self): 
        return self.to_string()


    layer = _swig_property(_cmf_core.MacroPore___get_layer)

    filled_fraction = _swig_property(_cmf_core.MacroPore_filled_fraction_get)
    K = _swig_property(_cmf_core.MacroPore_K_get)
    capacity = _swig_property(_cmf_core.MacroPore_capacity_get)
    cell = _swig_property(_cmf_core.MacroPore_cell_get)
    __swig_destroy__ = _cmf_core.delete_MacroPore
MacroPore.__get_layer = new_instancemethod(_cmf_core.MacroPore___get_layer, None, MacroPore)
MacroPore.get_porefraction = new_instancemethod(_cmf_core.MacroPore_get_porefraction, None, MacroPore)
MacroPore.get_K = new_instancemethod(_cmf_core.MacroPore_get_K, None, MacroPore)
MacroPore.get_crackwidth = new_instancemethod(_cmf_core.MacroPore_get_crackwidth, None, MacroPore)
MacroPore.get_flowwidth = new_instancemethod(_cmf_core.MacroPore_get_flowwidth, None, MacroPore)
MacroPore_swigregister = _cmf_core.MacroPore_swigregister
MacroPore_swigregister(MacroPore)

def MacroPore_create(*args, **kwargs):
    """MacroPore_create(cmf::upslope::SoilLayer::ptr layer, real porefraction=0.05, real Ksat=10, real density=0.05, real porefraction_wilt=-1., real K_shape=0.0) -> cmf::upslope::MacroPore::ptr"""
    return _cmf_core.MacroPore_create(*args, **kwargs)

def MacroPore_cast(*args, **kwargs):
    """MacroPore_cast(cmf::water::flux_node::ptr node) -> cmf::upslope::MacroPore::ptr"""
    return _cmf_core.MacroPore_cast(*args, **kwargs)

class BaseMacroFlow(flux_connection):
    """Proxy of C++ cmf::upslope::connections::BaseMacroFlow class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _cmf_core.delete_BaseMacroFlow
BaseMacroFlow_swigregister = _cmf_core.BaseMacroFlow_swigregister
BaseMacroFlow_swigregister(BaseMacroFlow)

class GradientMacroFlow(BaseMacroFlow):
    """Proxy of C++ cmf::upslope::connections::GradientMacroFlow 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::upslope::connections::GradientMacroFlow self, cmf::upslope::MacroPore::ptr left, cmf::water::flux_node::ptr right) -> GradientMacroFlow"""
        _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."""

    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"""
        _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."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    beta = _swig_property(_cmf_core.JarvisMacroFlow_beta_get, _cmf_core.JarvisMacroFlow_beta_set)
    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"""
        _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."""

    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"""
        _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."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    omega = _swig_property(_cmf_core.DiffusiveMacroMicroExchange_omega_get, _cmf_core.DiffusiveMacroMicroExchange_omega_set)
    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"""
        _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."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Gf = _swig_property(_cmf_core.MACROlikeMacroMicroExchange_Gf_get, _cmf_core.MACROlikeMacroMicroExchange_Gf_set)
    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"""
        _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."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def h(self, *args, **kwargs):
        """h(IVolumeHeightFunction self, double V) -> double"""
        return _cmf_core.IVolumeHeightFunction_h(self, *args, **kwargs)


    def A(self, *args, **kwargs):
        """A(IVolumeHeightFunction self, double V) -> double"""
        return _cmf_core.IVolumeHeightFunction_A(self, *args, **kwargs)


    def V(self, *args, **kwargs):
        """V(IVolumeHeightFunction self, double h) -> double"""
        return _cmf_core.IVolumeHeightFunction_V(self, *args, **kwargs)


    def copy(self, *args, **kwargs):
        """copy(IVolumeHeightFunction self) -> IVolumeHeightFunction"""
        return _cmf_core.IVolumeHeightFunction_copy(self, *args, **kwargs)


    def q(self, *args, **kwargs):
        """q(IVolumeHeightFunction self, double h, double slope) -> double"""
        return _cmf_core.IVolumeHeightFunction_q(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_IVolumeHeightFunction
IVolumeHeightFunction.h = new_instancemethod(_cmf_core.IVolumeHeightFunction_h, None, IVolumeHeightFunction)
IVolumeHeightFunction.A = new_instancemethod(_cmf_core.IVolumeHeightFunction_A, None, IVolumeHeightFunction)
IVolumeHeightFunction.V = new_instancemethod(_cmf_core.IVolumeHeightFunction_V, None, IVolumeHeightFunction)
IVolumeHeightFunction.copy = new_instancemethod(_cmf_core.IVolumeHeightFunction_copy, None, IVolumeHeightFunction)
IVolumeHeightFunction.q = new_instancemethod(_cmf_core.IVolumeHeightFunction_q, None, IVolumeHeightFunction)
IVolumeHeightFunction_swigregister = _cmf_core.IVolumeHeightFunction_swigregister
IVolumeHeightFunction_swigregister(IVolumeHeightFunction)

class Prism(IVolumeHeightFunction):
    """Proxy of C++ cmf::river::Prism class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Area = _swig_property(_cmf_core.Prism_Area_get, _cmf_core.Prism_Area_set)
    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"""
        _cmf_core.Prism_swiginit(self, _cmf_core.new_Prism(*args, **kwargs))

    def copy(self, *args, **kwargs):
        """copy(Prism self) -> Prism"""
        return _cmf_core.Prism_copy(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_Prism
Prism.copy = new_instancemethod(_cmf_core.Prism_copy, None, Prism)
Prism_swigregister = _cmf_core.Prism_swigregister
Prism_swigregister(Prism)

class volume_height_function(IVolumeHeightFunction):
    """Proxy of C++ cmf::river::volume_height_function 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):
        """
        __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
        """
        _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"""
        return _cmf_core.volume_height_function_copy(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_volume_height_function
volume_height_function.copy = new_instancemethod(_cmf_core.volume_height_function_copy, None, volume_height_function)
volume_height_function_swigregister = _cmf_core.volume_height_function_swigregister
volume_height_function_swigregister(volume_height_function)

class IChannel(IVolumeHeightFunction):
    """Proxy of C++ cmf::river::IChannel class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def get_nManning(self, *args, **kwargs):
        """get_nManning(IChannel self) -> double"""
        return _cmf_core.IChannel_get_nManning(self, *args, **kwargs)


    def set_nManning(self, *args, **kwargs):
        """set_nManning(IChannel self, double val)"""
        return _cmf_core.IChannel_set_nManning(self, *args, **kwargs)


    def get_length(self, *args, **kwargs):
        """get_length(IChannel self) -> double"""
        return _cmf_core.IChannel_get_length(self, *args, **kwargs)


    def typecode(self, *args, **kwargs):
        """typecode(IChannel self) -> char"""
        return _cmf_core.IChannel_typecode(self, *args, **kwargs)


    def get_channel_width(self, *args, **kwargs):
        """get_channel_width(IChannel self, double depth) -> double"""
        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"""
        return _cmf_core.IChannel_get_wetted_perimeter(self, *args, **kwargs)


    def get_depth(self, *args, **kwargs):
        """get_depth(IChannel self, double area) -> double"""
        return _cmf_core.IChannel_get_depth(self, *args, **kwargs)


    def get_flux_crossection(self, *args, **kwargs):
        """get_flux_crossection(IChannel self, double depth) -> double"""
        return _cmf_core.IChannel_get_flux_crossection(self, *args, **kwargs)


    def copy(self, *args, **kwargs):
        """copy(IChannel self) -> IChannel"""
        return _cmf_core.IChannel_copy(self, *args, **kwargs)


    def qManning(self, *args, **kwargs):
        """qManning(IChannel self, double A, double slope) -> double"""
        return _cmf_core.IChannel_qManning(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_IChannel
IChannel.get_nManning = new_instancemethod(_cmf_core.IChannel_get_nManning, None, IChannel)
IChannel.set_nManning = new_instancemethod(_cmf_core.IChannel_set_nManning, None, IChannel)
IChannel.get_length = new_instancemethod(_cmf_core.IChannel_get_length, None, IChannel)
IChannel.typecode = new_instancemethod(_cmf_core.IChannel_typecode, None, IChannel)
IChannel.get_channel_width = new_instancemethod(_cmf_core.IChannel_get_channel_width, None, IChannel)
IChannel.get_wetted_perimeter = new_instancemethod(_cmf_core.IChannel_get_wetted_perimeter, None, IChannel)
IChannel.get_depth = new_instancemethod(_cmf_core.IChannel_get_depth, None, IChannel)
IChannel.get_flux_crossection = new_instancemethod(_cmf_core.IChannel_get_flux_crossection, None, IChannel)
IChannel.copy = new_instancemethod(_cmf_core.IChannel_copy, None, IChannel)
IChannel.qManning = new_instancemethod(_cmf_core.IChannel_qManning, None, IChannel)
IChannel_swigregister = _cmf_core.IChannel_swigregister
IChannel_swigregister(IChannel)

class SWATReachType(IChannel):
    """Proxy of C++ cmf::river::SWATReachType class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    BottomWidth = _swig_property(_cmf_core.SWATReachType_BottomWidth_get, _cmf_core.SWATReachType_BottomWidth_set)
    ChannelDepth = _swig_property(_cmf_core.SWATReachType_ChannelDepth_get, _cmf_core.SWATReachType_ChannelDepth_set)
    BankSlope = _swig_property(_cmf_core.SWATReachType_BankSlope_get, _cmf_core.SWATReachType_BankSlope_set)
    FloodPlainSlope = _swig_property(_cmf_core.SWATReachType_FloodPlainSlope_get, _cmf_core.SWATReachType_FloodPlainSlope_set)

    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
        """
        _cmf_core.SWATReachType_swiginit(self, _cmf_core.new_SWATReachType(*args))

    def copy(self, *args, **kwargs):
        """copy(SWATReachType self) -> SWATReachType"""
        return _cmf_core.SWATReachType_copy(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_SWATReachType
SWATReachType.copy = new_instancemethod(_cmf_core.SWATReachType_copy, None, SWATReachType)
SWATReachType_swigregister = _cmf_core.SWATReachType_swigregister
SWATReachType_swigregister(SWATReachType)

class TriangularReach(IChannel):
    """Proxy of C++ cmf::river::TriangularReach class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    BankSlope = _swig_property(_cmf_core.TriangularReach_BankSlope_get, _cmf_core.TriangularReach_BankSlope_set)

    def __init__(self, *args):
        """
        __init__(cmf::river::TriangularReach self, double l, double bankSlope=2) -> TriangularReach
        __init__(cmf::river::TriangularReach self, TriangularReach copy) -> TriangularReach
        """
        _cmf_core.TriangularReach_swiginit(self, _cmf_core.new_TriangularReach(*args))

    def copy(self, *args, **kwargs):
        """copy(TriangularReach self) -> TriangularReach"""
        return _cmf_core.TriangularReach_copy(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_TriangularReach
TriangularReach.copy = new_instancemethod(_cmf_core.TriangularReach_copy, None, TriangularReach)
TriangularReach_swigregister = _cmf_core.TriangularReach_swigregister
TriangularReach_swigregister(TriangularReach)

class RectangularReach(IChannel):
    """Proxy of C++ cmf::river::RectangularReach 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):
        """
        __init__(cmf::river::RectangularReach self, double l, double width) -> RectangularReach
        __init__(cmf::river::RectangularReach self, RectangularReach copy) -> RectangularReach
        """
        _cmf_core.RectangularReach_swiginit(self, _cmf_core.new_RectangularReach(*args))

    def copy(self, *args, **kwargs):
        """copy(RectangularReach self) -> RectangularReach"""
        return _cmf_core.RectangularReach_copy(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_RectangularReach
RectangularReach.copy = new_instancemethod(_cmf_core.RectangularReach_copy, None, RectangularReach)
RectangularReach_swigregister = _cmf_core.RectangularReach_swigregister
RectangularReach_swigregister(RectangularReach)

class PipeReach(IChannel):
    """Proxy of C++ cmf::river::PipeReach class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    radius = _swig_property(_cmf_core.PipeReach_radius_get, _cmf_core.PipeReach_radius_set)

    def __init__(self, *args):
        """
        __init__(cmf::river::PipeReach self, double l, double diameter) -> PipeReach
        __init__(cmf::river::PipeReach self, PipeReach copy) -> PipeReach
        """
        _cmf_core.PipeReach_swiginit(self, _cmf_core.new_PipeReach(*args))

    def copy(self, *args, **kwargs):
        """copy(PipeReach self) -> PipeReach"""
        return _cmf_core.PipeReach_copy(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_PipeReach
PipeReach.copy = new_instancemethod(_cmf_core.PipeReach_copy, None, PipeReach)
PipeReach_swigregister = _cmf_core.PipeReach_swigregister
PipeReach_swigregister(PipeReach)

class Channel(IChannel):
    """Proxy of C++ cmf::river::Channel 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):
        """
        __init__(cmf::river::Channel self) -> Channel
        __init__(cmf::river::Channel self, double length) -> Channel
        __init__(cmf::river::Channel self, IChannel for_wrapping) -> Channel
        __init__(cmf::river::Channel self, IVolumeHeightFunction for_casting) -> Channel
        __init__(cmf::river::Channel self, Channel for_copy) -> Channel
        __init__(cmf::river::Channel self, char typecode, double length, double width=1., double depth=0.25) -> Channel
        """
        _cmf_core.Channel_swiginit(self, _cmf_core.new_Channel(*args))

    def copy(self, *args, **kwargs):
        """copy(Channel self) -> Channel"""
        return _cmf_core.Channel_copy(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_Channel
Channel.copy = new_instancemethod(_cmf_core.Channel_copy, None, Channel)
Channel_swigregister = _cmf_core.Channel_swigregister
Channel_swigregister(Channel)

class MeanChannel(IChannel):
    """Proxy of C++ cmf::river::MeanChannel 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):
        """
        __init__(cmf::river::MeanChannel self, IChannel channel1, IChannel channel2) -> MeanChannel
        __init__(cmf::river::MeanChannel self, MeanChannel meanChannel) -> MeanChannel
        """
        _cmf_core.MeanChannel_swiginit(self, _cmf_core.new_MeanChannel(*args))

    def copy(self, *args, **kwargs):
        """copy(MeanChannel self) -> MeanChannel"""
        return _cmf_core.MeanChannel_copy(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_MeanChannel
MeanChannel.copy = new_instancemethod(_cmf_core.MeanChannel_copy, None, MeanChannel)
MeanChannel_swigregister = _cmf_core.MeanChannel_swigregister
MeanChannel_swigregister(MeanChannel)

class OpenWaterStorage(WaterStorage):
    """Proxy of C++ cmf::river::OpenWaterStorage class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def get_height_function(self, *args, **kwargs):
        """get_height_function(OpenWaterStorage self) -> IVolumeHeightFunction"""
        return _cmf_core.OpenWaterStorage_get_height_function(self, *args, **kwargs)


    def set_height_function(self, *args, **kwargs):
        """set_height_function(OpenWaterStorage self, IVolumeHeightFunction val)"""
        return _cmf_core.OpenWaterStorage_set_height_function(self, *args, **kwargs)


    def wet_area(self, *args, **kwargs):
        """wet_area(OpenWaterStorage self) -> real"""
        return _cmf_core.OpenWaterStorage_wet_area(self, *args, **kwargs)


    def create(*args):
        """
        create(project _project, real Area) -> cmf::river::OpenWaterStorage::ptr
        create(project _project, IVolumeHeightFunction base_geo) -> cmf::river::OpenWaterStorage::ptr
        """
        return _cmf_core.OpenWaterStorage_create(*args)

    create = staticmethod(create)

    def cast(*args, **kwargs):
        """cast(cmf::water::flux_node::ptr node) -> cmf::river::OpenWaterStorage::ptr"""
        return _cmf_core.OpenWaterStorage_cast(*args, **kwargs)

    cast = staticmethod(cast)
    depth = _swig_property(_cmf_core.OpenWaterStorage_depth_get, _cmf_core.OpenWaterStorage_depth_set)

    def __repr__(self): 
        return self.to_string()

    __swig_destroy__ = _cmf_core.delete_OpenWaterStorage
OpenWaterStorage.get_height_function = new_instancemethod(_cmf_core.OpenWaterStorage_get_height_function, None, OpenWaterStorage)
OpenWaterStorage.set_height_function = new_instancemethod(_cmf_core.OpenWaterStorage_set_height_function, None, OpenWaterStorage)
OpenWaterStorage.wet_area = new_instancemethod(_cmf_core.OpenWaterStorage_wet_area, None, OpenWaterStorage)
OpenWaterStorage_swigregister = _cmf_core.OpenWaterStorage_swigregister
OpenWaterStorage_swigregister(OpenWaterStorage)

def OpenWaterStorage_create(*args):
    """
    create(project _project, real Area) -> cmf::river::OpenWaterStorage::ptr
    OpenWaterStorage_create(project _project, IVolumeHeightFunction base_geo) -> cmf::river::OpenWaterStorage::ptr
    """
    return _cmf_core.OpenWaterStorage_create(*args)

def OpenWaterStorage_cast(*args, **kwargs):
    """OpenWaterStorage_cast(cmf::water::flux_node::ptr node) -> cmf::river::OpenWaterStorage::ptr"""
    return _cmf_core.OpenWaterStorage_cast(*args, **kwargs)

class Reach(OpenWaterStorage):
    """Proxy of C++ cmf::river::Reach class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def get_reachtype(self, *args, **kwargs):
        """get_reachtype(Reach self) -> Channel"""
        return _cmf_core.Reach_get_reachtype(self, *args, **kwargs)


    def set_height_function(self, *args, **kwargs):
        """set_height_function(Reach self, IChannel val)"""
        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)"""
        return _cmf_core.Reach_set_outlet(self, *args, **kwargs)


    def set_dead_end(self, *args, **kwargs):
        """set_dead_end(Reach self)"""
        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)"""
        return _cmf_core.Reach_set_downstream(self, *args, **kwargs)


    def __get_downstream(self, *args, **kwargs):
        """__get_downstream(Reach self) -> cmf::water::flux_node::ptr"""
        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"""
        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)"""
        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"""
        return _cmf_core.Reach_distance_to_cell(self, *args, **kwargs)


    def __get_root(self, *args, **kwargs):
        """__get_root(Reach self) -> cmf::river::Reach::ptr"""
        return _cmf_core.Reach___get_root(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_Reach

    def create(*args, **kwargs):
        """create(project project, IChannel shape, bool diffusive=False) -> cmf::river::Reach::ptr"""
        return _cmf_core.Reach_create(*args, **kwargs)

    create = staticmethod(create)
    length = _swig_property(_cmf_core.Reach_length_get)
    width = _swig_property(_cmf_core.Reach_width_get)
    channel = _swig_property(_cmf_core.Reach_channel_get)

    downstream = _swig_property(_cmf_core.Reach___get_downstream)


    root = _swig_property(_cmf_core.Reach___get_root)

    upstream_count = _swig_property(_cmf_core.Reach_upstream_count_get)
    diffusive = _swig_property(_cmf_core.Reach_diffusive_get, _cmf_core.Reach_diffusive_set)

    @property
    def upstream(self):
        """Returns a list containing all reaches flowing into self"""
        return [self.get_upstream(i) for i in range(self.upstream_count)]
    def __hash__(self):
        return hash(self.water.node_id)
    def connect_to_cell(self,cell,width,subsurface_connection_type=None,subsurface_connection_depth=None,diffusive=None):
        """ Connects a cell with this reach using Manning's equation for surface runoff and
        a given connection for subsurface interflow 
         - width : Boundary width in m
         - subsurface_connection_type  : Any lateral flow connection type
         - subsurface_connection_depth : The depth below ground of the deepest layer to be connected by subsurface_connection_type,
                                         default (None) = cell.z - reach.position.z
         - diffusive: Determines if a kinematic or diffusive wave is to be used for surface runoff
        """
        assert(subsurface_connection_type is None or issubclass(subsurface_connection_type, lateral_sub_surface_flux))
        if diffusive is None:
            diffusive = self.diffusive
        if subsurface_connection_depth is None:
            subsurface_connection_depth = cell.z - self.position.z
        self.connect_to_surfacewater(cell,width,diffusive)
        r_depth = cell.z - self.position.z
        distance = self.distance_to_cell(cell)
        connections=[self.connection_to(cell.surfacewater)]
        if subsurface_connection_type:
            cell.connect_soil_with_node(self,subsurface_connection_type,width,distance,0,subsurface_connection_depth)
            connections.extend(self.connection_to(l) for l in cell.layers)
        return connections


    def __repr__(self): 
        return self.to_string()

Reach.get_reachtype = new_instancemethod(_cmf_core.Reach_get_reachtype, None, Reach)
Reach.set_height_function = new_instancemethod(_cmf_core.Reach_set_height_function, None, Reach)
Reach.set_outlet = new_instancemethod(_cmf_core.Reach_set_outlet, None, Reach)
Reach.set_dead_end = new_instancemethod(_cmf_core.Reach_set_dead_end, None, Reach)
Reach.set_downstream = new_instancemethod(_cmf_core.Reach_set_downstream, None, Reach)
Reach.__get_downstream = new_instancemethod(_cmf_core.Reach___get_downstream, None, Reach)
Reach.get_upstream = new_instancemethod(_cmf_core.Reach_get_upstream, None, Reach)
Reach.connect_to_surfacewater = new_instancemethod(_cmf_core.Reach_connect_to_surfacewater, None, Reach)
Reach.distance_to_cell = new_instancemethod(_cmf_core.Reach_distance_to_cell, None, Reach)
Reach.__get_root = new_instancemethod(_cmf_core.Reach___get_root, None, Reach)
Reach_swigregister = _cmf_core.Reach_swigregister
Reach_swigregister(Reach)

def Reach_create(*args, **kwargs):
    """Reach_create(project project, IChannel shape, bool diffusive=False) -> cmf::river::Reach::ptr"""
    return _cmf_core.Reach_create(*args, **kwargs)

class ReachIterator(object):
    """Proxy of C++ cmf::river::ReachIterator class."""

    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"""
        return _cmf_core.ReachIterator_next(self, *args, **kwargs)


    def valid(self, *args, **kwargs):
        """valid(ReachIterator self) -> bool"""
        return _cmf_core.ReachIterator_valid(self, *args, **kwargs)


    def __init__(self, *args, **kwargs):
        """__init__(cmf::river::ReachIterator self, cmf::river::Reach::ptr first) -> ReachIterator"""
        _cmf_core.ReachIterator_swiginit(self, _cmf_core.new_ReachIterator(*args, **kwargs))

    def __reach(self, *args, **kwargs):
        """__reach(ReachIterator self) -> cmf::river::Reach::ptr"""
        return _cmf_core.ReachIterator___reach(self, *args, **kwargs)

    position = _swig_property(_cmf_core.ReachIterator_position_get)

    reach = _swig_property(_cmf_core.ReachIterator___reach)


    def __iter__(self):
        while self.valid():
            next(self)
            yield (self.reach,self.position)

    __swig_destroy__ = _cmf_core.delete_ReachIterator
ReachIterator.next = new_instancemethod(_cmf_core.ReachIterator_next, None, ReachIterator)
ReachIterator.valid = new_instancemethod(_cmf_core.ReachIterator_valid, None, ReachIterator)
ReachIterator.__reach = new_instancemethod(_cmf_core.ReachIterator___reach, None, ReachIterator)
ReachIterator_swigregister = _cmf_core.ReachIterator_swigregister
ReachIterator_swigregister(ReachIterator)


def make_river_gap(*args, **kwargs):
    """make_river_gap(cmf::river::Reach::ptr root_reach) -> double"""
    return _cmf_core.make_river_gap(*args, **kwargs)
class SurfaceWater(OpenWaterStorage):
    """Proxy of C++ cmf::upslope::SurfaceWater class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def get_height_function(self, *args, **kwargs):
        """get_height_function(SurfaceWater self) -> Prism"""
        return _cmf_core.SurfaceWater_get_height_function(self, *args, **kwargs)


    def get_cell(self, *args, **kwargs):
        """get_cell(SurfaceWater self) -> Cell"""
        return _cmf_core.SurfaceWater_get_cell(self, *args, **kwargs)


    def cast(*args, **kwargs):
        """cast(cmf::water::flux_node::ptr node) -> cmf::upslope::SurfaceWater::ptr"""
        return _cmf_core.SurfaceWater_cast(*args, **kwargs)

    cast = staticmethod(cast)
    puddledepth = _swig_property(_cmf_core.SurfaceWater_puddledepth_get, _cmf_core.SurfaceWater_puddledepth_set)
    nManning = _swig_property(_cmf_core.SurfaceWater_nManning_get, _cmf_core.SurfaceWater_nManning_set)

    def __repr__(self): 
        return self.to_string()

    __swig_destroy__ = _cmf_core.delete_SurfaceWater
SurfaceWater.get_height_function = new_instancemethod(_cmf_core.SurfaceWater_get_height_function, None, SurfaceWater)
SurfaceWater.get_cell = new_instancemethod(_cmf_core.SurfaceWater_get_cell, None, SurfaceWater)
SurfaceWater_swigregister = _cmf_core.SurfaceWater_swigregister
SurfaceWater_swigregister(SurfaceWater)

def SurfaceWater_cast(*args, **kwargs):
    """SurfaceWater_cast(cmf::water::flux_node::ptr node) -> cmf::upslope::SurfaceWater::ptr"""
    return _cmf_core.SurfaceWater_cast(*args, **kwargs)

class KinematicSurfaceRunoff(flux_connection):
    """Proxy of C++ cmf::upslope::connections::KinematicSurfaceRunoff 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::upslope::connections::KinematicSurfaceRunoff self, cmf::upslope::SurfaceWater::ptr left, cmf::water::flux_node::ptr right, real flowwidth, real distance=-1) -> KinematicSurfaceRunoff"""
        _cmf_core.KinematicSurfaceRunoff_swiginit(self, _cmf_core.new_KinematicSurfaceRunoff(*args, **kwargs))
    __swig_destroy__ = _cmf_core.delete_KinematicSurfaceRunoff
KinematicSurfaceRunoff_swigregister = _cmf_core.KinematicSurfaceRunoff_swigregister
KinematicSurfaceRunoff_swigregister(KinematicSurfaceRunoff)
KinematicSurfaceRunoff.cell_connector = _cmf_core.cvar.KinematicSurfaceRunoff_cell_connector

class DiffusiveSurfaceRunoff(flux_connection):
    """Proxy of C++ cmf::upslope::connections::DiffusiveSurfaceRunoff class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def set_linear_slope(*args, **kwargs):
        """set_linear_slope(real width)"""
        return _cmf_core.DiffusiveSurfaceRunoff_set_linear_slope(*args, **kwargs)

    set_linear_slope = staticmethod(set_linear_slope)

    def get_linear_slope(*args, **kwargs):
        """get_linear_slope() -> real"""
        return _cmf_core.DiffusiveSurfaceRunoff_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"""
        _cmf_core.DiffusiveSurfaceRunoff_swiginit(self, _cmf_core.new_DiffusiveSurfaceRunoff(*args, **kwargs))
    __swig_destroy__ = _cmf_core.delete_DiffusiveSurfaceRunoff
DiffusiveSurfaceRunoff_swigregister = _cmf_core.DiffusiveSurfaceRunoff_swigregister
DiffusiveSurfaceRunoff_swigregister(DiffusiveSurfaceRunoff)

def DiffusiveSurfaceRunoff_set_linear_slope(*args, **kwargs):
    """DiffusiveSurfaceRunoff_set_linear_slope(real width)"""
    return _cmf_core.DiffusiveSurfaceRunoff_set_linear_slope(*args, **kwargs)

def DiffusiveSurfaceRunoff_get_linear_slope(*args):
    """DiffusiveSurfaceRunoff_get_linear_slope() -> real"""
    return _cmf_core.DiffusiveSurfaceRunoff_get_linear_slope(*args)
DiffusiveSurfaceRunoff.cell_connector = _cmf_core.cvar.DiffusiveSurfaceRunoff_cell_connector

class aquifer(WaterStorage):
    """Proxy of C++ cmf::upslope::aquifer class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    area = _swig_property(_cmf_core.aquifer_area_get, _cmf_core.aquifer_area_set)
    thickness = _swig_property(_cmf_core.aquifer_thickness_get, _cmf_core.aquifer_thickness_set)
    porosity = _swig_property(_cmf_core.aquifer_porosity_get, _cmf_core.aquifer_porosity_set)
    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"""
        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"""
        return _cmf_core.aquifer_get_abs_errtol(self, *args, **kwargs)


    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
        """
        _cmf_core.aquifer_swiginit(self, _cmf_core.new_aquifer(*args))

    def cast(*args, **kwargs):
        """cast(cmf::water::flux_node::ptr for_cast) -> cmf::upslope::aquifer::ptr"""
        return _cmf_core.aquifer_cast(*args, **kwargs)

    cast = staticmethod(cast)
    base_height = _swig_property(_cmf_core.aquifer_base_height_get)
    top_height = _swig_property(_cmf_core.aquifer_top_height_get)

    def __repr__(self): 
        return self.to_string()

    __swig_destroy__ = _cmf_core.delete_aquifer
aquifer.get_K = new_instancemethod(_cmf_core.aquifer_get_K, None, aquifer)
aquifer.get_abs_errtol = new_instancemethod(_cmf_core.aquifer_get_abs_errtol, None, aquifer)
aquifer_swigregister = _cmf_core.aquifer_swigregister
aquifer_swigregister(aquifer)

def aquifer_cast(*args, **kwargs):
    """aquifer_cast(cmf::water::flux_node::ptr for_cast) -> cmf::upslope::aquifer::ptr"""
    return _cmf_core.aquifer_cast(*args, **kwargs)

class aquifer_Darcy(flux_connection):
    """Proxy of C++ cmf::upslope::aquifer_Darcy class."""

    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"""
        _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."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _cmf_core.delete_lateral_sub_surface_flux
lateral_sub_surface_flux_swigregister = _cmf_core.lateral_sub_surface_flux_swigregister
lateral_sub_surface_flux_swigregister(lateral_sub_surface_flux)

class Darcy(lateral_sub_surface_flux):
    """Proxy of C++ cmf::upslope::connections::Darcy 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::upslope::connections::Darcy self, cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right, real FlowWidth, real Distance=0) -> Darcy"""
        _cmf_core.Darcy_swiginit(self, _cmf_core.new_Darcy(*args, **kwargs))
    __swig_destroy__ = _cmf_core.delete_Darcy
Darcy_swigregister = _cmf_core.Darcy_swigregister
Darcy_swigregister(Darcy)
Darcy.cell_connector = _cmf_core.cvar.Darcy_cell_connector

class TopographicGradientDarcy(lateral_sub_surface_flux):
    """Proxy of C++ cmf::upslope::connections::TopographicGradientDarcy 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::upslope::connections::TopographicGradientDarcy self, cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right, real FlowWidth, real Distance=0) -> TopographicGradientDarcy"""
        _cmf_core.TopographicGradientDarcy_swiginit(self, _cmf_core.new_TopographicGradientDarcy(*args, **kwargs))
    __swig_destroy__ = _cmf_core.delete_TopographicGradientDarcy
TopographicGradientDarcy_swigregister = _cmf_core.TopographicGradientDarcy_swigregister
TopographicGradientDarcy_swigregister(TopographicGradientDarcy)
TopographicGradientDarcy.cell_connector = _cmf_core.cvar.TopographicGradientDarcy_cell_connector

class DarcyKinematic(lateral_sub_surface_flux):
    """Proxy of C++ cmf::upslope::connections::DarcyKinematic 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::upslope::connections::DarcyKinematic self, cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right, real FlowWidth, real Distance=0) -> DarcyKinematic"""
        _cmf_core.DarcyKinematic_swiginit(self, _cmf_core.new_DarcyKinematic(*args, **kwargs))
    __swig_destroy__ = _cmf_core.delete_DarcyKinematic
DarcyKinematic_swigregister = _cmf_core.DarcyKinematic_swigregister
DarcyKinematic_swigregister(DarcyKinematic)
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."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    flow_thickness = _swig_property(_cmf_core.Richards_lateral_flow_thickness_get, _cmf_core.Richards_lateral_flow_thickness_set)
    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"""
        _cmf_core.Richards_lateral_swiginit(self, _cmf_core.new_Richards_lateral(*args, **kwargs))

    def usebaseflow(*args, **kwargs):
        """usebaseflow(bool use)"""
        return _cmf_core.Richards_lateral_usebaseflow(*args, **kwargs)

    usebaseflow = staticmethod(usebaseflow)
    __swig_destroy__ = _cmf_core.delete_Richards_lateral
Richards_lateral_swigregister = _cmf_core.Richards_lateral_swigregister
Richards_lateral_swigregister(Richards_lateral)

def Richards_lateral_usebaseflow(*args, **kwargs):
    """Richards_lateral_usebaseflow(bool use)"""
    return _cmf_core.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."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    flow_width = _swig_property(_cmf_core.TOPModelFlow_flow_width_get, _cmf_core.TOPModelFlow_flow_width_set)
    distance = _swig_property(_cmf_core.TOPModelFlow_distance_get, _cmf_core.TOPModelFlow_distance_set)
    T0 = _swig_property(_cmf_core.TOPModelFlow_T0_get, _cmf_core.TOPModelFlow_T0_set)
    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"""
        _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."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    is_diffusive_wave = _swig_property(_cmf_core.Manning_is_diffusive_wave_get, _cmf_core.Manning_is_diffusive_wave_set)
    flux_geometry = _swig_property(_cmf_core.Manning_flux_geometry_get, _cmf_core.Manning_flux_geometry_set)
    __swig_destroy__ = _cmf_core.delete_Manning
Manning_swigregister = _cmf_core.Manning_swigregister
Manning_swigregister(Manning)

class Manning_Diffusive(Manning):
    """Proxy of C++ cmf::river::Manning_Diffusive class."""

    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"""
        _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
Manning_Diffusive_swigregister(Manning_Diffusive)
Manning_Diffusive.cell_connector = _cmf_core.cvar.Manning_Diffusive_cell_connector

class Manning_Kinematic(Manning):
    """Proxy of C++ cmf::river::Manning_Kinematic 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::river::Manning_Kinematic self, cmf::river::OpenWaterStorage::ptr left, cmf::water::flux_node::ptr right, IChannel reachtype) -> Manning_Kinematic"""
        _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
Manning_Kinematic_swigregister(Manning_Kinematic)
Manning_Kinematic.cell_connector = _cmf_core.cvar.Manning_Kinematic_cell_connector

class CanopyOverflow(flux_connection):
    """Proxy of C++ cmf::upslope::connections::CanopyOverflow 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::upslope::connections::CanopyOverflow self, cmf::water::WaterStorage::ptr Canopy, cmf::water::flux_node::ptr target, Cell cell) -> CanopyOverflow"""
        _cmf_core.CanopyOverflow_swiginit(self, _cmf_core.new_CanopyOverflow(*args, **kwargs))

    def use_for_cell(*args, **kwargs):
        """use_for_cell(Cell cell) -> CanopyOverflow"""
        return _cmf_core.CanopyOverflow_use_for_cell(*args, **kwargs)

    use_for_cell = staticmethod(use_for_cell)
    __swig_destroy__ = _cmf_core.delete_CanopyOverflow
CanopyOverflow_swigregister = _cmf_core.CanopyOverflow_swigregister
CanopyOverflow_swigregister(CanopyOverflow)

def CanopyOverflow_use_for_cell(*args, **kwargs):
    """CanopyOverflow_use_for_cell(Cell cell) -> CanopyOverflow"""
    return _cmf_core.CanopyOverflow_use_for_cell(*args, **kwargs)

class RutterInterception(flux_connection):
    """Proxy of C++ cmf::upslope::connections::RutterInterception 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::upslope::connections::RutterInterception self, cmf::water::WaterStorage::ptr Canopy, cmf::water::flux_node::ptr target, Cell cell) -> RutterInterception"""
        _cmf_core.RutterInterception_swiginit(self, _cmf_core.new_RutterInterception(*args, **kwargs))

    def use_for_cell(*args, **kwargs):
        """use_for_cell(Cell cell) -> RutterInterception"""
        return _cmf_core.RutterInterception_use_for_cell(*args, **kwargs)

    use_for_cell = staticmethod(use_for_cell)
    __swig_destroy__ = _cmf_core.delete_RutterInterception
RutterInterception_swigregister = _cmf_core.RutterInterception_swigregister
RutterInterception_swigregister(RutterInterception)

def RutterInterception_use_for_cell(*args, **kwargs):
    """RutterInterception_use_for_cell(Cell cell) -> RutterInterception"""
    return _cmf_core.RutterInterception_use_for_cell(*args, **kwargs)

class SimpleTindexSnowMelt(flux_connection):
    """Proxy of C++ cmf::upslope::connections::SimpleTindexSnowMelt class."""

    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"""
        _cmf_core.SimpleTindexSnowMelt_swiginit(self, _cmf_core.new_SimpleTindexSnowMelt(*args, **kwargs))

    def use_for_cell(*args, **kwargs):
        """use_for_cell(Cell cell)"""
        return _cmf_core.SimpleTindexSnowMelt_use_for_cell(*args, **kwargs)

    use_for_cell = staticmethod(use_for_cell)
    __swig_destroy__ = _cmf_core.delete_SimpleTindexSnowMelt
SimpleTindexSnowMelt_swigregister = _cmf_core.SimpleTindexSnowMelt_swigregister
SimpleTindexSnowMelt_swigregister(SimpleTindexSnowMelt)

def SimpleTindexSnowMelt_use_for_cell(*args, **kwargs):
    """SimpleTindexSnowMelt_use_for_cell(Cell cell)"""
    return _cmf_core.SimpleTindexSnowMelt_use_for_cell(*args, **kwargs)

class EnergyBudgetSnowMelt(flux_connection):
    """Proxy of C++ cmf::upslope::connections::EnergyBudgetSnowMelt 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::upslope::connections::EnergyBudgetSnowMelt self, cmf::water::WaterStorage::ptr snow, cmf::water::flux_node::ptr surface_water, Cell cell) -> EnergyBudgetSnowMelt"""
        _cmf_core.EnergyBudgetSnowMelt_swiginit(self, _cmf_core.new_EnergyBudgetSnowMelt(*args, **kwargs))

    def use_for_cell(*args, **kwargs):
        """use_for_cell(Cell cell)"""
        return _cmf_core.EnergyBudgetSnowMelt_use_for_cell(*args, **kwargs)

    use_for_cell = staticmethod(use_for_cell)
    __swig_destroy__ = _cmf_core.delete_EnergyBudgetSnowMelt
EnergyBudgetSnowMelt_swigregister = _cmf_core.EnergyBudgetSnowMelt_swigregister
EnergyBudgetSnowMelt_swigregister(EnergyBudgetSnowMelt)

def EnergyBudgetSnowMelt_use_for_cell(*args, **kwargs):
    """EnergyBudgetSnowMelt_use_for_cell(Cell cell)"""
    return _cmf_core.EnergyBudgetSnowMelt_use_for_cell(*args, **kwargs)


def snowfraction(*args, **kwargs):
    """snowfraction(real T) -> real"""
    return _cmf_core.snowfraction(*args, **kwargs)
class Rainfall(flux_connection):
    """Proxy of C++ cmf::upslope::connections::Rainfall class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Throughfall = _swig_property(_cmf_core.Rainfall_Throughfall_get, _cmf_core.Rainfall_Throughfall_set)
    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"""
        _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."""

    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"""
        _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."""

    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"""
        _cmf_core.MatrixInfiltration_swiginit(self, _cmf_core.new_MatrixInfiltration(*args, **kwargs))

    def use_for_cell(*args, **kwargs):
        """use_for_cell(Cell c)"""
        return _cmf_core.MatrixInfiltration_use_for_cell(*args, **kwargs)

    use_for_cell = staticmethod(use_for_cell)
    __swig_destroy__ = _cmf_core.delete_MatrixInfiltration
MatrixInfiltration_swigregister = _cmf_core.MatrixInfiltration_swigregister
MatrixInfiltration_swigregister(MatrixInfiltration)

def MatrixInfiltration_use_for_cell(*args, **kwargs):
    """MatrixInfiltration_use_for_cell(Cell c)"""
    return _cmf_core.MatrixInfiltration_use_for_cell(*args, **kwargs)

class GreenAmptInfiltration(flux_connection):
    """Proxy of C++ cmf::upslope::connections::GreenAmptInfiltration 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::upslope::connections::GreenAmptInfiltration self, cmf::upslope::SoilLayer::ptr soilwater, cmf::water::flux_node::ptr surfacewater) -> GreenAmptInfiltration"""
        _cmf_core.GreenAmptInfiltration_swiginit(self, _cmf_core.new_GreenAmptInfiltration(*args, **kwargs))

    def use_for_cell(*args, **kwargs):
        """use_for_cell(Cell c)"""
        return _cmf_core.GreenAmptInfiltration_use_for_cell(*args, **kwargs)

    use_for_cell = staticmethod(use_for_cell)
    __swig_destroy__ = _cmf_core.delete_GreenAmptInfiltration
GreenAmptInfiltration_swigregister = _cmf_core.GreenAmptInfiltration_swigregister
GreenAmptInfiltration_swigregister(GreenAmptInfiltration)

def GreenAmptInfiltration_use_for_cell(*args, **kwargs):
    """GreenAmptInfiltration_use_for_cell(Cell c)"""
    return _cmf_core.GreenAmptInfiltration_use_for_cell(*args, **kwargs)

class SimpleInfiltration(flux_connection):
    """Proxy of C++ cmf::upslope::connections::SimpleInfiltration class."""

    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"""
        _cmf_core.SimpleInfiltration_swiginit(self, _cmf_core.new_SimpleInfiltration(*args, **kwargs))

    def use_for_cell(*args, **kwargs):
        """use_for_cell(Cell c)"""
        return _cmf_core.SimpleInfiltration_use_for_cell(*args, **kwargs)

    use_for_cell = staticmethod(use_for_cell)
    __swig_destroy__ = _cmf_core.delete_SimpleInfiltration
SimpleInfiltration_swigregister = _cmf_core.SimpleInfiltration_swigregister
SimpleInfiltration_swigregister(SimpleInfiltration)

def SimpleInfiltration_use_for_cell(*args, **kwargs):
    """SimpleInfiltration_use_for_cell(Cell c)"""
    return _cmf_core.SimpleInfiltration_use_for_cell(*args, **kwargs)

class SWATPercolation(flux_connection):
    """Proxy of C++ cmf::upslope::connections::SWATPercolation class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def use_for_cell(*args, **kwargs):
        """use_for_cell(Cell cell, bool no_override=True)"""
        return _cmf_core.SWATPercolation_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"""
        _cmf_core.SWATPercolation_swiginit(self, _cmf_core.new_SWATPercolation(*args, **kwargs))
    __swig_destroy__ = _cmf_core.delete_SWATPercolation
SWATPercolation_swigregister = _cmf_core.SWATPercolation_swigregister
SWATPercolation_swigregister(SWATPercolation)

def SWATPercolation_use_for_cell(*args, **kwargs):
    """SWATPercolation_use_for_cell(Cell cell, bool no_override=True)"""
    return _cmf_core.SWATPercolation_use_for_cell(*args, **kwargs)

class Richards(flux_connection):
    """Proxy of C++ cmf::upslope::connections::Richards 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::upslope::connections::Richards self, cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right) -> Richards"""
        _cmf_core.Richards_swiginit(self, _cmf_core.new_Richards(*args, **kwargs))

    def use_for_cell(*args, **kwargs):
        """use_for_cell(Cell cell, bool no_override=True)"""
        return _cmf_core.Richards_use_for_cell(*args, **kwargs)

    use_for_cell = staticmethod(use_for_cell)
    __swig_destroy__ = _cmf_core.delete_Richards
Richards_swigregister = _cmf_core.Richards_swigregister
Richards_swigregister(Richards)

def Richards_use_for_cell(*args, **kwargs):
    """Richards_use_for_cell(Cell cell, bool no_override=True)"""
    return _cmf_core.Richards_use_for_cell(*args, **kwargs)

class SimplRichards(flux_connection):
    """Proxy of C++ cmf::upslope::connections::SimplRichards 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::upslope::connections::SimplRichards self, cmf::upslope::SoilLayer::ptr left, cmf::water::flux_node::ptr right) -> SimplRichards"""
        _cmf_core.SimplRichards_swiginit(self, _cmf_core.new_SimplRichards(*args, **kwargs))

    def use_for_cell(*args, **kwargs):
        """use_for_cell(Cell cell, bool no_override=True)"""
        return _cmf_core.SimplRichards_use_for_cell(*args, **kwargs)

    use_for_cell = staticmethod(use_for_cell)
    __swig_destroy__ = _cmf_core.delete_SimplRichards
SimplRichards_swigregister = _cmf_core.SimplRichards_swigregister
SimplRichards_swigregister(SimplRichards)

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."""

    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"""
        _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."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Kmax = _swig_property(_cmf_core.LayerBypass_Kmax_get, _cmf_core.LayerBypass_Kmax_set)
    w0 = _swig_property(_cmf_core.LayerBypass_w0_get, _cmf_core.LayerBypass_w0_set)
    beta = _swig_property(_cmf_core.LayerBypass_beta_get, _cmf_core.LayerBypass_beta_set)

    def K(self, *args, **kwargs):
        """K(LayerBypass self, real w) -> real"""
        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"""
        _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)
LayerBypass_swigregister = _cmf_core.LayerBypass_swigregister
LayerBypass_swigregister(LayerBypass)

class RootUptakeStessFunction(object):
    """Proxy of C++ cmf::upslope::ET::RootUptakeStessFunction class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def Tact(self, *args, **kwargs):
        """Tact(RootUptakeStessFunction self, stressedET connection, real Tpot) -> real"""
        return _cmf_core.RootUptakeStessFunction_Tact(self, *args, **kwargs)


    def copy(self, *args, **kwargs):
        """copy(RootUptakeStessFunction self) -> RootUptakeStessFunction"""
        return _cmf_core.RootUptakeStessFunction_copy(self, *args, **kwargs)


    def to_string(self, *args, **kwargs):
        """to_string(RootUptakeStessFunction self) -> std::string"""
        return _cmf_core.RootUptakeStessFunction_to_string(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_RootUptakeStessFunction
RootUptakeStessFunction.Tact = new_instancemethod(_cmf_core.RootUptakeStessFunction_Tact, None, RootUptakeStessFunction)
RootUptakeStessFunction.copy = new_instancemethod(_cmf_core.RootUptakeStessFunction_copy, None, RootUptakeStessFunction)
RootUptakeStessFunction.to_string = new_instancemethod(_cmf_core.RootUptakeStessFunction_to_string, None, RootUptakeStessFunction)
RootUptakeStessFunction_swigregister = _cmf_core.RootUptakeStessFunction_swigregister
RootUptakeStessFunction_swigregister(RootUptakeStessFunction)

class SuctionStress(RootUptakeStessFunction):
    """Proxy of C++ cmf::upslope::ET::SuctionStress class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    P0 = _swig_property(_cmf_core.SuctionStress_P0_get, _cmf_core.SuctionStress_P0_set)
    P1 = _swig_property(_cmf_core.SuctionStress_P1_get, _cmf_core.SuctionStress_P1_set)
    P2 = _swig_property(_cmf_core.SuctionStress_P2_get, _cmf_core.SuctionStress_P2_set)
    P3 = _swig_property(_cmf_core.SuctionStress_P3_get, _cmf_core.SuctionStress_P3_set)

    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
        """
        _cmf_core.SuctionStress_swiginit(self, _cmf_core.new_SuctionStress(*args))

    def copy(self, *args, **kwargs):
        """copy(SuctionStress self) -> SuctionStress"""
        return _cmf_core.SuctionStress_copy(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_SuctionStress
SuctionStress.copy = new_instancemethod(_cmf_core.SuctionStress_copy, None, SuctionStress)
SuctionStress_swigregister = _cmf_core.SuctionStress_swigregister
SuctionStress_swigregister(SuctionStress)

class ContentStress(RootUptakeStessFunction):
    """Proxy of C++ cmf::upslope::ET::ContentStress class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    theta_d = _swig_property(_cmf_core.ContentStress_theta_d_get, _cmf_core.ContentStress_theta_d_set)
    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"""
        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"""
        _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)
ContentStress_swigregister = _cmf_core.ContentStress_swigregister
ContentStress_swigregister(ContentStress)

class VolumeStress(RootUptakeStessFunction):
    """Proxy of C++ cmf::upslope::ET::VolumeStress class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    V1 = _swig_property(_cmf_core.VolumeStress_V1_get, _cmf_core.VolumeStress_V1_set)
    V0 = _swig_property(_cmf_core.VolumeStress_V0_get, _cmf_core.VolumeStress_V0_set)

    def __init__(self, *args):
        """
        __init__(cmf::upslope::ET::VolumeStress self, real V1, real V0) -> VolumeStress
        __init__(cmf::upslope::ET::VolumeStress self, VolumeStress other) -> VolumeStress
        """
        _cmf_core.VolumeStress_swiginit(self, _cmf_core.new_VolumeStress(*args))

    def copy(self, *args, **kwargs):
        """copy(VolumeStress self) -> VolumeStress"""
        return _cmf_core.VolumeStress_copy(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_VolumeStress
VolumeStress.copy = new_instancemethod(_cmf_core.VolumeStress_copy, None, VolumeStress)
VolumeStress_swigregister = _cmf_core.VolumeStress_swigregister
VolumeStress_swigregister(VolumeStress)

class log_wind_profile(aerodynamic_resistance):
    """Proxy of C++ cmf::atmosphere::log_wind_profile 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::atmosphere::log_wind_profile self, Cell _cell) -> log_wind_profile"""
        _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."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def transp_from_layer(self, *args, **kwargs):
        """transp_from_layer(transpiration_method self, cmf::upslope::SoilLayer::ptr arg2, Time t) -> double"""
        return _cmf_core.transpiration_method_transp_from_layer(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_transpiration_method
transpiration_method.transp_from_layer = new_instancemethod(_cmf_core.transpiration_method_transp_from_layer, None, transpiration_method)
transpiration_method_swigregister = _cmf_core.transpiration_method_swigregister
transpiration_method_swigregister(transpiration_method)

class soil_evaporation_method(object):
    """Proxy of C++ cmf::upslope::ET::soil_evaporation_method class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __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"""
        return _cmf_core.soil_evaporation_method_evap_from_layer(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_soil_evaporation_method
soil_evaporation_method.evap_from_layer = new_instancemethod(_cmf_core.soil_evaporation_method_evap_from_layer, None, soil_evaporation_method)
soil_evaporation_method_swigregister = _cmf_core.soil_evaporation_method_swigregister
soil_evaporation_method_swigregister(soil_evaporation_method)

class surface_water_evaporation_method(object):
    """Proxy of C++ cmf::upslope::ET::surface_water_evaporation_method class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __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"""
        return _cmf_core.surface_water_evaporation_method_evap_from_openwater(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_surface_water_evaporation_method
surface_water_evaporation_method.evap_from_openwater = new_instancemethod(_cmf_core.surface_water_evaporation_method_evap_from_openwater, None, surface_water_evaporation_method)
surface_water_evaporation_method_swigregister = _cmf_core.surface_water_evaporation_method_swigregister
surface_water_evaporation_method_swigregister(surface_water_evaporation_method)

class canopy_evaporation_method(object):
    """Proxy of C++ cmf::upslope::ET::canopy_evaporation_method class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __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"""
        return _cmf_core.canopy_evaporation_method_evap_from_canopy(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_canopy_evaporation_method
canopy_evaporation_method.evap_from_canopy = new_instancemethod(_cmf_core.canopy_evaporation_method_evap_from_canopy, None, canopy_evaporation_method)
canopy_evaporation_method_swigregister = _cmf_core.canopy_evaporation_method_swigregister
canopy_evaporation_method_swigregister(canopy_evaporation_method)

class snow_evaporation_method(object):
    """Proxy of C++ cmf::upslope::ET::snow_evaporation_method class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __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"""
        return _cmf_core.snow_evaporation_method_evap_from_snow(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_snow_evaporation_method
snow_evaporation_method.evap_from_snow = new_instancemethod(_cmf_core.snow_evaporation_method_evap_from_snow, None, snow_evaporation_method)
snow_evaporation_method_swigregister = _cmf_core.snow_evaporation_method_swigregister
snow_evaporation_method_swigregister(snow_evaporation_method)

class transpiration(flux_connection):
    """Proxy of C++ cmf::upslope::ET::transpiration 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::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"""
        _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."""

    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"""
        _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."""

    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"""
        _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."""

    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"""
        _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."""

    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"""
        _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
surface_water_evaporation_swigregister(surface_water_evaporation)


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
    """
    return _cmf_core.PenmanMonteith(*args)
class stressedET(flux_connection):
    """Proxy of C++ cmf::upslope::ET::stressedET class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def set_stressfunction(self, *args, **kwargs):
        """set_stressfunction(stressedET self, RootUptakeStessFunction stressfunction)"""
        return _cmf_core.stressedET_set_stressfunction(self, *args, **kwargs)


    def get_layer(self, *args, **kwargs):
        """get_layer(stressedET self) -> cmf::upslope::SoilLayer::ptr"""
        return _cmf_core.stressedET_get_layer(self, *args, **kwargs)


    def ETpot(self, *args, **kwargs):
        """ETpot(stressedET self, Time t) -> real"""
        return _cmf_core.stressedET_ETpot(self, *args, **kwargs)

    __swig_destroy__ = _cmf_core.delete_stressedET
stressedET.set_stressfunction = new_instancemethod(_cmf_core.stressedET_set_stressfunction, None, stressedET)
stressedET.get_layer = new_instancemethod(_cmf_core.stressedET_get_layer, None, stressedET)
stressedET.ETpot = new_instancemethod(_cmf_core.stressedET_ETpot, None, stressedET)
stressedET_swigregister = _cmf_core.stressedET_swigregister
stressedET_swigregister(stressedET)

class constantETpot(stressedET):
    """Proxy of C++ cmf::upslope::ET::constantETpot class."""

    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"""
        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"""
        _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)
constantETpot_swigregister = _cmf_core.constantETpot_swigregister
constantETpot_swigregister(constantETpot)

class timeseriesETpot(stressedET):
    """Proxy of C++ cmf::upslope::ET::timeseriesETpot class."""

    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"""
        _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."""

    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"""
        _cmf_core.PenmanMonteithET_swiginit(self, _cmf_core.new_PenmanMonteithET(*args, **kwargs))

    def r_s(*args, **kwargs):
        """r_s(Vegetation veg) -> real"""
        return _cmf_core.PenmanMonteithET_r_s(*args, **kwargs)

    r_s = staticmethod(r_s)

    def r_a(*args, **kwargs):
        """r_a(Weather A, real veg_height) -> real"""
        return _cmf_core.PenmanMonteithET_r_a(*args, **kwargs)

    r_a = staticmethod(r_a)

    def use_for_cell(*args, **kwargs):
        """use_for_cell(Cell cell)"""
        return _cmf_core.PenmanMonteithET_use_for_cell(*args, **kwargs)

    use_for_cell = staticmethod(use_for_cell)
    __swig_destroy__ = _cmf_core.delete_PenmanMonteithET
PenmanMonteithET_swigregister = _cmf_core.PenmanMonteithET_swigregister
PenmanMonteithET_swigregister(PenmanMonteithET)

def PenmanMonteithET_r_s(*args, **kwargs):
    """PenmanMonteithET_r_s(Vegetation veg) -> real"""
    return _cmf_core.PenmanMonteithET_r_s(*args, **kwargs)

def PenmanMonteithET_r_a(*args, **kwargs):
    """PenmanMonteithET_r_a(Weather A, real veg_height) -> real"""
    return _cmf_core.PenmanMonteithET_r_a(*args, **kwargs)

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."""

    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.PriestleyTaylorET_daily_get, _cmf_core.PriestleyTaylorET_daily_set)
    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"""
        _cmf_core.PriestleyTaylorET_swiginit(self, _cmf_core.new_PriestleyTaylorET(*args, **kwargs))

    def use_for_cell(*args, **kwargs):
        """use_for_cell(Cell cell)"""
        return _cmf_core.PriestleyTaylorET_use_for_cell(*args, **kwargs)

    use_for_cell = staticmethod(use_for_cell)
    __swig_destroy__ = _cmf_core.delete_PriestleyTaylorET
PriestleyTaylorET_swigregister = _cmf_core.PriestleyTaylorET_swigregister
PriestleyTaylorET_swigregister(PriestleyTaylorET)

def PriestleyTaylorET_use_for_cell(*args, **kwargs):
    """PriestleyTaylorET_use_for_cell(Cell cell)"""
    return _cmf_core.PriestleyTaylorET_use_for_cell(*args, **kwargs)

class HargreaveET(stressedET):
    """Proxy of C++ cmf::upslope::ET::HargreaveET 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::upslope::ET::HargreaveET self, cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target, real latitude=51.0) -> HargreaveET"""
        _cmf_core.HargreaveET_swiginit(self, _cmf_core.new_HargreaveET(*args, **kwargs))
    lat = _swig_property(_cmf_core.HargreaveET_lat_get, _cmf_core.HargreaveET_lat_set)

    def use_for_cell(*args, **kwargs):
        """use_for_cell(Cell cell)"""
        return _cmf_core.HargreaveET_use_for_cell(*args, **kwargs)

    use_for_cell = staticmethod(use_for_cell)
    __swig_destroy__ = _cmf_core.delete_HargreaveET
HargreaveET_swigregister = _cmf_core.HargreaveET_swigregister
HargreaveET_swigregister(HargreaveET)

def HargreaveET_use_for_cell(*args, **kwargs):
    """HargreaveET_use_for_cell(Cell cell)"""
    return _cmf_core.HargreaveET_use_for_cell(*args, **kwargs)

class TurcET(stressedET):
    """Proxy of C++ cmf::upslope::ET::TurcET 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::upslope::ET::TurcET self, cmf::upslope::SoilLayer::ptr source, cmf::water::flux_node::ptr ET_target) -> TurcET"""
        _cmf_core.TurcET_swiginit(self, _cmf_core.new_TurcET(*args, **kwargs))

    def use_for_cell(*args, **kwargs):
        """use_for_cell(Cell cell)"""
        return _cmf_core.TurcET_use_for_cell(*args, **kwargs)

    use_for_cell = staticmethod(use_for_cell)
    __swig_destroy__ = _cmf_core.delete_TurcET
TurcET_swigregister = _cmf_core.TurcET_swigregister
TurcET_swigregister(TurcET)

def TurcET_use_for_cell(*args, **kwargs):
    """TurcET_use_for_cell(Cell cell)"""
    return _cmf_core.TurcET_use_for_cell(*args, **kwargs)

class CanopyStorageEvaporation(flux_connection):
    """Proxy of C++ cmf::upslope::ET::CanopyStorageEvaporation 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::upslope::ET::CanopyStorageEvaporation self, cmf::water::WaterStorage::ptr CanopyStorage, cmf::water::flux_node::ptr ET_target, Cell cell) -> CanopyStorageEvaporation"""
        _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."""

    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"""
        _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."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    RAA = _swig_property(_cmf_core.ShuttleworthWallace_RAA_get, _cmf_core.ShuttleworthWallace_RAA_set)
    RAC = _swig_property(_cmf_core.ShuttleworthWallace_RAC_get, _cmf_core.ShuttleworthWallace_RAC_set)
    RAS = _swig_property(_cmf_core.ShuttleworthWallace_RAS_get, _cmf_core.ShuttleworthWallace_RAS_set)
    RSS = _swig_property(_cmf_core.ShuttleworthWallace_RSS_get, _cmf_core.ShuttleworthWallace_RSS_set)
    RSC = _swig_property(_cmf_core.ShuttleworthWallace_RSC_get, _cmf_core.ShuttleworthWallace_RSC_set)
    refresh_counter = _swig_property(_cmf_core.ShuttleworthWallace_refresh_counter_get, _cmf_core.ShuttleworthWallace_refresh_counter_set)

    def refresh(self, *args):
        """
        refresh(ShuttleworthWallace self, Time t)
        refresh(ShuttleworthWallace self)
        """
        return _cmf_core.ShuttleworthWallace_refresh(self, *args)

    PTR = _swig_property(_cmf_core.ShuttleworthWallace_PTR_get, _cmf_core.ShuttleworthWallace_PTR_set)
    PSNVP = _swig_property(_cmf_core.ShuttleworthWallace_PSNVP_get, _cmf_core.ShuttleworthWallace_PSNVP_set)
    ASNVP = _swig_property(_cmf_core.ShuttleworthWallace_ASNVP_get, _cmf_core.ShuttleworthWallace_ASNVP_set)
    GER = _swig_property(_cmf_core.ShuttleworthWallace_GER_get, _cmf_core.ShuttleworthWallace_GER_set)
    PIR = _swig_property(_cmf_core.ShuttleworthWallace_PIR_get, _cmf_core.ShuttleworthWallace_PIR_set)
    AIR = _swig_property(_cmf_core.ShuttleworthWallace_AIR_get, _cmf_core.ShuttleworthWallace_AIR_set)
    GIR = _swig_property(_cmf_core.ShuttleworthWallace_GIR_get, _cmf_core.ShuttleworthWallace_GIR_set)
    ATR_sum = _swig_property(_cmf_core.ShuttleworthWallace_ATR_sum_get, _cmf_core.ShuttleworthWallace_ATR_sum_set)
    ATR = _swig_property(_cmf_core.ShuttleworthWallace_ATR_get, _cmf_core.ShuttleworthWallace_ATR_set)
    KSNVP = _swig_property(_cmf_core.ShuttleworthWallace_KSNVP_get, _cmf_core.ShuttleworthWallace_KSNVP_set)
    allow_dew = _swig_property(_cmf_core.ShuttleworthWallace_allow_dew_get, _cmf_core.ShuttleworthWallace_allow_dew_set)

    def set_RSS_parameters(*args, **kwargs):
        """set_RSS_parameters(double _RSSa=500., double _RSSb=1.0, double _RSSa_pot=-3.22)"""
        return _cmf_core.ShuttleworthWallace_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"""
        _cmf_core.ShuttleworthWallace_swiginit(self, _cmf_core.new_ShuttleworthWallace(*args, **kwargs))

    def use_for_cell(*args, **kwargs):
        """use_for_cell(Cell cell) -> ShuttleworthWallace"""
        return _cmf_core.ShuttleworthWallace_use_for_cell(*args, **kwargs)

    use_for_cell = staticmethod(use_for_cell)
    __swig_destroy__ = _cmf_core.delete_ShuttleworthWallace
ShuttleworthWallace.refresh = new_instancemethod(_cmf_core.ShuttleworthWallace_refresh, None, ShuttleworthWallace)
ShuttleworthWallace_swigregister = _cmf_core.ShuttleworthWallace_swigregister
ShuttleworthWallace_swigregister(ShuttleworthWallace)

def ShuttleworthWallace_set_RSS_parameters(*args, **kwargs):
    """ShuttleworthWallace_set_RSS_parameters(double _RSSa=500., double _RSSb=1.0, double _RSSa_pot=-3.22)"""
    return _cmf_core.ShuttleworthWallace_set_RSS_parameters(*args, **kwargs)

def ShuttleworthWallace_use_for_cell(*args, **kwargs):
    """ShuttleworthWallace_use_for_cell(Cell cell) -> ShuttleworthWallace"""
    return _cmf_core.ShuttleworthWallace_use_for_cell(*args, **kwargs)


class project_list_wrapper:
    def __init__(self,getitem,getlen,name):
        self.__get = getitem
        self.__len = getlen
        self.name = name
    def __len__(self):
        return int(self.__len())
    def __getitem__(self,index):
        if (type(index)==slice):
             return [self.__get(i) for i in range(*index.indices(len(self)))]
        try:
             gen=iter(index)
             return [self.__get(it) for it in gen]
        except TypeError:
             return self.__get(index)
    def __iter__(self):
        for i in range(len(self)):
            yield self.__get(i)
    def __repr__(self):
        return '[%i %s of project]' % (len(self),self.name)


class project(StateVariableOwner):
    """Proxy of C++ cmf::project class."""

    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"""
        return _cmf_core.project_remove_node(self, *args, **kwargs)

    solutes = _swig_property(_cmf_core.project_solutes_get)
    meteo_stations = _swig_property(_cmf_core.project_meteo_stations_get, _cmf_core.project_meteo_stations_set)
    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)"""
        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)"""
        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)"""
        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)"""
        return _cmf_core.project_use_nearest_rainfall(self, *args, **kwargs)


    def get_cell(self, *args, **kwargs):
        """get_cell(project self, ptrdiff_t index) -> Cell"""
        return _cmf_core.project_get_cell(self, *args, **kwargs)


    def size(self, *args, **kwargs):
        """size(project self) -> size_t"""
        return _cmf_core.project_size(self, *args, **kwargs)


    def __init__(self, *args, **kwargs):
        """__init__(cmf::project self, std::string solute_names) -> project"""
        _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"""
        return _cmf_core.project_NewCell(self, *args, **kwargs)


    def NewOutlet(self, *args, **kwargs):
        """NewOutlet(project self, std::string name, double x, double y, double z) -> cmf::water::DirichletBoundary::ptr"""
        return _cmf_core.project_NewOutlet(self, *args, **kwargs)


    def NewStorage(self, *args, **kwargs):
        """NewStorage(project self, std::string name, double x, double y, double z) -> cmf::water::WaterStorage::ptr"""
        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"""
        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"""
        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"""
        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"""
        return _cmf_core.project_get_reach(self, *args, **kwargs)


    def reach_count(self, *args, **kwargs):
        """reach_count(project self) -> size_t"""
        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"""
        return _cmf_core.project_get_node(self, *args, **kwargs)


    def node_count(self, *args, **kwargs):
        """node_count(project self) -> size_t"""
        return _cmf_core.project_node_count(self, *args, **kwargs)


    def get_storages(self, *args, **kwargs):
        """get_storages(project self) -> node_list"""
        return _cmf_core.project_get_storages(self, *args, **kwargs)

    cells = _swig_property(_cmf_core.project_cells_get)

    def __repr__(self):
        return "cmf.project(%i cells, %i meteo stations, %i project nodes)" % (len(self.cells),len(self.meteo_stations),len(self.nodes))
    def __len__(self):
        return self.size()
    def __getitem__(self,index):
        if isinstance(index,slice):
            return [self[i] for i in range(*index.indices(len(self)))]
        else:
            return self.get_cell(index)        
    def __iter__(self):
        for i in range(self.size()):
            yield self.get_cell(i)
    @property
    def reaches(self):
        "Returns the reaches of the project"
        return project_list_wrapper(self.get_reach,self.reach_count,'reaches')
    @property
    def nodes(self):
        "Returns the nodes of the project"
        return project_list_wrapper(self.get_node,self.node_count,'nodes')

project.remove_node = new_instancemethod(_cmf_core.project_remove_node, None, project)
project.use_IDW_meteo = new_instancemethod(_cmf_core.project_use_IDW_meteo, None, project)
project.use_nearest_meteo = new_instancemethod(_cmf_core.project_use_nearest_meteo, None, project)
project.use_IDW_rainfall = new_instancemethod(_cmf_core.project_use_IDW_rainfall, None, project)
project.use_nearest_rainfall = new_instancemethod(_cmf_core.project_use_nearest_rainfall, None, project)
project.get_cell = new_instancemethod(_cmf_core.project_get_cell, None, project)
project.size = new_instancemethod(_cmf_core.project_size, None, project)
project.NewCell = new_instancemethod(_cmf_core.project_NewCell, None, project)
project.NewOutlet = new_instancemethod(_cmf_core.project_NewOutlet, None, project)
project.NewStorage = new_instancemethod(_cmf_core.project_NewStorage, None, project)
project.NewOpenStorage = new_instancemethod(_cmf_core.project_NewOpenStorage, None, project)
project.NewNeumannBoundary = new_instancemethod(_cmf_core.project_NewNeumannBoundary, None, project)
project.NewReach = new_instancemethod(_cmf_core.project_NewReach, None, project)
project.get_reach = new_instancemethod(_cmf_core.project_get_reach, None, project)
project.reach_count = new_instancemethod(_cmf_core.project_reach_count, None, project)
project.get_node = new_instancemethod(_cmf_core.project_get_node, None, project)
project.node_count = new_instancemethod(_cmf_core.project_node_count, None, project)
project.get_storages = new_instancemethod(_cmf_core.project_get_storages, None, project)
project_swigregister = _cmf_core.project_swigregister
project_swigregister(project)

class SoluteWaterIntegrator(Integrator):
    """Proxy of C++ cmf::math::SoluteWaterIntegrator class."""

    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"""
        return _cmf_core.SoluteWaterIntegrator_copy(self, *args, **kwargs)


    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
        """
        _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"""
        return _cmf_core.SoluteWaterIntegrator_to_string(self, *args, **kwargs)

SoluteWaterIntegrator.copy = new_instancemethod(_cmf_core.SoluteWaterIntegrator_copy, None, SoluteWaterIntegrator)
SoluteWaterIntegrator.to_string = new_instancemethod(_cmf_core.SoluteWaterIntegrator_to_string, None, SoluteWaterIntegrator)
SoluteWaterIntegrator_swigregister = _cmf_core.SoluteWaterIntegrator_swigregister
SoluteWaterIntegrator_swigregister(SoluteWaterIntegrator)



