# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.31
#
# Don't modify this file, modify the SWIG interface instead.
# This file is compatible with both classic and new-style classes.

import _steps_swig
import new
new_instancemethod = new.instancemethod
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
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__ == 'PySwigObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name):
        self.__dict__[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,name

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

import types
try:
    _object = types.ObjectType
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0
del types


class PySwigIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PySwigIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PySwigIterator, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _steps_swig.delete_PySwigIterator
    __del__ = lambda self : None;
    def value(*args): return _steps_swig.PySwigIterator_value(*args)
    def incr(*args): return _steps_swig.PySwigIterator_incr(*args)
    def decr(*args): return _steps_swig.PySwigIterator_decr(*args)
    def distance(*args): return _steps_swig.PySwigIterator_distance(*args)
    def equal(*args): return _steps_swig.PySwigIterator_equal(*args)
    def copy(*args): return _steps_swig.PySwigIterator_copy(*args)
    def next(*args): return _steps_swig.PySwigIterator_next(*args)
    def previous(*args): return _steps_swig.PySwigIterator_previous(*args)
    def advance(*args): return _steps_swig.PySwigIterator_advance(*args)
    def __eq__(*args): return _steps_swig.PySwigIterator___eq__(*args)
    def __ne__(*args): return _steps_swig.PySwigIterator___ne__(*args)
    def __iadd__(*args): return _steps_swig.PySwigIterator___iadd__(*args)
    def __isub__(*args): return _steps_swig.PySwigIterator___isub__(*args)
    def __add__(*args): return _steps_swig.PySwigIterator___add__(*args)
    def __sub__(*args): return _steps_swig.PySwigIterator___sub__(*args)
    def __iter__(self): return self
PySwigIterator_swigregister = _steps_swig.PySwigIterator_swigregister
PySwigIterator_swigregister(PySwigIterator)

class Err(_object):
    """Proxy of C++ Err class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Err, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Err, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, string msg="") -> Err
        __init__(self) -> Err
        """
        this = _steps_swig.new_Err(*args)
        try: self.this.append(this)
        except: self.this = this
    def getMsg(*args):
        """getMsg(self) -> char"""
        return _steps_swig.Err_getMsg(*args)

    __swig_destroy__ = _steps_swig.delete_Err
    __del__ = lambda self : None;
Err_swigregister = _steps_swig.Err_swigregister
Err_swigregister(Err)

class ArgErr(Err):
    """Proxy of C++ ArgErr class"""
    __swig_setmethods__ = {}
    for _s in [Err]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArgErr, name, value)
    __swig_getmethods__ = {}
    for _s in [Err]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArgErr, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, string msg="") -> ArgErr
        __init__(self) -> ArgErr
        """
        this = _steps_swig.new_ArgErr(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _steps_swig.delete_ArgErr
    __del__ = lambda self : None;
ArgErr_swigregister = _steps_swig.ArgErr_swigregister
ArgErr_swigregister(ArgErr)

class NotImplErr(Err):
    """Proxy of C++ NotImplErr class"""
    __swig_setmethods__ = {}
    for _s in [Err]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NotImplErr, name, value)
    __swig_getmethods__ = {}
    for _s in [Err]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NotImplErr, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, string msg="") -> NotImplErr
        __init__(self) -> NotImplErr
        """
        this = _steps_swig.new_NotImplErr(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _steps_swig.delete_NotImplErr
    __del__ = lambda self : None;
NotImplErr_swigregister = _steps_swig.NotImplErr_swigregister
NotImplErr_swigregister(NotImplErr)

class vector_str(_object):
    """Proxy of C++ vector_str class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vector_str, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vector_str, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return _steps_swig.vector_str_iterator(*args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return _steps_swig.vector_str___nonzero__(*args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return _steps_swig.vector_str___len__(*args)

    def pop(*args):
        """pop(self) -> value_type"""
        return _steps_swig.vector_str_pop(*args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> vector_str"""
        return _steps_swig.vector_str___getslice__(*args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, vector_str v)"""
        return _steps_swig.vector_str___setslice__(*args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _steps_swig.vector_str___delslice__(*args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return _steps_swig.vector_str___delitem__(*args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return _steps_swig.vector_str___getitem__(*args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return _steps_swig.vector_str___setitem__(*args)

    def append(*args):
        """append(self, value_type x)"""
        return _steps_swig.vector_str_append(*args)

    def empty(*args):
        """empty(self) -> bool"""
        return _steps_swig.vector_str_empty(*args)

    def size(*args):
        """size(self) -> size_type"""
        return _steps_swig.vector_str_size(*args)

    def clear(*args):
        """clear(self)"""
        return _steps_swig.vector_str_clear(*args)

    def swap(*args):
        """swap(self, vector_str v)"""
        return _steps_swig.vector_str_swap(*args)

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return _steps_swig.vector_str_get_allocator(*args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return _steps_swig.vector_str_begin(*args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return _steps_swig.vector_str_end(*args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_str_rbegin(*args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_str_rend(*args)

    def pop_back(*args):
        """pop_back(self)"""
        return _steps_swig.vector_str_pop_back(*args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _steps_swig.vector_str_erase(*args)

    def __init__(self, *args): 
        """
        __init__(self) -> vector_str
        __init__(self, vector_str ?) -> vector_str
        __init__(self, size_type size) -> vector_str
        __init__(self, size_type size, value_type value) -> vector_str
        """
        this = _steps_swig.new_vector_str(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return _steps_swig.vector_str_push_back(*args)

    def front(*args):
        """front(self) -> value_type"""
        return _steps_swig.vector_str_front(*args)

    def back(*args):
        """back(self) -> value_type"""
        return _steps_swig.vector_str_back(*args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return _steps_swig.vector_str_assign(*args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _steps_swig.vector_str_resize(*args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _steps_swig.vector_str_insert(*args)

    def reserve(*args):
        """reserve(self, size_type n)"""
        return _steps_swig.vector_str_reserve(*args)

    def capacity(*args):
        """capacity(self) -> size_type"""
        return _steps_swig.vector_str_capacity(*args)

    __swig_destroy__ = _steps_swig.delete_vector_str
    __del__ = lambda self : None;
vector_str_swigregister = _steps_swig.vector_str_swigregister
vector_str_swigregister(vector_str)

class vector_spc(_object):
    """Proxy of C++ vector_spc class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vector_spc, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vector_spc, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return _steps_swig.vector_spc_iterator(*args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return _steps_swig.vector_spc___nonzero__(*args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return _steps_swig.vector_spc___len__(*args)

    def pop(*args):
        """pop(self) -> value_type"""
        return _steps_swig.vector_spc_pop(*args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> vector_spc"""
        return _steps_swig.vector_spc___getslice__(*args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, vector_spc v)"""
        return _steps_swig.vector_spc___setslice__(*args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _steps_swig.vector_spc___delslice__(*args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return _steps_swig.vector_spc___delitem__(*args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return _steps_swig.vector_spc___getitem__(*args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return _steps_swig.vector_spc___setitem__(*args)

    def append(*args):
        """append(self, value_type x)"""
        return _steps_swig.vector_spc_append(*args)

    def empty(*args):
        """empty(self) -> bool"""
        return _steps_swig.vector_spc_empty(*args)

    def size(*args):
        """size(self) -> size_type"""
        return _steps_swig.vector_spc_size(*args)

    def clear(*args):
        """clear(self)"""
        return _steps_swig.vector_spc_clear(*args)

    def swap(*args):
        """swap(self, vector_spc v)"""
        return _steps_swig.vector_spc_swap(*args)

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return _steps_swig.vector_spc_get_allocator(*args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return _steps_swig.vector_spc_begin(*args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return _steps_swig.vector_spc_end(*args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_spc_rbegin(*args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_spc_rend(*args)

    def pop_back(*args):
        """pop_back(self)"""
        return _steps_swig.vector_spc_pop_back(*args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _steps_swig.vector_spc_erase(*args)

    def __init__(self, *args): 
        """
        __init__(self) -> vector_spc
        __init__(self, vector_spc ?) -> vector_spc
        __init__(self, size_type size) -> vector_spc
        __init__(self, size_type size, value_type value) -> vector_spc
        """
        this = _steps_swig.new_vector_spc(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return _steps_swig.vector_spc_push_back(*args)

    def front(*args):
        """front(self) -> value_type"""
        return _steps_swig.vector_spc_front(*args)

    def back(*args):
        """back(self) -> value_type"""
        return _steps_swig.vector_spc_back(*args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return _steps_swig.vector_spc_assign(*args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _steps_swig.vector_spc_resize(*args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _steps_swig.vector_spc_insert(*args)

    def reserve(*args):
        """reserve(self, size_type n)"""
        return _steps_swig.vector_spc_reserve(*args)

    def capacity(*args):
        """capacity(self) -> size_type"""
        return _steps_swig.vector_spc_capacity(*args)

    __swig_destroy__ = _steps_swig.delete_vector_spc
    __del__ = lambda self : None;
vector_spc_swigregister = _steps_swig.vector_spc_swigregister
vector_spc_swigregister(vector_spc)

class vector_rec(_object):
    """Proxy of C++ vector_rec class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vector_rec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vector_rec, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return _steps_swig.vector_rec_iterator(*args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return _steps_swig.vector_rec___nonzero__(*args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return _steps_swig.vector_rec___len__(*args)

    def pop(*args):
        """pop(self) -> value_type"""
        return _steps_swig.vector_rec_pop(*args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> vector_rec"""
        return _steps_swig.vector_rec___getslice__(*args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, vector_rec v)"""
        return _steps_swig.vector_rec___setslice__(*args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _steps_swig.vector_rec___delslice__(*args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return _steps_swig.vector_rec___delitem__(*args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return _steps_swig.vector_rec___getitem__(*args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return _steps_swig.vector_rec___setitem__(*args)

    def append(*args):
        """append(self, value_type x)"""
        return _steps_swig.vector_rec_append(*args)

    def empty(*args):
        """empty(self) -> bool"""
        return _steps_swig.vector_rec_empty(*args)

    def size(*args):
        """size(self) -> size_type"""
        return _steps_swig.vector_rec_size(*args)

    def clear(*args):
        """clear(self)"""
        return _steps_swig.vector_rec_clear(*args)

    def swap(*args):
        """swap(self, vector_rec v)"""
        return _steps_swig.vector_rec_swap(*args)

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return _steps_swig.vector_rec_get_allocator(*args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return _steps_swig.vector_rec_begin(*args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return _steps_swig.vector_rec_end(*args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_rec_rbegin(*args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_rec_rend(*args)

    def pop_back(*args):
        """pop_back(self)"""
        return _steps_swig.vector_rec_pop_back(*args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _steps_swig.vector_rec_erase(*args)

    def __init__(self, *args): 
        """
        __init__(self) -> vector_rec
        __init__(self, vector_rec ?) -> vector_rec
        __init__(self, size_type size) -> vector_rec
        __init__(self, size_type size, value_type value) -> vector_rec
        """
        this = _steps_swig.new_vector_rec(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return _steps_swig.vector_rec_push_back(*args)

    def front(*args):
        """front(self) -> value_type"""
        return _steps_swig.vector_rec_front(*args)

    def back(*args):
        """back(self) -> value_type"""
        return _steps_swig.vector_rec_back(*args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return _steps_swig.vector_rec_assign(*args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _steps_swig.vector_rec_resize(*args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _steps_swig.vector_rec_insert(*args)

    def reserve(*args):
        """reserve(self, size_type n)"""
        return _steps_swig.vector_rec_reserve(*args)

    def capacity(*args):
        """capacity(self) -> size_type"""
        return _steps_swig.vector_rec_capacity(*args)

    __swig_destroy__ = _steps_swig.delete_vector_rec
    __del__ = lambda self : None;
vector_rec_swigregister = _steps_swig.vector_rec_swigregister
vector_rec_swigregister(vector_rec)

class vector_src(_object):
    """Proxy of C++ vector_src class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vector_src, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vector_src, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return _steps_swig.vector_src_iterator(*args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return _steps_swig.vector_src___nonzero__(*args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return _steps_swig.vector_src___len__(*args)

    def pop(*args):
        """pop(self) -> value_type"""
        return _steps_swig.vector_src_pop(*args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> vector_src"""
        return _steps_swig.vector_src___getslice__(*args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, vector_src v)"""
        return _steps_swig.vector_src___setslice__(*args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _steps_swig.vector_src___delslice__(*args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return _steps_swig.vector_src___delitem__(*args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return _steps_swig.vector_src___getitem__(*args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return _steps_swig.vector_src___setitem__(*args)

    def append(*args):
        """append(self, value_type x)"""
        return _steps_swig.vector_src_append(*args)

    def empty(*args):
        """empty(self) -> bool"""
        return _steps_swig.vector_src_empty(*args)

    def size(*args):
        """size(self) -> size_type"""
        return _steps_swig.vector_src_size(*args)

    def clear(*args):
        """clear(self)"""
        return _steps_swig.vector_src_clear(*args)

    def swap(*args):
        """swap(self, vector_src v)"""
        return _steps_swig.vector_src_swap(*args)

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return _steps_swig.vector_src_get_allocator(*args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return _steps_swig.vector_src_begin(*args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return _steps_swig.vector_src_end(*args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_src_rbegin(*args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_src_rend(*args)

    def pop_back(*args):
        """pop_back(self)"""
        return _steps_swig.vector_src_pop_back(*args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _steps_swig.vector_src_erase(*args)

    def __init__(self, *args): 
        """
        __init__(self) -> vector_src
        __init__(self, vector_src ?) -> vector_src
        __init__(self, size_type size) -> vector_src
        __init__(self, size_type size, value_type value) -> vector_src
        """
        this = _steps_swig.new_vector_src(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return _steps_swig.vector_src_push_back(*args)

    def front(*args):
        """front(self) -> value_type"""
        return _steps_swig.vector_src_front(*args)

    def back(*args):
        """back(self) -> value_type"""
        return _steps_swig.vector_src_back(*args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return _steps_swig.vector_src_assign(*args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _steps_swig.vector_src_resize(*args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _steps_swig.vector_src_insert(*args)

    def reserve(*args):
        """reserve(self, size_type n)"""
        return _steps_swig.vector_src_reserve(*args)

    def capacity(*args):
        """capacity(self) -> size_type"""
        return _steps_swig.vector_src_capacity(*args)

    __swig_destroy__ = _steps_swig.delete_vector_src
    __del__ = lambda self : None;
vector_src_swigregister = _steps_swig.vector_src_swigregister
vector_src_swigregister(vector_src)

class vector_dif(_object):
    """Proxy of C++ vector_dif class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vector_dif, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vector_dif, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return _steps_swig.vector_dif_iterator(*args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return _steps_swig.vector_dif___nonzero__(*args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return _steps_swig.vector_dif___len__(*args)

    def pop(*args):
        """pop(self) -> value_type"""
        return _steps_swig.vector_dif_pop(*args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> vector_dif"""
        return _steps_swig.vector_dif___getslice__(*args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, vector_dif v)"""
        return _steps_swig.vector_dif___setslice__(*args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _steps_swig.vector_dif___delslice__(*args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return _steps_swig.vector_dif___delitem__(*args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return _steps_swig.vector_dif___getitem__(*args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return _steps_swig.vector_dif___setitem__(*args)

    def append(*args):
        """append(self, value_type x)"""
        return _steps_swig.vector_dif_append(*args)

    def empty(*args):
        """empty(self) -> bool"""
        return _steps_swig.vector_dif_empty(*args)

    def size(*args):
        """size(self) -> size_type"""
        return _steps_swig.vector_dif_size(*args)

    def clear(*args):
        """clear(self)"""
        return _steps_swig.vector_dif_clear(*args)

    def swap(*args):
        """swap(self, vector_dif v)"""
        return _steps_swig.vector_dif_swap(*args)

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return _steps_swig.vector_dif_get_allocator(*args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return _steps_swig.vector_dif_begin(*args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return _steps_swig.vector_dif_end(*args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_dif_rbegin(*args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_dif_rend(*args)

    def pop_back(*args):
        """pop_back(self)"""
        return _steps_swig.vector_dif_pop_back(*args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _steps_swig.vector_dif_erase(*args)

    def __init__(self, *args): 
        """
        __init__(self) -> vector_dif
        __init__(self, vector_dif ?) -> vector_dif
        __init__(self, size_type size) -> vector_dif
        __init__(self, size_type size, value_type value) -> vector_dif
        """
        this = _steps_swig.new_vector_dif(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return _steps_swig.vector_dif_push_back(*args)

    def front(*args):
        """front(self) -> value_type"""
        return _steps_swig.vector_dif_front(*args)

    def back(*args):
        """back(self) -> value_type"""
        return _steps_swig.vector_dif_back(*args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return _steps_swig.vector_dif_assign(*args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _steps_swig.vector_dif_resize(*args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _steps_swig.vector_dif_insert(*args)

    def reserve(*args):
        """reserve(self, size_type n)"""
        return _steps_swig.vector_dif_reserve(*args)

    def capacity(*args):
        """capacity(self) -> size_type"""
        return _steps_swig.vector_dif_capacity(*args)

    __swig_destroy__ = _steps_swig.delete_vector_dif
    __del__ = lambda self : None;
vector_dif_swigregister = _steps_swig.vector_dif_swigregister
vector_dif_swigregister(vector_dif)

class vector_vsys(_object):
    """Proxy of C++ vector_vsys class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vector_vsys, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vector_vsys, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return _steps_swig.vector_vsys_iterator(*args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return _steps_swig.vector_vsys___nonzero__(*args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return _steps_swig.vector_vsys___len__(*args)

    def pop(*args):
        """pop(self) -> value_type"""
        return _steps_swig.vector_vsys_pop(*args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> vector_vsys"""
        return _steps_swig.vector_vsys___getslice__(*args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, vector_vsys v)"""
        return _steps_swig.vector_vsys___setslice__(*args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _steps_swig.vector_vsys___delslice__(*args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return _steps_swig.vector_vsys___delitem__(*args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return _steps_swig.vector_vsys___getitem__(*args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return _steps_swig.vector_vsys___setitem__(*args)

    def append(*args):
        """append(self, value_type x)"""
        return _steps_swig.vector_vsys_append(*args)

    def empty(*args):
        """empty(self) -> bool"""
        return _steps_swig.vector_vsys_empty(*args)

    def size(*args):
        """size(self) -> size_type"""
        return _steps_swig.vector_vsys_size(*args)

    def clear(*args):
        """clear(self)"""
        return _steps_swig.vector_vsys_clear(*args)

    def swap(*args):
        """swap(self, vector_vsys v)"""
        return _steps_swig.vector_vsys_swap(*args)

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return _steps_swig.vector_vsys_get_allocator(*args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return _steps_swig.vector_vsys_begin(*args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return _steps_swig.vector_vsys_end(*args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_vsys_rbegin(*args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_vsys_rend(*args)

    def pop_back(*args):
        """pop_back(self)"""
        return _steps_swig.vector_vsys_pop_back(*args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _steps_swig.vector_vsys_erase(*args)

    def __init__(self, *args): 
        """
        __init__(self) -> vector_vsys
        __init__(self, vector_vsys ?) -> vector_vsys
        __init__(self, size_type size) -> vector_vsys
        __init__(self, size_type size, value_type value) -> vector_vsys
        """
        this = _steps_swig.new_vector_vsys(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return _steps_swig.vector_vsys_push_back(*args)

    def front(*args):
        """front(self) -> value_type"""
        return _steps_swig.vector_vsys_front(*args)

    def back(*args):
        """back(self) -> value_type"""
        return _steps_swig.vector_vsys_back(*args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return _steps_swig.vector_vsys_assign(*args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _steps_swig.vector_vsys_resize(*args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _steps_swig.vector_vsys_insert(*args)

    def reserve(*args):
        """reserve(self, size_type n)"""
        return _steps_swig.vector_vsys_reserve(*args)

    def capacity(*args):
        """capacity(self) -> size_type"""
        return _steps_swig.vector_vsys_capacity(*args)

    __swig_destroy__ = _steps_swig.delete_vector_vsys
    __del__ = lambda self : None;
vector_vsys_swigregister = _steps_swig.vector_vsys_swigregister
vector_vsys_swigregister(vector_vsys)

class vector_ssys(_object):
    """Proxy of C++ vector_ssys class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vector_ssys, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vector_ssys, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return _steps_swig.vector_ssys_iterator(*args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return _steps_swig.vector_ssys___nonzero__(*args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return _steps_swig.vector_ssys___len__(*args)

    def pop(*args):
        """pop(self) -> value_type"""
        return _steps_swig.vector_ssys_pop(*args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> vector_ssys"""
        return _steps_swig.vector_ssys___getslice__(*args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, vector_ssys v)"""
        return _steps_swig.vector_ssys___setslice__(*args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _steps_swig.vector_ssys___delslice__(*args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return _steps_swig.vector_ssys___delitem__(*args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return _steps_swig.vector_ssys___getitem__(*args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return _steps_swig.vector_ssys___setitem__(*args)

    def append(*args):
        """append(self, value_type x)"""
        return _steps_swig.vector_ssys_append(*args)

    def empty(*args):
        """empty(self) -> bool"""
        return _steps_swig.vector_ssys_empty(*args)

    def size(*args):
        """size(self) -> size_type"""
        return _steps_swig.vector_ssys_size(*args)

    def clear(*args):
        """clear(self)"""
        return _steps_swig.vector_ssys_clear(*args)

    def swap(*args):
        """swap(self, vector_ssys v)"""
        return _steps_swig.vector_ssys_swap(*args)

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return _steps_swig.vector_ssys_get_allocator(*args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return _steps_swig.vector_ssys_begin(*args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return _steps_swig.vector_ssys_end(*args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_ssys_rbegin(*args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_ssys_rend(*args)

    def pop_back(*args):
        """pop_back(self)"""
        return _steps_swig.vector_ssys_pop_back(*args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _steps_swig.vector_ssys_erase(*args)

    def __init__(self, *args): 
        """
        __init__(self) -> vector_ssys
        __init__(self, vector_ssys ?) -> vector_ssys
        __init__(self, size_type size) -> vector_ssys
        __init__(self, size_type size, value_type value) -> vector_ssys
        """
        this = _steps_swig.new_vector_ssys(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return _steps_swig.vector_ssys_push_back(*args)

    def front(*args):
        """front(self) -> value_type"""
        return _steps_swig.vector_ssys_front(*args)

    def back(*args):
        """back(self) -> value_type"""
        return _steps_swig.vector_ssys_back(*args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return _steps_swig.vector_ssys_assign(*args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _steps_swig.vector_ssys_resize(*args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _steps_swig.vector_ssys_insert(*args)

    def reserve(*args):
        """reserve(self, size_type n)"""
        return _steps_swig.vector_ssys_reserve(*args)

    def capacity(*args):
        """capacity(self) -> size_type"""
        return _steps_swig.vector_ssys_capacity(*args)

    __swig_destroy__ = _steps_swig.delete_vector_ssys
    __del__ = lambda self : None;
vector_ssys_swigregister = _steps_swig.vector_ssys_swigregister
vector_ssys_swigregister(vector_ssys)


def isValidID(*args):
  """isValidID(string id) -> bool"""
  return _steps_swig.isValidID(*args)

def checkID(*args):
  """checkID(string id)"""
  return _steps_swig.checkID(*args)
class Model(_object):
    """Proxy of C++ Model class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Model, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Model, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> Model"""
        this = _steps_swig.new_Model(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _steps_swig.delete_Model
    __del__ = lambda self : None;
    def getSpec(*args):
        """
        Returns a reference to the steps.model.Spec species object with 
        identifier string spec_id (if defined).

        Syntax::

            getSpec(spec_id)

        Arguments:
            string spec_id
                     
        Return:
            steps.model.Spec

        """
        return _steps_swig.Model_getSpec(*args)

    def delSpec(*args):
        """
        Remove the steps.model.Spec species object with identifier 
        string spec_id (if defined) from the model.

        Syntax::

            delSpec(spec_id)

        Arguments:
            string spec_id

        Return:
            None

        """
        return _steps_swig.Model_delSpec(*args)

    def getAllSpecs(*args):
        """
        Returns a list of steps.model.Spec object references of all species in the model.

        Syntax::

            getAllSpecs()
            
        Arguments:
            None
                     
        Return:
            list<steps.model.Spec>

        """
        return _steps_swig.Model_getAllSpecs(*args)

    def getVolsys(*args):
        """
        Returns a reference to the steps.model.Volsys volume system object with 
        identifier string vsys_id (if defined).

        Syntax::

            getVolsys(vsys_id)

        Arguments:
            string vsys_id

        Return:
            steps.model.Volsys

        """
        return _steps_swig.Model_getVolsys(*args)

    def delVolsys(*args):
        """
        Remove the steps.model.Volsys volume system object with identifier string 
        vsys_id (if defined) from the model.

        Syntax::

            delVolsys(vsys_id)

        Arguments:
            string vsys_id

        Return:
            None

        """
        return _steps_swig.Model_delVolsys(*args)

    def getAllVolsyss(*args):
        """
        Returns a list of steps.model.Volsys object references of all volume systems in the model.
                     
        Syntax::
                     
            getAllVolsyss()
                     
        Arguments:
            None
                     
        Return:
            list<steps.model.Volsys>

        """
        return _steps_swig.Model_getAllVolsyss(*args)

    def getSurfsys(*args):
        """
        Returns a reference to the steps.model.Surfsys surface system object with 
        identifier string ssys_id (if defined).

        Syntax::

            getSurfsys(ssys_id)

        Arguments:
            string ssys_id

        Return:
            steps.model.Surfsys

        """
        return _steps_swig.Model_getSurfsys(*args)

    def delSurfsys(*args):
        """
        Remove the steps.model.Surfsys surface system object with identifier string 
        ssys_id (if defined) from the model.

        Syntax::

            delSurfsys(ssys_id)

        Arguments:
            string ssys_id

        Return:
            None

        """
        return _steps_swig.Model_delSurfsys(*args)

    def getAllSurfsyss(*args):
        """
        Returns a list of steps.model.Surfsys object references of all surface systems in the model.

        ax::

        getAllSurfsyss()

        ments:
        None

        rn:
        list<steps.model.Surfsys>

        """
        return _steps_swig.Model_getAllSurfsyss(*args)

Model_swigregister = _steps_swig.Model_swigregister
Model_swigregister(Model)

class Spec(_object):
    """Proxy of C++ Spec class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Spec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Spec, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string id, Model model) -> Spec"""
        this = _steps_swig.new_Spec(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _steps_swig.delete_Spec
    __del__ = lambda self : None;
    def getID(*args):
        """
        Get the identifier string of the species.

        Syntax::

            getID()

        Arguments:
            None

        Return:
            string

        """
        return _steps_swig.Spec_getID(*args)

    def setID(*args):
        """
        Set the identifier string of the species.

        Syntax::

            setID(name)

        Arguments:
            string name

        Return:
            None

        """
        return _steps_swig.Spec_setID(*args)

    def getModel(*args):
        """
        Returns a reference to the parent steps.model.Model container object.

        Syntax::

            getModel()
            
        Arguments:
            None

        Return:
            steps.model.Model
            
        Attribute:
            model

        """
        return _steps_swig.Spec_getModel(*args)

Spec_swigregister = _steps_swig.Spec_swigregister
Spec_swigregister(Spec)

class Surfsys(_object):
    """Proxy of C++ Surfsys class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Surfsys, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Surfsys, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string id, Model model) -> Surfsys"""
        this = _steps_swig.new_Surfsys(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _steps_swig.delete_Surfsys
    __del__ = lambda self : None;
    def getID(*args):
        """
        Get the identifier string of the surface system.

        Syntax::
            
            getID()

        Arguments:
            None

        Return:
            string

        """
        return _steps_swig.Surfsys_getID(*args)

    def setID(*args):
        """
        Set the identifier string of the surface system.

        Syntax::

            setID(name)
            
        Arguments:
            string name

        Return:
            None

        """
        return _steps_swig.Surfsys_setID(*args)

    def getModel(*args):
        """
        Returns a reference to the parent steps.model.Model container object.

        Syntax::

            getModel()

        Arguments:
            None

        Return:
            steps.model.Model

        """
        return _steps_swig.Surfsys_getModel(*args)

    def getSReac(*args):
        """
        Returns a reference to the steps.model.SReac surface-reaction object 
        with identifier sreac_id (if defined in the surface system.

        Syntax::

            getSReac(sreac_id)

        Arguments:
            string sreac_id

        Return:
            steps.model.SReac

        """
        return _steps_swig.Surfsys_getSReac(*args)

    def delSReac(*args):
        """
        Remove the steps.model.SReac surface-reaction object with identifier 
        sreac_id from the surface system.

        Syntax::

            delSReac(sreac_id)
            
        Arguments:
            string sreac_id

        Return:
            None

        """
        return _steps_swig.Surfsys_delSReac(*args)

    def getAllSReacs(*args):
        """
        Returns a list of references to all steps.model.SReac surface-reaction 
        objects defined in the surface system.

        Syntax::

            getAllSReacs()

        Arguments:
            None

        Return:
            list<steps.model.SReac>

        """
        return _steps_swig.Surfsys_getAllSReacs(*args)

    def getAllSpecs(*args):
        """
        Returns a list of references to all steps.model.Spec species objects included 
        in the surface system; that is all reactants and products in the surface 
        reactions belonging to this surface system. No duplicate member is included.

        Syntax::

            getAllSpecs()
            
        Arguments:
            None

        Return:
            list<steps.model.Spec>

        """
        return _steps_swig.Surfsys_getAllSpecs(*args)

Surfsys_swigregister = _steps_swig.Surfsys_swigregister
Surfsys_swigregister(Surfsys)

class Volsys(_object):
    """Proxy of C++ Volsys class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Volsys, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Volsys, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string id, Model model) -> Volsys"""
        this = _steps_swig.new_Volsys(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _steps_swig.delete_Volsys
    __del__ = lambda self : None;
    def getID(*args):
        """
        Get the identifier string of the volume system.

        Syntax::

            getID()
            
        Arguments:
            None

        Return:
            string

        """
        return _steps_swig.Volsys_getID(*args)

    def setID(*args):
        """
        Set the identifier string of the volume system.

        Syntax::

            setID(name)
            
        Arguments:
            string name

        Return:
            None

        """
        return _steps_swig.Volsys_setID(*args)

    def getModel(*args):
        """
        Returns a reference to the parent steps.model.Model container object.

        Syntax::

            getModel()
            
        Arguments:
            None

        Return:
            steps.model.Model

        """
        return _steps_swig.Volsys_getModel(*args)

    def getReac(*args):
        """
        Returns a reference to the steps.model.Reac reaction-rule object with 
        identifier string reac_id (if defined in the volume system).

        Syntax::

            getReac(reac_id)
            
        Arguments:
            string reac_id

        Return:
            steps.model.Reac

        """
        return _steps_swig.Volsys_getReac(*args)

    def delReac(*args):
        """
        Remove the steps.model.Reac reaction-rule object with identifier reac_id 
        (if defined) from the volume system.

        Syntax::

            delReac(reac_id)

        Arguments:
            string reac_id

        Return:
            None

        """
        return _steps_swig.Volsys_delReac(*args)

    def getAllReacs(*args):
        """
        Returns a list of references to all steps.model.Reac objects in this volume 
        system; that is all the reaction rules belonging to this volume system. 
        No duplicate member is included.

        Syntax::

            getAllReacs()
            
        Arguments:
            None

        Return:
            list<steps.model.Reac>

        """
        return _steps_swig.Volsys_getAllReacs(*args)

    def getDiff(*args):
        """
        Returns a reference to the steps.model.Diff diffusion-rule object with 
        identifier diff_id (if defined in the volume system).

        Syntax::

            getDiff(diff_id)
            
        Arguments:
            string diff_id

        Return:
            steps.model.Diff

        """
        return _steps_swig.Volsys_getDiff(*args)

    def delDiff(*args):
        """
        Remove the steps.model.Diff diffusion-rule object with identifier diff_id 
        from the volume system.

        Syntax::

            delDiff(diff_id)
            
        Arguments:
            string diff_id

        Return:
            None

        """
        return _steps_swig.Volsys_delDiff(*args)

    def getAllDiffs(*args):
        """
        Returns a list of references to all steps.model.Diff diffusion-rule objects 
        defined in the volume system.

        Syntax::

            getAllDiffs()
            
        Arguments:
            None

        Return:
            list<steps.model.Diff>

        """
        return _steps_swig.Volsys_getAllDiffs(*args)

    def getAllSpecs(*args):
        """
        Returns a list of references to all steps.model.Spec objects in this volume system; 
        that is all reactants, products or diffusing species in the reaction and diffusion 
        rules belonging to this volume system. No duplicate member is included.

        Syntax::

            getAllSpecs()
            
        Arguments:
            None

        Return:
            list<steps.model.Spec>

        """
        return _steps_swig.Volsys_getAllSpecs(*args)

Volsys_swigregister = _steps_swig.Volsys_swigregister
Volsys_swigregister(Volsys)

class Diff(_object):
    """Proxy of C++ Diff class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Diff, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Diff, name)
    __repr__ = _swig_repr
    def __init__(self, *args, **kwargs): 
        """__init__(self, string id, Volsys volsys, Spec lig, double dcst=0.0) -> Diff"""
        this = _steps_swig.new_Diff(*args, **kwargs)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _steps_swig.delete_Diff
    __del__ = lambda self : None;
    def getID(*args):
        """
        Get the identifier string of the diffusion rule.

        Syntax::

            getID()
            
        Arguments:
            None

        Return:
            string

        """
        return _steps_swig.Diff_getID(*args)

    def setID(*args):
        """
        Set the identifier string of the diffusion rule.

        Syntax::

            setID(name)
            
        Arguments:
            string name

        Return:
            None

        """
        return _steps_swig.Diff_setID(*args)

    def getVolsys(*args):
        """
        Returns a reference to the parent steps.model.Volsys volume system object.

        Syntax::

            getVolsys()
            
        Arguments:
            None

        Return:
            steps.model.Volsys

        """
        return _steps_swig.Diff_getVolsys(*args)

    def getModel(*args):
        """
        Returns a reference to the parent steps.model.Model container object.

        Syntax::

            getModel()
            
        Arguments:
            None

        Return:
            steps.model.Model

        """
        return _steps_swig.Diff_getModel(*args)

    def getLig(*args):
        """
        get a reference to the steps.model.Spec species object to which this 
        diffusion rule is applied.

        Syntax::

            getLig()
            
        Arguments:
            None

        Return:
            steps.model.Spec

        """
        return _steps_swig.Diff_getLig(*args)

    def setLig(*args):
        """
        Set a reference to the steps.model.Spec species object to which this 
        diffusion rule is applied.

        Syntax::

            setLig(lig)
            
        Arguments:
            steps.model.Spec lig

        Return:
            None

        """
        return _steps_swig.Diff_setLig(*args)

    def getDcst(*args):
        """
        Get the diffusion constant for the diffusion rule, in s.i. units.

        Syntax::

            getDcst()
            
        Arguments:
            None

        Return:
            float

        """
        return _steps_swig.Diff_getDcst(*args)

    def setDcst(*args):
        """
        Set the diffusion constant for the diffusion rule, in s.i. units.

        Syntax::

            setDcst(dcst)
            
        Arguments:
            float dcst

        Return:
            None

        """
        return _steps_swig.Diff_setDcst(*args)

Diff_swigregister = _steps_swig.Diff_swigregister
Diff_swigregister(Diff)

class Reac(_object):
    """Proxy of C++ Reac class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Reac, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Reac, name)
    __repr__ = _swig_repr
    def __init__(self, *args, **kwargs): 
        """
        __init__(self, string id, Volsys volsys, vector_spc lhs=std::vector<steps::model::Spec * >(), 
            vector_spc rhs=std::vector<steps::model::Spec * >(), 
            double kcst=0.0) -> Reac
        """
        this = _steps_swig.new_Reac(*args, **kwargs)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _steps_swig.delete_Reac
    __del__ = lambda self : None;
    def getID(*args):
        """
        Get the identifier string of the reaction rule.

        Syntax::

            getID()
            
        Arguments:
            None

        Return:
            string

        """
        return _steps_swig.Reac_getID(*args)

    def setID(*args):
        """
        Set the identifier string of the reaction rule.

        Syntax::

            setID(name)
            
        Arguments:
            string name

        Return:
            None

        """
        return _steps_swig.Reac_setID(*args)

    def getVolsys(*args):
        """
        Returns a reference to the parent steps.model.Volsys volume system object.

        Syntax::

            getVolsys()
            
        Arguments:
            None

        Return:
            steps.model.Volsys

        """
        return _steps_swig.Reac_getVolsys(*args)

    def getModel(*args):
        """
        Returns a reference to the parent steps.model.Model container object.

        Syntax::

            getModel()
            
        Arguments:
            None

        Return:
            steps.model.Model

        """
        return _steps_swig.Reac_getModel(*args)

    def getLHS(*args):
        """
        Get a list of references to steps.model.Spec species objects on the 
        left hand side of the reaction: the reactants.

        Syntax::

            getLHS()
            
        Arguments:
            None

        Return:
            list<steps.model.Spec>

        """
        return _steps_swig.Reac_getLHS(*args)

    def setLHS(*args):
        """
        Set a list of references to steps.model.Spec species objects on the 
        left hand side of the reaction: the reactants.

        Syntax::

            setLHS(lhs)

        Arguments:
            list<steps.model.Spec> lhs

        Return:
            None

        """
        return _steps_swig.Reac_setLHS(*args)

    def getRHS(*args):
        """
        Get a list of references to steps.model.Spec species objects on the 
        right hand side of the reaction: the reactants.

        Syntax::

            getRHS()

        Arguments:
            None

        Return:
            list<steps.model.Spec>

        """
        return _steps_swig.Reac_getRHS(*args)

    def setRHS(*args):
        """
        Set a list of references to steps.model.Spec species objects on the 
        right hand side of the reaction: the reactants.

        Syntax::

            setRHS(rhs)
            
        Arguments:
            list<steps.model.Spec> rhs

        Return:
            None

        """
        return _steps_swig.Reac_setRHS(*args)

    def getOrder(*args):
        """
        Returns the order of this reaction.

        Syntax::

            getOrder()
            
        Arguments:
            None

        Return:
            int

        """
        return _steps_swig.Reac_getOrder(*args)

    def getKcst(*args):
        """
        Get the kinetic reaction rate constant, in s.i. units, 
        where the actual units depend on the order of the reaction.

        Syntax::
            
            getKcst()

        Arguments:
            None

        Return:
            float

        """
        return _steps_swig.Reac_getKcst(*args)

    def setKcst(*args):
        """
        Set the kinetic reaction rate constant, in s.i. units, 
        where the actual units depend on the order of the reaction.

        Syntax::
            
            setKcst(kcst)

        Arguments:
            float kcst

        Return:
            None

        """
        return _steps_swig.Reac_setKcst(*args)

    def getAllSpecs(*args):
        """
        Returns a list of references to all steps.model.Spec species objects in 
        the reaction; that is all reactants and products. No duplicate member 
        is included.

        Syntax::

            getAllSpecs()

        Arguments:
            None

        Return:
            list<steps.model.Spec>

        """
        return _steps_swig.Reac_getAllSpecs(*args)

Reac_swigregister = _steps_swig.Reac_swigregister
Reac_swigregister(Reac)

class SReac(_object):
    """Proxy of C++ SReac class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SReac, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SReac, name)
    __repr__ = _swig_repr
    def __init__(self, *args, **kwargs): 
        """
        __init__(self, string id, Surfsys surfsys, vector_spc olhs=std::vector<steps::model::Spec * >(), 
            vector_spc ilhs=std::vector<steps::model::Spec * >(), 
            vector_spc slhs=std::vector<steps::model::Spec * >(), 
            vector_spc irhs=std::vector<steps::model::Spec * >(), 
            vector_spc srhs=std::vector<steps::model::Spec * >(), 
            vector_spc orhs=std::vector<steps::model::Spec * >(), 
            double kcst=0.0) -> SReac
        """
        this = _steps_swig.new_SReac(*args, **kwargs)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _steps_swig.delete_SReac
    __del__ = lambda self : None;
    def getID(*args):
        """
        Get the identifier string of the surface reaction rule.

        Syntax::

            getID()
            
        Arguments:
            None

        Return:
            string

        """
        return _steps_swig.SReac_getID(*args)

    def setID(*args):
        """
        Set the identifier string of the surface reaction rule.

        Syntax::

            setID(name)
            
        Arguments:
            string name

        Return:
            None

        """
        return _steps_swig.SReac_setID(*args)

    def getSurfsys(*args):
        """
        Returns a reference to the parent steps.model.Surfsys surface system object.

        Syntax::

            getSurfsys()
            
        Arguments:
            None

        Return:
            steps.model.Surfsys

        """
        return _steps_swig.SReac_getSurfsys(*args)

    def getModel(*args):
        """
        Returns a reference to the parent steps.model.Model container object.

        Syntax::

            getModel()
            
        Arguments:
            None

        Return:
            steps.model.Model

        """
        return _steps_swig.SReac_getModel(*args)

    def getInner(*args):
        """Obsolete"""
        return _steps_swig.SReac_getInner(*args)

    def getOuter(*args):
        """Obsolete"""
        return _steps_swig.SReac_getOuter(*args)

    def getOLHS(*args):
        """
        Get a list of references to steps.model.Spec species objects; 
        the left hand side outer volume reactants.

        Syntax::

            getOLHS()
            
        Arguments:
            None

        Return:
            list<steps.model.Spec>

        """
        return _steps_swig.SReac_getOLHS(*args)

    def setOLHS(*args):
        """
        Set a list of references to steps.model.Spec species objects; 
        the left hand side outer volume reactants.

        Syntax::

            setOLHS(olhs)
            
        Arguments:
            list<steps.model.Spec) olhs

        Return:
            None

        """
        return _steps_swig.SReac_setOLHS(*args)

    def getILHS(*args):
        """
        Get a list of references to steps.model.Spec species objects; 
        the left hand side inner volume reactants.

        Syntax::
            
            getILHS()

        Arguments:
            None

        Return:
            list<steps.model.Spec>

        """
        return _steps_swig.SReac_getILHS(*args)

    def setILHS(*args):
        """
        Set a list of references to steps.model.Spec species objects; 
        the left hand side inner volume reactants.

        Syntax::

            setILHS(ilhs)

        Arguments:
            list<steps.model.Spec> ilhs

        Return:
            None

        """
        return _steps_swig.SReac_setILHS(*args)

    def getSLHS(*args):
        """
        Get a list of references to steps.model.Spec species objects; 
        the left hand side surface reactants.

        Syntax::

            getSLHS()
            
        Arguments:
            None

        Return:
            list<steps.model.Spec>

        """
        return _steps_swig.SReac_getSLHS(*args)

    def setSLHS(*args):
        """
        Set a list of references to steps.model.Spec species objects; 
        the left hand side surface reactants.

        Syntax::

            setSLHS(slhs)
            
        Arguments:
            list<steps.model.Spec> slhs

        Return:
            None

        """
        return _steps_swig.SReac_setSLHS(*args)

    def getIRHS(*args):
        """
        Get a list of references to steps.model.Spec species objects; 
        the right hand side inner volume reactants.

        Syntax::

            getIRHS()
            
        Arguments:
            None

        Return:
            list<steps.model.Spec>

        """
        return _steps_swig.SReac_getIRHS(*args)

    def setIRHS(*args):
        """
        Set a list of references to steps.model.Spec species objects; 
        the right hand side inner volume reactants.

        Syntax::

            setIRHS(irhs)
            
        Arguments:
            list<steps.model.Spec> irhs

        Return:
            None

        """
        return _steps_swig.SReac_setIRHS(*args)

    def getSRHS(*args):
        """
        Get a list of references to steps.model.Spec species objects; 
        the right hand side surface reactants.

        Syntax::
            
            getSRHS()

        Arguments:
            None

        Return:
            list<steps.model.Spec>

        """
        return _steps_swig.SReac_getSRHS(*args)

    def setSRHS(*args):
        """
        Set a list of references to steps.model.Spec species objects; 
        the right hand side surface reactants.

        Syntax::

            setSRHS(srhs)
            
        Arguments:
            list<steps.model.Spec> srhs

        Return:
            None

        """
        return _steps_swig.SReac_setSRHS(*args)

    def getORHS(*args):
        """
        Get a list of references to steps.model.Spec species objects; 
        the right hand side outer volume reactants.

        Syntax::

            getORHS()
            
        Arguments:
            None

        Return:
            list<steps.model.Spec>

        """
        return _steps_swig.SReac_getORHS(*args)

    def setORHS(*args):
        """
        Get a list of references to steps.model.Spec species objects; 
        the right hand side outer volume reactants.

        Syntax::

            setORHS(orhs)
            
        Arguments:
            list<steps.model.Spec> orhs

        Return:
            None

        """
        return _steps_swig.SReac_setORHS(*args)

    def getOrder(*args):
        """
        Returns the order of this surface reaction.

        Syntax::

            getOrder()
            
        Arguments:
            None

        Return:
            int

        """
        return _steps_swig.SReac_getOrder(*args)

    def getKcst(*args):
        """
        Get the kinetic reaction rate constant, in s.i. units, 
        where the actual units depend on the order of the surface reaction.

        Syntax::

            getKcst()
            
        Arguments:
            None

        Return:
            float

        """
        return _steps_swig.SReac_getKcst(*args)

    def setKcst(*args):
        """
        Set the kinetic reaction rate constant, in s.i. units, 
        where the actual units depend on the order of the surface reaction.

        Syntax::

            setKcst(kcst)
            
        Arguments:
            float kcst

        Return:
            None

        """
        return _steps_swig.SReac_setKcst(*args)

    def getAllSpecs(*args):
        """
        Returns a list of references to all steps.model.Spec species objects in 
        the surface reaction; that is all reactants and products. No duplicate member 
        is included.

        Syntax::

            getAllSpecs()
            
        Arguments:
            None

        Return:
            list<steps.model.Spec>

        """
        return _steps_swig.SReac_getAllSpecs(*args)

SReac_swigregister = _steps_swig.SReac_swigregister
SReac_swigregister(SReac)

class set_str(_object):
    """Proxy of C++ set_str class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, set_str, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, set_str, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return _steps_swig.set_str_iterator(*args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return _steps_swig.set_str___nonzero__(*args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return _steps_swig.set_str___len__(*args)

    def append(*args):
        """append(self, value_type x)"""
        return _steps_swig.set_str_append(*args)

    def __contains__(*args):
        """__contains__(self, value_type x) -> bool"""
        return _steps_swig.set_str___contains__(*args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return _steps_swig.set_str___getitem__(*args)

    def __init__(self, *args): 
        """
        __init__(self) -> set_str
        __init__(self, set_str ?) -> set_str
        """
        this = _steps_swig.new_set_str(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(*args):
        """empty(self) -> bool"""
        return _steps_swig.set_str_empty(*args)

    def size(*args):
        """size(self) -> size_type"""
        return _steps_swig.set_str_size(*args)

    def clear(*args):
        """clear(self)"""
        return _steps_swig.set_str_clear(*args)

    def swap(*args):
        """swap(self, set_str v)"""
        return _steps_swig.set_str_swap(*args)

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return _steps_swig.set_str_get_allocator(*args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return _steps_swig.set_str_begin(*args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return _steps_swig.set_str_end(*args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return _steps_swig.set_str_rbegin(*args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return _steps_swig.set_str_rend(*args)

    def count(*args):
        """count(self, key_type x) -> size_type"""
        return _steps_swig.set_str_count(*args)

    def erase(*args):
        """
        erase(self, key_type x) -> size_type
        erase(self, iterator pos)
        erase(self, iterator first, iterator last)
        """
        return _steps_swig.set_str_erase(*args)

    def find(*args):
        """find(self, key_type x) -> iterator"""
        return _steps_swig.set_str_find(*args)

    def lower_bound(*args):
        """lower_bound(self, key_type x) -> iterator"""
        return _steps_swig.set_str_lower_bound(*args)

    def upper_bound(*args):
        """upper_bound(self, key_type x) -> iterator"""
        return _steps_swig.set_str_upper_bound(*args)

    def equal_range(*args):
        """equal_range(self, key_type x) -> std::pair<(std::set<(std::string)>::iterator,std::set<(std::string)>::iterator)>"""
        return _steps_swig.set_str_equal_range(*args)

    def insert(*args):
        """insert(self, value_type __x) -> std::pair<(std::set<(std::string)>::iterator,bool)>"""
        return _steps_swig.set_str_insert(*args)

    __swig_destroy__ = _steps_swig.delete_set_str
    __del__ = lambda self : None;
set_str_swigregister = _steps_swig.set_str_swigregister
set_str_swigregister(set_str)

class set_ptc(_object):
    """Proxy of C++ set_ptc class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, set_ptc, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, set_ptc, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return _steps_swig.set_ptc_iterator(*args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return _steps_swig.set_ptc___nonzero__(*args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return _steps_swig.set_ptc___len__(*args)

    def append(*args):
        """append(self, value_type x)"""
        return _steps_swig.set_ptc_append(*args)

    def __contains__(*args):
        """__contains__(self, value_type x) -> bool"""
        return _steps_swig.set_ptc___contains__(*args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return _steps_swig.set_ptc___getitem__(*args)

    def __init__(self, *args): 
        """
        __init__(self) -> set_ptc
        __init__(self, set_ptc ?) -> set_ptc
        """
        this = _steps_swig.new_set_ptc(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(*args):
        """empty(self) -> bool"""
        return _steps_swig.set_ptc_empty(*args)

    def size(*args):
        """size(self) -> size_type"""
        return _steps_swig.set_ptc_size(*args)

    def clear(*args):
        """clear(self)"""
        return _steps_swig.set_ptc_clear(*args)

    def swap(*args):
        """swap(self, set_ptc v)"""
        return _steps_swig.set_ptc_swap(*args)

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return _steps_swig.set_ptc_get_allocator(*args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return _steps_swig.set_ptc_begin(*args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return _steps_swig.set_ptc_end(*args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return _steps_swig.set_ptc_rbegin(*args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return _steps_swig.set_ptc_rend(*args)

    def count(*args):
        """count(self, key_type x) -> size_type"""
        return _steps_swig.set_ptc_count(*args)

    def erase(*args):
        """
        erase(self, key_type x) -> size_type
        erase(self, iterator pos)
        erase(self, iterator first, iterator last)
        """
        return _steps_swig.set_ptc_erase(*args)

    def find(*args):
        """find(self, key_type x) -> iterator"""
        return _steps_swig.set_ptc_find(*args)

    def lower_bound(*args):
        """lower_bound(self, key_type x) -> iterator"""
        return _steps_swig.set_ptc_lower_bound(*args)

    def upper_bound(*args):
        """upper_bound(self, key_type x) -> iterator"""
        return _steps_swig.set_ptc_upper_bound(*args)

    def equal_range(*args):
        """equal_range(self, key_type x) -> std::pair<(std::set<(p.steps::wm::Patch)>::iterator,std::set<(p.steps::wm::Patch)>::iterator)>"""
        return _steps_swig.set_ptc_equal_range(*args)

    def insert(*args):
        """insert(self, value_type __x) -> std::pair<(std::set<(p.steps::wm::Patch)>::iterator,bool)>"""
        return _steps_swig.set_ptc_insert(*args)

    __swig_destroy__ = _steps_swig.delete_set_ptc
    __del__ = lambda self : None;
set_ptc_swigregister = _steps_swig.set_ptc_swigregister
set_ptc_swigregister(set_ptc)

class vector_ptc(_object):
    """Proxy of C++ vector_ptc class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vector_ptc, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vector_ptc, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return _steps_swig.vector_ptc_iterator(*args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return _steps_swig.vector_ptc___nonzero__(*args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return _steps_swig.vector_ptc___len__(*args)

    def pop(*args):
        """pop(self) -> value_type"""
        return _steps_swig.vector_ptc_pop(*args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> vector_ptc"""
        return _steps_swig.vector_ptc___getslice__(*args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, vector_ptc v)"""
        return _steps_swig.vector_ptc___setslice__(*args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _steps_swig.vector_ptc___delslice__(*args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return _steps_swig.vector_ptc___delitem__(*args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return _steps_swig.vector_ptc___getitem__(*args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return _steps_swig.vector_ptc___setitem__(*args)

    def append(*args):
        """append(self, value_type x)"""
        return _steps_swig.vector_ptc_append(*args)

    def empty(*args):
        """empty(self) -> bool"""
        return _steps_swig.vector_ptc_empty(*args)

    def size(*args):
        """size(self) -> size_type"""
        return _steps_swig.vector_ptc_size(*args)

    def clear(*args):
        """clear(self)"""
        return _steps_swig.vector_ptc_clear(*args)

    def swap(*args):
        """swap(self, vector_ptc v)"""
        return _steps_swig.vector_ptc_swap(*args)

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return _steps_swig.vector_ptc_get_allocator(*args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return _steps_swig.vector_ptc_begin(*args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return _steps_swig.vector_ptc_end(*args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_ptc_rbegin(*args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_ptc_rend(*args)

    def pop_back(*args):
        """pop_back(self)"""
        return _steps_swig.vector_ptc_pop_back(*args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _steps_swig.vector_ptc_erase(*args)

    def __init__(self, *args): 
        """
        __init__(self) -> vector_ptc
        __init__(self, vector_ptc ?) -> vector_ptc
        __init__(self, size_type size) -> vector_ptc
        __init__(self, size_type size, value_type value) -> vector_ptc
        """
        this = _steps_swig.new_vector_ptc(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return _steps_swig.vector_ptc_push_back(*args)

    def front(*args):
        """front(self) -> value_type"""
        return _steps_swig.vector_ptc_front(*args)

    def back(*args):
        """back(self) -> value_type"""
        return _steps_swig.vector_ptc_back(*args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return _steps_swig.vector_ptc_assign(*args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _steps_swig.vector_ptc_resize(*args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _steps_swig.vector_ptc_insert(*args)

    def reserve(*args):
        """reserve(self, size_type n)"""
        return _steps_swig.vector_ptc_reserve(*args)

    def capacity(*args):
        """capacity(self) -> size_type"""
        return _steps_swig.vector_ptc_capacity(*args)

    __swig_destroy__ = _steps_swig.delete_vector_ptc
    __del__ = lambda self : None;
vector_ptc_swigregister = _steps_swig.vector_ptc_swigregister
vector_ptc_swigregister(vector_ptc)

class vector_cmp(_object):
    """Proxy of C++ vector_cmp class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vector_cmp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vector_cmp, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return _steps_swig.vector_cmp_iterator(*args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return _steps_swig.vector_cmp___nonzero__(*args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return _steps_swig.vector_cmp___len__(*args)

    def pop(*args):
        """pop(self) -> value_type"""
        return _steps_swig.vector_cmp_pop(*args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> vector_cmp"""
        return _steps_swig.vector_cmp___getslice__(*args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, vector_cmp v)"""
        return _steps_swig.vector_cmp___setslice__(*args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _steps_swig.vector_cmp___delslice__(*args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return _steps_swig.vector_cmp___delitem__(*args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return _steps_swig.vector_cmp___getitem__(*args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return _steps_swig.vector_cmp___setitem__(*args)

    def append(*args):
        """append(self, value_type x)"""
        return _steps_swig.vector_cmp_append(*args)

    def empty(*args):
        """empty(self) -> bool"""
        return _steps_swig.vector_cmp_empty(*args)

    def size(*args):
        """size(self) -> size_type"""
        return _steps_swig.vector_cmp_size(*args)

    def clear(*args):
        """clear(self)"""
        return _steps_swig.vector_cmp_clear(*args)

    def swap(*args):
        """swap(self, vector_cmp v)"""
        return _steps_swig.vector_cmp_swap(*args)

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return _steps_swig.vector_cmp_get_allocator(*args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return _steps_swig.vector_cmp_begin(*args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return _steps_swig.vector_cmp_end(*args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_cmp_rbegin(*args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_cmp_rend(*args)

    def pop_back(*args):
        """pop_back(self)"""
        return _steps_swig.vector_cmp_pop_back(*args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _steps_swig.vector_cmp_erase(*args)

    def __init__(self, *args): 
        """
        __init__(self) -> vector_cmp
        __init__(self, vector_cmp ?) -> vector_cmp
        __init__(self, size_type size) -> vector_cmp
        __init__(self, size_type size, value_type value) -> vector_cmp
        """
        this = _steps_swig.new_vector_cmp(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return _steps_swig.vector_cmp_push_back(*args)

    def front(*args):
        """front(self) -> value_type"""
        return _steps_swig.vector_cmp_front(*args)

    def back(*args):
        """back(self) -> value_type"""
        return _steps_swig.vector_cmp_back(*args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return _steps_swig.vector_cmp_assign(*args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _steps_swig.vector_cmp_resize(*args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _steps_swig.vector_cmp_insert(*args)

    def reserve(*args):
        """reserve(self, size_type n)"""
        return _steps_swig.vector_cmp_reserve(*args)

    def capacity(*args):
        """capacity(self) -> size_type"""
        return _steps_swig.vector_cmp_capacity(*args)

    __swig_destroy__ = _steps_swig.delete_vector_cmp
    __del__ = lambda self : None;
vector_cmp_swigregister = _steps_swig.vector_cmp_swigregister
vector_cmp_swigregister(vector_cmp)

class vector_int(_object):
    """Proxy of C++ vector_int class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vector_int, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vector_int, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return _steps_swig.vector_int_iterator(*args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return _steps_swig.vector_int___nonzero__(*args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return _steps_swig.vector_int___len__(*args)

    def pop(*args):
        """pop(self) -> value_type"""
        return _steps_swig.vector_int_pop(*args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> vector_int"""
        return _steps_swig.vector_int___getslice__(*args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, vector_int v)"""
        return _steps_swig.vector_int___setslice__(*args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _steps_swig.vector_int___delslice__(*args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return _steps_swig.vector_int___delitem__(*args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return _steps_swig.vector_int___getitem__(*args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return _steps_swig.vector_int___setitem__(*args)

    def append(*args):
        """append(self, value_type x)"""
        return _steps_swig.vector_int_append(*args)

    def empty(*args):
        """empty(self) -> bool"""
        return _steps_swig.vector_int_empty(*args)

    def size(*args):
        """size(self) -> size_type"""
        return _steps_swig.vector_int_size(*args)

    def clear(*args):
        """clear(self)"""
        return _steps_swig.vector_int_clear(*args)

    def swap(*args):
        """swap(self, vector_int v)"""
        return _steps_swig.vector_int_swap(*args)

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return _steps_swig.vector_int_get_allocator(*args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return _steps_swig.vector_int_begin(*args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return _steps_swig.vector_int_end(*args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_int_rbegin(*args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_int_rend(*args)

    def pop_back(*args):
        """pop_back(self)"""
        return _steps_swig.vector_int_pop_back(*args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _steps_swig.vector_int_erase(*args)

    def __init__(self, *args): 
        """
        __init__(self) -> vector_int
        __init__(self, vector_int ?) -> vector_int
        __init__(self, size_type size) -> vector_int
        __init__(self, size_type size, value_type value) -> vector_int
        """
        this = _steps_swig.new_vector_int(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return _steps_swig.vector_int_push_back(*args)

    def front(*args):
        """front(self) -> value_type"""
        return _steps_swig.vector_int_front(*args)

    def back(*args):
        """back(self) -> value_type"""
        return _steps_swig.vector_int_back(*args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return _steps_swig.vector_int_assign(*args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _steps_swig.vector_int_resize(*args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _steps_swig.vector_int_insert(*args)

    def reserve(*args):
        """reserve(self, size_type n)"""
        return _steps_swig.vector_int_reserve(*args)

    def capacity(*args):
        """capacity(self) -> size_type"""
        return _steps_swig.vector_int_capacity(*args)

    __swig_destroy__ = _steps_swig.delete_vector_int
    __del__ = lambda self : None;
vector_int_swigregister = _steps_swig.vector_int_swigregister
vector_int_swigregister(vector_int)

class vector_uint(_object):
    """Proxy of C++ vector_uint class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vector_uint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vector_uint, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return _steps_swig.vector_uint_iterator(*args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return _steps_swig.vector_uint___nonzero__(*args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return _steps_swig.vector_uint___len__(*args)

    def pop(*args):
        """pop(self) -> value_type"""
        return _steps_swig.vector_uint_pop(*args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> vector_uint"""
        return _steps_swig.vector_uint___getslice__(*args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, vector_uint v)"""
        return _steps_swig.vector_uint___setslice__(*args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _steps_swig.vector_uint___delslice__(*args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return _steps_swig.vector_uint___delitem__(*args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return _steps_swig.vector_uint___getitem__(*args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return _steps_swig.vector_uint___setitem__(*args)

    def append(*args):
        """append(self, value_type x)"""
        return _steps_swig.vector_uint_append(*args)

    def empty(*args):
        """empty(self) -> bool"""
        return _steps_swig.vector_uint_empty(*args)

    def size(*args):
        """size(self) -> size_type"""
        return _steps_swig.vector_uint_size(*args)

    def clear(*args):
        """clear(self)"""
        return _steps_swig.vector_uint_clear(*args)

    def swap(*args):
        """swap(self, vector_uint v)"""
        return _steps_swig.vector_uint_swap(*args)

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return _steps_swig.vector_uint_get_allocator(*args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return _steps_swig.vector_uint_begin(*args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return _steps_swig.vector_uint_end(*args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_uint_rbegin(*args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_uint_rend(*args)

    def pop_back(*args):
        """pop_back(self)"""
        return _steps_swig.vector_uint_pop_back(*args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _steps_swig.vector_uint_erase(*args)

    def __init__(self, *args): 
        """
        __init__(self) -> vector_uint
        __init__(self, vector_uint ?) -> vector_uint
        __init__(self, size_type size) -> vector_uint
        __init__(self, size_type size, value_type value) -> vector_uint
        """
        this = _steps_swig.new_vector_uint(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return _steps_swig.vector_uint_push_back(*args)

    def front(*args):
        """front(self) -> value_type"""
        return _steps_swig.vector_uint_front(*args)

    def back(*args):
        """back(self) -> value_type"""
        return _steps_swig.vector_uint_back(*args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return _steps_swig.vector_uint_assign(*args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _steps_swig.vector_uint_resize(*args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _steps_swig.vector_uint_insert(*args)

    def reserve(*args):
        """reserve(self, size_type n)"""
        return _steps_swig.vector_uint_reserve(*args)

    def capacity(*args):
        """capacity(self) -> size_type"""
        return _steps_swig.vector_uint_capacity(*args)

    __swig_destroy__ = _steps_swig.delete_vector_uint
    __del__ = lambda self : None;
vector_uint_swigregister = _steps_swig.vector_uint_swigregister
vector_uint_swigregister(vector_uint)

class vector_dbl(_object):
    """Proxy of C++ vector_dbl class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vector_dbl, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vector_dbl, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return _steps_swig.vector_dbl_iterator(*args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return _steps_swig.vector_dbl___nonzero__(*args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return _steps_swig.vector_dbl___len__(*args)

    def pop(*args):
        """pop(self) -> value_type"""
        return _steps_swig.vector_dbl_pop(*args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> vector_dbl"""
        return _steps_swig.vector_dbl___getslice__(*args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, vector_dbl v)"""
        return _steps_swig.vector_dbl___setslice__(*args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _steps_swig.vector_dbl___delslice__(*args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return _steps_swig.vector_dbl___delitem__(*args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return _steps_swig.vector_dbl___getitem__(*args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return _steps_swig.vector_dbl___setitem__(*args)

    def append(*args):
        """append(self, value_type x)"""
        return _steps_swig.vector_dbl_append(*args)

    def empty(*args):
        """empty(self) -> bool"""
        return _steps_swig.vector_dbl_empty(*args)

    def size(*args):
        """size(self) -> size_type"""
        return _steps_swig.vector_dbl_size(*args)

    def clear(*args):
        """clear(self)"""
        return _steps_swig.vector_dbl_clear(*args)

    def swap(*args):
        """swap(self, vector_dbl v)"""
        return _steps_swig.vector_dbl_swap(*args)

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return _steps_swig.vector_dbl_get_allocator(*args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return _steps_swig.vector_dbl_begin(*args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return _steps_swig.vector_dbl_end(*args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_dbl_rbegin(*args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_dbl_rend(*args)

    def pop_back(*args):
        """pop_back(self)"""
        return _steps_swig.vector_dbl_pop_back(*args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _steps_swig.vector_dbl_erase(*args)

    def __init__(self, *args): 
        """
        __init__(self) -> vector_dbl
        __init__(self, vector_dbl ?) -> vector_dbl
        __init__(self, size_type size) -> vector_dbl
        __init__(self, size_type size, value_type value) -> vector_dbl
        """
        this = _steps_swig.new_vector_dbl(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return _steps_swig.vector_dbl_push_back(*args)

    def front(*args):
        """front(self) -> value_type"""
        return _steps_swig.vector_dbl_front(*args)

    def back(*args):
        """back(self) -> value_type"""
        return _steps_swig.vector_dbl_back(*args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return _steps_swig.vector_dbl_assign(*args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _steps_swig.vector_dbl_resize(*args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _steps_swig.vector_dbl_insert(*args)

    def reserve(*args):
        """reserve(self, size_type n)"""
        return _steps_swig.vector_dbl_reserve(*args)

    def capacity(*args):
        """capacity(self) -> size_type"""
        return _steps_swig.vector_dbl_capacity(*args)

    __swig_destroy__ = _steps_swig.delete_vector_dbl
    __del__ = lambda self : None;
vector_dbl_swigregister = _steps_swig.vector_dbl_swigregister
vector_dbl_swigregister(vector_dbl)

class vector_bool(_object):
    """Proxy of C++ vector_bool class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vector_bool, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vector_bool, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return _steps_swig.vector_bool_iterator(*args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return _steps_swig.vector_bool___nonzero__(*args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return _steps_swig.vector_bool___len__(*args)

    def pop(*args):
        """pop(self) -> value_type"""
        return _steps_swig.vector_bool_pop(*args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> vector_bool"""
        return _steps_swig.vector_bool___getslice__(*args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, vector_bool v)"""
        return _steps_swig.vector_bool___setslice__(*args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _steps_swig.vector_bool___delslice__(*args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return _steps_swig.vector_bool___delitem__(*args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return _steps_swig.vector_bool___getitem__(*args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return _steps_swig.vector_bool___setitem__(*args)

    def append(*args):
        """append(self, value_type x)"""
        return _steps_swig.vector_bool_append(*args)

    def empty(*args):
        """empty(self) -> bool"""
        return _steps_swig.vector_bool_empty(*args)

    def size(*args):
        """size(self) -> size_type"""
        return _steps_swig.vector_bool_size(*args)

    def clear(*args):
        """clear(self)"""
        return _steps_swig.vector_bool_clear(*args)

    def swap(*args):
        """swap(self, vector_bool v)"""
        return _steps_swig.vector_bool_swap(*args)

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return _steps_swig.vector_bool_get_allocator(*args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return _steps_swig.vector_bool_begin(*args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return _steps_swig.vector_bool_end(*args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_bool_rbegin(*args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return _steps_swig.vector_bool_rend(*args)

    def pop_back(*args):
        """pop_back(self)"""
        return _steps_swig.vector_bool_pop_back(*args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _steps_swig.vector_bool_erase(*args)

    def __init__(self, *args): 
        """
        __init__(self) -> vector_bool
        __init__(self, vector_bool ?) -> vector_bool
        __init__(self, size_type size) -> vector_bool
        __init__(self, size_type size, value_type value) -> vector_bool
        """
        this = _steps_swig.new_vector_bool(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return _steps_swig.vector_bool_push_back(*args)

    def front(*args):
        """front(self) -> value_type"""
        return _steps_swig.vector_bool_front(*args)

    def back(*args):
        """back(self) -> value_type"""
        return _steps_swig.vector_bool_back(*args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return _steps_swig.vector_bool_assign(*args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _steps_swig.vector_bool_resize(*args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _steps_swig.vector_bool_insert(*args)

    def reserve(*args):
        """reserve(self, size_type n)"""
        return _steps_swig.vector_bool_reserve(*args)

    def capacity(*args):
        """capacity(self) -> size_type"""
        return _steps_swig.vector_bool_capacity(*args)

    __swig_destroy__ = _steps_swig.delete_vector_bool
    __del__ = lambda self : None;
vector_bool_swigregister = _steps_swig.vector_bool_swigregister
vector_bool_swigregister(vector_bool)

class Geom(_object):
    """Proxy of C++ Geom class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Geom, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Geom, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> Geom"""
        this = _steps_swig.new_Geom(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _steps_swig.delete_Geom
    __del__ = lambda self : None;
    def getComp(*args):
        """
        Returns a reference to the steps.model.Comp compartment object with 
        identifier string comp_id (if defined).

        Syntax::

            getComp(comp_id)
            
        Arguments:
            string comp_id
                     
        Return:
            steps.model.Comp

        """
        return _steps_swig.Geom_getComp(*args)

    def delComp(*args):
        """
        Removes the steps.geom.Comp object with identifier string comp_id (if defined) 
        from the geometry container.

        Syntax::

            delComp(comp_id)
            
        Arguments:
            string comp_id
                     
        Return:
            None

        """
        return _steps_swig.Geom_delComp(*args)

    def getAllComps(*args):
        """
        Returns a list of references to all steps.geom.Comp compartment objects in the 
        geometry container.

        Syntax::

            getAllComps()
            
        Arguments:
            None
                     
        Return:
            list<steps.geom.Comp>

        """
        return _steps_swig.Geom_getAllComps(*args)

    def getPatch(*args):
        """
        Removes the steps.geom.Patch object with identifier string patch_id (if defined) 
        from the geometry container.

        Syntax::

            getPatch(patch_id)
            
        Arguments:
            string patch_id
                     
        Return:
            steps.geom.Patch

        """
        return _steps_swig.Geom_getPatch(*args)

    def delPatch(*args):
        """
        Removes the steps.geom.Patch object with identifier string patch_id (if defined) 
        from the geometry container.

        Syntax::

            delPatch(patch_id)
            
        Arguments:
            string patch_id
                     
        Return:
            None

        """
        return _steps_swig.Geom_delPatch(*args)

    def getAllPatches(*args):
        """
        Returns a list of references to all steps.geom.Patch patch objects in the 
        geometry container.

        Syntax::

            getAllPatches()
            
        Arguments:
            None
                     
        Return:
            list<steps.geom.Patch>

        """
        return _steps_swig.Geom_getAllPatches(*args)

Geom_swigregister = _steps_swig.Geom_swigregister
Geom_swigregister(Geom)

class Patch(_object):
    """Proxy of C++ Patch class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Patch, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Patch, name)
    __repr__ = _swig_repr
    def __init__(self, *args, **kwargs): 
        """
        __init__(self, string id, Geom container, Comp icomp, Comp ocomp=0, 
            double area=0.0) -> Patch
        """
        this = _steps_swig.new_Patch(*args, **kwargs)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _steps_swig.delete_Patch
    __del__ = lambda self : None;
    def getID(*args):
        """
        Get the identifier string of the patch.

        Syntax::

            getID()
            
        Arguments:
            None
                     
        Return:
            string

        """
        return _steps_swig.Patch_getID(*args)

    def setID(*args):
        """
        Set the identifier string of the patch.

        Syntax::

            setID(name)
            
        Arguments:
            string name
                     
        Return:
            None

        """
        return _steps_swig.Patch_setID(*args)

    def getContainer(*args):
        """
        Returns a reference to the parent steps.geom.Geom container object.

        Syntax::

            getContainer()
            
        Arguments:
            None
                     
        Return:
            steps.geom.Geom

        """
        return _steps_swig.Patch_getContainer(*args)

    def getArea(*args):
        """
        Get the area of the patch (in m^2).

        Syntax::

            getArea()

        Arguments:
            None
                     
        Return:
            float

        """
        return _steps_swig.Patch_getArea(*args)

    def setArea(*args):
        """
        Set the area of the patch (in m^2).

        Syntax::

            setArea(area)
            
        Arguments:
            float area
                     
        Return:
            None

        """
        return _steps_swig.Patch_setArea(*args)

    def addSurfsys(*args):
        """
        Add surface system identifier string surfsys_id to the patch object.

        Syntax::

            addSurfsys(surfsys_id)
            
        Arguments:
            string surfsys_id
                     
        Return:
            None

        """
        return _steps_swig.Patch_addSurfsys(*args)

    def getSurfsys(*args):
        """
        Returns a list of the surface system identifier strings which have 
        been added to the patch.

        Syntax::

            getSurfsys()
            
        Arguments:
            None
                     
        Return:
            list<string>

        """
        return _steps_swig.Patch_getSurfsys(*args)

    def delSurfsys(*args):
        """
        Removes surface system identifier string surfsys_id from this patch.

        Syntax::

            delSurfsys(surfsys_id)

        Arguments:
            string surfsys_id
                     
        Return:
            None

        """
        return _steps_swig.Patch_delSurfsys(*args)

    def getIComp(*args):
        """
        Returns a reference to the steps.geom.Comp compartment object representing
        the inner compartment.

        Syntax::

            getIComp()

        Arguments:
            None
                     
        Return:
            steps.geom.Comp

        """
        return _steps_swig.Patch_getIComp(*args)

    def getOComp(*args):
        """
        Returns a reference to the steps.geom.Comp compartment object representing
        the outer compartment.

        Syntax::
            
            getOComp()

        Arguments:
            None
                     
        Return:
            steps.geom.Comp

        """
        return _steps_swig.Patch_getOComp(*args)

Patch_swigregister = _steps_swig.Patch_swigregister
Patch_swigregister(Patch)

class Comp(_object):
    """Proxy of C++ Comp class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Comp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Comp, name)
    __repr__ = _swig_repr
    def __init__(self, *args, **kwargs): 
        """__init__(self, string id, Geom container, double vol=0.0) -> Comp"""
        this = _steps_swig.new_Comp(*args, **kwargs)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _steps_swig.delete_Comp
    __del__ = lambda self : None;
    def getID(*args):
        """
        Get the identifier string of the compartment.

        Syntax::

            getID()

        Arguments:
            None
                     
        Return:
            string

        """
        return _steps_swig.Comp_getID(*args)

    def setID(*args):
        """
        Set the identifier string of the compartment.

        Syntax::

            setID(name)

        Arguments:
            string name
                     
        Return:
            None

        """
        return _steps_swig.Comp_setID(*args)

    def getContainer(*args):
        """
        Returns a reference to the parent steps.geom.Geom container object.

        Syntax::

            getContainer()

        Arguments:
            None
                     
        Return:
            steps.geom.Geom

        """
        return _steps_swig.Comp_getContainer(*args)

    def getVol(*args):
        """
        Get the volume of the compartment (in m^3).

        Syntax::

            getVol()
            
        Arguments:
            None
                     
        Return:
            float

        """
        return _steps_swig.Comp_getVol(*args)

    def setVol(*args):
        """
        Set the volume of the compartment (in m^3).

        Syntax::

            setVol(vol)

        Arguments:
            float vol
                     
        Return:
            None

        """
        return _steps_swig.Comp_setVol(*args)

    def addVolsys(*args):
        """
        Add volume system identifier string volsys_id to the compartment object.

        Syntax::

            addVolsys(volsys_id)

        Arguments:
            string volsys_id
                     
        Return:
            None

        """
        return _steps_swig.Comp_addVolsys(*args)

    def getVolsys(*args):
        """
        Returns a list of the volume system identifier strings which have been 
        added to the compartment.

        Syntax::

            getVolsys()

        Arguments:
            None
                     
        Return:
            list<string>

        """
        return _steps_swig.Comp_getVolsys(*args)

    def delVolsys(*args):
        """
        Removes volume system identifier string volsys_id from this compartment.

        Syntax::

            delVolsys(volsys_id)

        Arguments:
            string volsys_id
                     
        Return:
            None

        """
        return _steps_swig.Comp_delVolsys(*args)

    def getIPatches(*args):
        """
        Returns a list of references to steps.geom.Patch patch objects: 
        the 'inner' patches.

        Syntax::

            getIPatches()

        Arguments:
            None
                     
        Return:
            list<steps.geom.Patch>

        """
        return _steps_swig.Comp_getIPatches(*args)

    def getOPatches(*args):
        """
        Returns a list of references to steps.geom.Patch patch objects: 
        the 'outer' patches.

        Syntax::

            getOPatches()

        Arguments:
            None
                     
        Return:
            list<steps.geom.Patch>

        """
        return _steps_swig.Comp_getOPatches(*args)

Comp_swigregister = _steps_swig.Comp_swigregister
Comp_swigregister(Comp)

class Tetmesh(Geom):
    """Proxy of C++ Tetmesh class"""
    __swig_setmethods__ = {}
    for _s in [Geom]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Tetmesh, name, value)
    __swig_getmethods__ = {}
    for _s in [Geom]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Tetmesh, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        Returns a list of references to all steps.geom.Patch patch objects in the 
        geometry container.

        Syntax::

            getAllPatches()
            
        Arguments:
            None
                     
        Return:
            list<steps.geom.Patch>


        Returns a list of references to all steps.geom.Patch patch objects in the 
        geometry container.

        Syntax::

            getAllPatches()
            
        Arguments:
            None
                     
        Return:
            list<steps.geom.Patch>


        Returns a list of references to all steps.geom.Patch patch objects in the 
        geometry container.

        Syntax::

            getAllPatches()
            
        Arguments:
            None
                     
        Return:
            list<steps.geom.Patch>


        Returns a list of references to all steps.geom.Patch patch objects in the 
        geometry container.

        Syntax::

            getAllPatches()
            
        Arguments:
            None
                     
        Return:
            list<steps.geom.Patch>

        """
        this = _steps_swig.new_Tetmesh(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _steps_swig.delete_Tetmesh
    __del__ = lambda self : None;
    def setVertex(*args):
        """
        Set a vertex with index vidx to coordinates x, y, z. Should be used nverts 
        number of times to supply all vertex information if the second constructor 
        is used. Cannot be called after setup() has been called.

        Syntax::

            setVertex(vidx, x, y, z)

        Arguments:
            * uint vidx
            * float x
            * float y
            * float z
                     
        Return:
            None

        """
        return _steps_swig.Tetmesh_setVertex(*args)

    def setTri(*args):
        """
        Set the triangle with index tidx formed by vertices vidx0, vidx1, vidx2. 
        Should be called ntris number of times to supply triangle information if the 
        second constructor is used. Cannot be called after setup() has been called.

        Syntax::

            setTri(tidx, vidx0, vidx1, vidx2)
                        
        Arguments:
            * uint tidx
            * uint vidx0
            * uint vidx1
            * uint vidx2
                     
        Return:
            None

        """
        return _steps_swig.Tetmesh_setTri(*args)

    def setTet(*args):
        """
        Set the tetrahedron with index tidx formed by vertices vidx0, vidx1, 
        vidx2, vidx3. Should be called ntets number of times to supply tetrahedron 
        information if the second constructor is used. Cannot be called after setup() 
        has been called. 

        Syntax::

            setTet(tidx, vidx0, vidx1, vidx2, vidx3)

        Arguments:
            * uint tidx
            * uint vidx0
            * uint vidx1
            * uint vidx2
            * uint vidx3
                     
        Return:
            None

        """
        return _steps_swig.Tetmesh_setTet(*args)

    def setup(*args):
        """
        Setup the Tetmesh object by computing the auxiliary data. This method should 
        be called when the second constructor is used and all vertex, tetrahedron and 
        triangle information has been supplied with the set methods. The first constructor 
        calls this method internally, so setup does not have to be called when using the 
        first constructor.

        Syntax::

            setup()

        Arguments:
            None
                     
        Return:
            None

        """
        return _steps_swig.Tetmesh_setup(*args)

    def isSetupDone(*args):
        """
        Check if setup() has been called, either internally by the first constructor, 
        or by the user if the second constructor was used.

        Syntax::

            isSetupDone()

        Arguments:
            None
                     
        Return:
            True if setup is done.
            False if setup is not done.

        """
        return _steps_swig.Tetmesh_isSetupDone(*args)

    def getVertex(*args):
        """
        Returns the coordinates of vertex with index vidx in the container.

        Syntax::

            getVertex(vidx)

        Arguments:
            uint vidx
                     
        Return:
            list<float, length = 3>

        """
        return _steps_swig.Tetmesh_getVertex(*args)

    def countVertices(*args):
        """
        Returns the total number of vertices in the mesh.

        Syntax::

            countVertices()

        Arguments:
            None
                     
        Return:
            uint

        """
        return _steps_swig.Tetmesh_countVertices(*args)

    def getTri(*args):
        """
        Returns the triangle with index tidx in the container by its three vertex indices.

        Syntax::

            getTri(tidx)

        Arguments:
            uint tidx
                     
        Return:
            list<uint, length = 3>

        """
        return _steps_swig.Tetmesh_getTri(*args)

    def countTris(*args):
        """
        Returns the total number of triangles in the mesh.

        Syntax::

            countTris()

        Arguments:
            None
                     
        Return:
            uint

        """
        return _steps_swig.Tetmesh_countTris(*args)

    def getTriArea(*args):
        """
        Returns the area of the triangle with index tidx.

        Syntax::

            getTriArea(tidx)

        Arguments:
            uint tidx
                     
        Return:
            float

        """
        return _steps_swig.Tetmesh_getTriArea(*args)

    def getTriBarycenter(*args):
        """
        Returns the Cartesian coordinates of the barycenter of triangle with index tidx.

        Syntax::

            getTriBarycenter(tidx)

        Arguments:
            uint tidx
                     
        Return:
            list<float, length = 3>

        """
        return _steps_swig.Tetmesh_getTriBarycenter(*args)

    def getTetQualityRER(*args):
        """
        Returns the radius-edge-ratio (a quality measurement) of tetrahedron with index tidx.

        Syntax::
            
            getTetQualityRER(tidx)

        Arguments:
            uint tidx
                     
        Return:
            float

        """
        return _steps_swig.Tetmesh_getTetQualityRER(*args)

    def getTriNorm(*args):
        """
        Returns the normal vector of the triangle with index tidx.

        Syntax::

            getTriNorm(tidx)

        Arguments:
            uint tidx
                     
        Return:
            list<float, length = 3>

        """
        return _steps_swig.Tetmesh_getTriNorm(*args)

    def getTriPatch(*args):
        """
        Returns a reference to a step.geom.TmPatch object: the patch which triangle 
        with index tidx belongs to. Returns None if triangle not assigned to a patch.

        Syntax::

            getTriPatch(tidx)

        Arguments:
            uint tidx
                     
        Return:
            steps.geom.TmPatch

        """
        return _steps_swig.Tetmesh_getTriPatch(*args)

    def getTriDiffBoundary(*args):
        """
        Returns a reference to a step.geom.Diffboundary object: the diffusion boundary triangle 
        with index tidx belongs to. Returns None if triangle not assigned to a diffusion boundary.
                     
        Syntax::
                     
            getTriDiffBoundary(tidx)
                     
        Arguments:
            uint tidx
                     
        Return:
            steps.geom.DiffBoundary

        """
        return _steps_swig.Tetmesh_getTriDiffBoundary(*args)

    def getTriTetNeighb(*args):
        """
        Returns the indices of the two neighbouring tetrahedrons of triangle with 
        index tidx. An index of -1 indicates no neighbour (triangle is on the mesh border). 

        Syntax::

            getTriTetNeighb(tidx)

        Arguments:
            uint tidx
                     
        Return:
            list<int, length = 2>

        """
        return _steps_swig.Tetmesh_getTriTetNeighb(*args)

    def getTriBoundary(*args):
        """
        Returns a list of triangles that form the mesh boundary.
        Support function for steps.utilities.visual.

        Syntax::

            getTriBoundary()

        Arguments:
            None
                     
        Return:
            list<int>
            
        Status: Obsolete. rename as getTriSurfs()

        """
        return _steps_swig.Tetmesh_getTriBoundary(*args)

    def getSurfTris(*args):
        """
        Returns a list of triangles that form the mesh boundary.
        Support function for steps.utilities.visual.

        Syntax::

            getSurfTris()

        Arguments:
            None
                     
        Return:
            list<unsigned int>

        """
        return _steps_swig.Tetmesh_getSurfTris(*args)

    def getTet(*args):
        """
        Returns the tetrahedron with index tidx in the container by its four vertex indices.

        Syntax::
            getTet(tidx)
            
        Arguments:
            uint tidx
                     
        Return:
            list<uint, length = 4>

        """
        return _steps_swig.Tetmesh_getTet(*args)

    def countTets(*args):
        """
        Returns the total number of tetrahedrons in the mesh.

        Syntax::

            countTets()

        Arguments:
            None
                     
        Return:
            uint

        """
        return _steps_swig.Tetmesh_countTets(*args)

    def getTetVol(*args):
        """
        Returns the volume of the tetrahedron with index tidx.

        Syntax::

            getTetVol(tidx)

        Arguments:
            uint tidx
                     
        Return:
            float

        """
        return _steps_swig.Tetmesh_getTetVol(*args)

    def getTetBarycenter(*args):
        """
        Returns the barycenter of the tetrahedron with index tidx.

        Syntax::

            getTetBarycenter(tidx)

        Arguments:
            uint tidx
                     
        Return:
            list<float, length = 3>

        """
        return _steps_swig.Tetmesh_getTetBarycenter(*args)

    def getTetComp(*args):
        """
        Returns a reference to a steps.geom.Comp object: the compartment which 
        tetrahedron with index tidx belongs to. Returns None if tetrahedron not 
        assigned to a compartment.

        Syntax::

            getTetComp(tidx)

        Arguments:
            uint tidx
                     
        Return:
            steps.geom.TmComp

        """
        return _steps_swig.Tetmesh_getTetComp(*args)

    def getTetTriNeighb(*args):
        """
        Returns the indices of the four neighbouring triangles of tetrahedron with index tidx.

        Syntax::

            getTetTriNeighb(tidx)

        Arguments:
            uint tidx
                     
        Return:
            list<uint, length = 4>

        """
        return _steps_swig.Tetmesh_getTetTriNeighb(*args)

    def getTetTetNeighb(*args):
        """
        Returns the indices of the four neighbouring tetrahedrons of tetrahedron with index tidx. 
        An index of -1 indicates no neighbour (tetrahedron is on the mesh border).

        Syntax::

            getTetTetNeighb(tidx)

        Arguments:
            uint tidx
                     
        Return:
            list<int, length = 4>

        """
        return _steps_swig.Tetmesh_getTetTetNeighb(*args)

    def findTetByPoint(*args):
        """
        Returns the index of the tetrahedron which encompasses a given point 
        p (given in Cartesian coordinates x,y,z). Returns -1 if p is a position 
        outside the mesh.

        Syntax::

            findTetByPoint(p)

        Arguments:
            list<float, length = 3> p
                     
        Return:
            int

        """
        return _steps_swig.Tetmesh_findTetByPoint(*args)

    def getBoundMin(*args):
        """
        Returns the minimal Cartesian coordinate of the rectangular bounding box of the mesh. 

        Syntax::

            getBoundMin()

        Arguments:
            None
                     
        Return:
            list<float, length = 3>

        """
        return _steps_swig.Tetmesh_getBoundMin(*args)

    def getBoundMax(*args):
        """
        Returns the maximal Cartesian coordinate of the rectangular bounding box of the mesh. 

        Syntax::

            getBoundMax()

        Arguments:
            None
                     
        Return:
            list<float, length = 3>

        """
        return _steps_swig.Tetmesh_getBoundMax(*args)

    def getMeshVolume(*args):
        """
        Returns the total volume of the mesh. 

        Syntax::

            getMeshVolume()

        Arguments:
            None
                     
        Return:
            float

        """
        return _steps_swig.Tetmesh_getMeshVolume(*args)

Tetmesh_swigregister = _steps_swig.Tetmesh_swigregister
Tetmesh_swigregister(Tetmesh)

class TmComp(Comp):
    """Proxy of C++ TmComp class"""
    __swig_setmethods__ = {}
    for _s in [Comp]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TmComp, name, value)
    __swig_getmethods__ = {}
    for _s in [Comp]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TmComp, name)
    __repr__ = _swig_repr
    def __init__(self, *args, **kwargs): 
        """
        Returns a list of references to steps.geom.Patch patch objects: 
        the 'outer' patches.

        Syntax::

            getOPatches()

        Arguments:
            None
                     
        Return:
            list<steps.geom.Patch>

        """
        this = _steps_swig.new_TmComp(*args, **kwargs)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _steps_swig.delete_TmComp
    __del__ = lambda self : None;
    def setVol(*args):
        """Obsolete"""
        return _steps_swig.TmComp_setVol(*args)

    def getAllTetIndices(*args):
        """
        Returns a list of indices of all tetrahedrons assigned to the compartment. 

        Syntax::

            getAllTetIndices()

        Arguments:
            None
                     
        Return:
            list<uint>

        """
        return _steps_swig.TmComp_getAllTetIndices(*args)

    def countTets(*args):
        """
        Returns the number of tetrahedrons assigned to the compartment. 

        Syntax::

            countTets()

        Arguments:
            None
                     
        Return:
            uint

        """
        return _steps_swig.TmComp_countTets(*args)

    def isTetInside(*args):
        """
        Returns a list of Booleans describing if tetrahedrons tets are 
        assigned to the compartment.

        Syntax::
            
            isTetInside(tets)

        Arguments:
            list<uint> tets
                     
        Return:
            list<bool, length = length(tets)>

        """
        return _steps_swig.TmComp_isTetInside(*args)

    def getBoundMin(*args):
        """
        Returns the minimal Cartesian coordinate of the rectangular bounding box 
        of the compartment. 

        Syntax::

            getBoundMin()

        Arguments:
            None
                     
        Return:
            list<float, length = 3>

        """
        return _steps_swig.TmComp_getBoundMin(*args)

    def getBoundMax(*args):
        """
        Returns the maximal Cartesian coordinate of the rectangular bounding box 
        of the compartment. 

        Syntax::

            getBoundMax()

        Arguments:
            None
                     
        Return:
            list<float, length = 3>

        """
        return _steps_swig.TmComp_getBoundMax(*args)

TmComp_swigregister = _steps_swig.TmComp_swigregister
TmComp_swigregister(TmComp)

class TmPatch(Patch):
    """Proxy of C++ TmPatch class"""
    __swig_setmethods__ = {}
    for _s in [Patch]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TmPatch, name, value)
    __swig_getmethods__ = {}
    for _s in [Patch]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TmPatch, name)
    __repr__ = _swig_repr
    def __init__(self, *args, **kwargs): 
        """
        Returns a reference to the steps.geom.Comp compartment object representing
        the outer compartment.

        Syntax::
            
            getOComp()

        Arguments:
            None
                     
        Return:
            steps.geom.Comp

        """
        this = _steps_swig.new_TmPatch(*args, **kwargs)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _steps_swig.delete_TmPatch
    __del__ = lambda self : None;
    def setArea(*args):
        """Obsolete"""
        return _steps_swig.TmPatch_setArea(*args)

    def getAllTriIndices(*args):
        """
        Returns a list of indices of all triangles assigned to the patch.

        Syntax::

            getAllTriIndices()

        Arguments:
            None
                     
        Return:
            list<uint>

        """
        return _steps_swig.TmPatch_getAllTriIndices(*args)

    def isTriInside(*args):
        """
        Returns a list of Booleans describing if triangles tris are 
        assigned to the patch.

        Syntax::

            isTriInside(tris)

        Arguments:
            list<uint> tris
                     
        Return:
            list<bool, length = length(tris)>

        """
        return _steps_swig.TmPatch_isTriInside(*args)

TmPatch_swigregister = _steps_swig.TmPatch_swigregister
TmPatch_swigregister(TmPatch)

class DiffBoundary(_object):
    """Proxy of C++ DiffBoundary class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DiffBoundary, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DiffBoundary, name)
    __repr__ = _swig_repr
    def __init__(self, *args, **kwargs): 
        """__init__(self, string id, Tetmesh container, vector_uint tris) -> DiffBoundary"""
        this = _steps_swig.new_DiffBoundary(*args, **kwargs)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _steps_swig.delete_DiffBoundary
    __del__ = lambda self : None;
    def getID(*args):
        """
        Get the identifier string of the diffusion boundary.

        Syntax::

            getID()

        Arguments:
            None
                     
        Return:
            string

        """
        return _steps_swig.DiffBoundary_getID(*args)

    def setID(*args):
        """
        Set the identifier string of the diffusion boundary.

        Syntax::

            setID(name)

        Arguments:
            string name

        Return:
            None

        """
        return _steps_swig.DiffBoundary_setID(*args)

    def getContainer(*args):
        """
        Returns a reference to the parent steps.geom.Tetmesh container object.

        Syntax::

            getContainer()

        Arguments:
            None

        Return:
            steps.geom.Tetmesh

        """
        return _steps_swig.DiffBoundary_getContainer(*args)

    def getComps(*args):
        """
        Returns a list of the two compartments this diffusion boundary connects.
                     
        Syntax::
                     
            getComps()
                     
        Arguments:
            None
                     
        Return:
            list<steps::wm::Comp, length = 2>

        """
        return _steps_swig.DiffBoundary_getComps(*args)

    def isTriInside(*args):
        """
        Returns a list of Booleans describing if triangles tris are 
        assigned to the Diffusion Boundary.
                     
        Syntax::
                     
            isTriInside(tris)
                     
        Arguments:
            list<uint> tris
                     
        Return:
            list<bool, length = length(tris)>

        """
        return _steps_swig.DiffBoundary_isTriInside(*args)

    def getAllTriIndices(*args):
        """
        Returns a list of indices of all triangles assigned to the patch.
                     
        Syntax::
                     
            getAllTriIndices()
                     
        Arguments:
            None
                     
        Return:
            list<uint>

        """
        return _steps_swig.DiffBoundary_getAllTriIndices(*args)

DiffBoundary_swigregister = _steps_swig.DiffBoundary_swigregister
DiffBoundary_swigregister(DiffBoundary)

class RNG(_object):
    """
    Proxy of C++ random number generator.


    """
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RNG, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RNG, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _steps_swig.delete_RNG
    __del__ = lambda self : None;
    def initialize(*args):
        """
        Initialize the random number generator with given seed value.


        Syntax::
            
            initialize(seed)
            
        Arguments:
            uint seed

        Return:
            None

        """
        return _steps_swig.RNG_initialize(*args)

    def get(*args):
        """
        Initialize the random number generator with given seed value.


        Syntax::
            
            initialize(seed)
            
        Arguments:
            uint seed

        Return:
            None

        """
        return _steps_swig.RNG_get(*args)

    def getUnfII(*args):
        """
        Initialize the random number generator with given seed value.


        Syntax::
            
            initialize(seed)
            
        Arguments:
            uint seed

        Return:
            None

        """
        return _steps_swig.RNG_getUnfII(*args)

    def getUnfIE(*args):
        """
        Initialize the random number generator with given seed value.


        Syntax::
            
            initialize(seed)
            
        Arguments:
            uint seed

        Return:
            None

        """
        return _steps_swig.RNG_getUnfIE(*args)

    def getUnfEE(*args):
        """
        Initialize the random number generator with given seed value.


        Syntax::
            
            initialize(seed)
            
        Arguments:
            uint seed

        Return:
            None

        """
        return _steps_swig.RNG_getUnfEE(*args)

    def getUnfIE53(*args):
        """
        Initialize the random number generator with given seed value.


        Syntax::
            
            initialize(seed)
            
        Arguments:
            uint seed

        Return:
            None

        """
        return _steps_swig.RNG_getUnfIE53(*args)

    def getStdExp(*args):
        """
        Initialize the random number generator with given seed value.


        Syntax::
            
            initialize(seed)
            
        Arguments:
            uint seed

        Return:
            None

        """
        return _steps_swig.RNG_getStdExp(*args)

    def getExp(*args):
        """
        Initialize the random number generator with given seed value.


        Syntax::
            
            initialize(seed)
            
        Arguments:
            uint seed

        Return:
            None

        """
        return _steps_swig.RNG_getExp(*args)

    def getPsn(*args):
        """
        Initialize the random number generator with given seed value.


        Syntax::
            
            initialize(seed)
            
        Arguments:
            uint seed

        Return:
            None

        """
        return _steps_swig.RNG_getPsn(*args)

    def getStdNrm(*args):
        """
        Initialize the random number generator with given seed value.


        Syntax::
            
            initialize(seed)
            
        Arguments:
            uint seed

        Return:
            None

        """
        return _steps_swig.RNG_getStdNrm(*args)

RNG_swigregister = _steps_swig.RNG_swigregister
RNG_swigregister(RNG)


def create_mt19937(*args):
  """
    Equivalent to: create('mt19937', buffer_size)

    Syntax::

        create_mt19937(buffer_size)
        
    Arguments:
        uint buffer_size

    Return:
        steps.rng.RNG

    """
  return _steps_swig.create_mt19937(*args)

def create(*args):
  """
    Creates and returns a reference to a steps.rng.RNG random number generator object, 
    which is specified by type and pre-allocates a buffer list with size of buffer_size.

    Syntax::
        
        create(type, buffer_size)

    Arguments:
        * string type
        * uint buffer_size

    Return:
        steps.rng.RNG

    """
  return _steps_swig.create(*args)
class API(_object):
    """Proxy of C++ API class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, API, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, API, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _steps_swig.delete_API
    __del__ = lambda self : None;
    def getSolverName(*args):
        """
        Returns a string of the solver's name.

        Syntax::
            
            getSolverName()
            
        Arguments:
            None

        Return:
            string

        """
        return _steps_swig.API_getSolverName(*args)

    def getSolverDesc(*args):
        """
        Returns a string giving a short description of the solver.

        Syntax::
            
            getSolverDesc()
            
        Arguments:
            None

        Return:
            string

        """
        return _steps_swig.API_getSolverDesc(*args)

    def getSolverAuthors(*args):
        """
        Returns a string of the solver authors names.

        Syntax::
            
            getSolverAuthors()
            
        Arguments:
            None

        Return:
            string

        """
        return _steps_swig.API_getSolverAuthors(*args)

    def getSolverEmail(*args):
        """
        Returns a string giving the author's email address.

        Syntax::
            
            getSolverEmail()
            
        Arguments:
            None

        Return:
            string

        """
        return _steps_swig.API_getSolverEmail(*args)

    def reset(*args):
        """
        Reset the simulation to the state the solver was initialised to. 
        Typically, this resets all concentrations of all chemical species in 
        all elements (whether compartments and patches in a well-mixed solver 
        or tetrahedrons and triangles in a mesh-based solver) to zero, 
        resets the simulation time to zero and resets reaction (and diffusion) 
        rates to the default values described in the steps.model objects. 
        All reaction (and diffusion) rules are reset to active and all 
        compartment volumes and patch areas are reset to default values 
        described in steps.geom objects (for well-mixed solvers). 
        Usually, this method should be called before starting each simulation iteration.

        Syntax::
            
            reset()
            
        Arguments:
            None

        Return:
            None

        """
        return _steps_swig.API_reset(*args)

    def checkpoint(*args):
        """
        Checkpoint the simulation state to a file.

        Syntax::
            
            checkpoint(file_name)
            
        Arguments:
            string file_name

        Return:
            None

        """
        return _steps_swig.API_checkpoint(*args)

    def restore(*args):
        """
        Restore the simulation state from a file.

        Syntax::
            
            restore(file_name)
            
        Arguments:
            string file_name

        Return:
            None

        """
        return _steps_swig.API_restore(*args)

    def run(*args):
        """
        Advance the simulation until endtime (given in seconds) is reached. 
        The endtime must be larger or equal to the current simulation time.

        Syntax::
            
            run(endtime)
            
        Arguments:
            float endtime

        Return:
            None

        """
        return _steps_swig.API_run(*args)

    def getTime(*args):
        """
        Returns the current simulation time in seconds.

        Syntax::
            
            getTime()
            
        Arguments:
            None

        Return:
            float

        """
        return _steps_swig.API_getTime(*args)

    def advance(*args):
        """
        Advance the simulation for secs seconds. 

        Syntax::
            
            advance(adv)
            
        Arguments:
            float adv

        Return:
            None

        """
        return _steps_swig.API_advance(*args)

    def step(*args):
        """
        Advance the simulation for one 'step'. In stochastic solvers this is one 
        'realization' of the Gillespie SSA (one reaction 'event'). 
        In numerical solvers (currently Wmrk4) this is one time-step, with the 
        stepsize defined with the setDT method.

        Syntax::
            
            step()
            
        Arguments:
            None

        Return:
            None

        """
        return _steps_swig.API_step(*args)

    def setRk4DT(*args):
        """
        Set the stepsize for numerical solvers. Must be called before running a 
        simulation with these solvers (currently Wmrk4) since there is no default 
        stepsize. The deterministic solver Wmrk4 implements a fixed stepsize 
        (i.e. not adaptive), although the stepsize can be altered at any point 
        during the simulation with this method.

        Syntax::
            
            setRk4DT(dt)
            
        Arguments:
            float dt

        Return:
            None

        """
        return _steps_swig.API_setRk4DT(*args)

    def setDT(*args):
        """
        Set the stepsize for numerical solvers. Superceded by setRk4DT, but
        Included for backwards compatability.
         
        Syntax::
         
            setDT(dt)
         
        Arguments:
            float dt
         
        Return:
            None

        """
        return _steps_swig.API_setDT(*args)

    def getRk4DT(*args):
        """
        Returns the stepsize for numerical solvers.

        Syntax::

            getRk4DT()

        Arguments:
            None

        Return:
            float

        """
        return _steps_swig.API_getRk4DT(*args)

    def getDT(*args):
        """
        Returns the stepsize for numerical solvers.
        Superceded by getRk4DT, but included for backwards compatibility.

        Syntax::
            
            getDT()
            
        Arguments:
            None

        Return:
            float

        """
        return _steps_swig.API_getDT(*args)

    def setTime(*args):
        """
        Set the current simulation time.

        Syntax::
            
            setTime(time)
            
        Arguments:
            folat time

        Return:
            None

        """
        return _steps_swig.API_setTime(*args)

    def getA0(*args):
        """
        Returns the total propensity of the current simulation state 
        (the total propensity multiplied by an infinitesimally small 
        time dt gives the probability that a reaction will occur in that dt). 
        For Tetexact this includes the propensity from the extension of the SSA 
        for diffusive flux between tetrahedral elements in the mesh.

        Syntax::
            
            getA0()
            
        Arguments:
            None

        Return:
            float

        """
        return _steps_swig.API_getA0(*args)

    def getNSteps(*args):
        """
        Return the number of 'realizations' of the SSA, the number of reaction 
        (and diffusion) events in stochastic solvers.

        Syntax::
            
            getNSteps()
            
        Arguments:
            None

        Return:
            uint

        """
        return _steps_swig.API_getNSteps(*args)

    def setNSteps(*args):
        """
        Set the number of 'realizations' of the SSA, the number of reaction 
        (and diffusion) events in stochastic solvers.

        Syntax::
            
            setNSteps(nsteps)
            
        Arguments:
            uint nsteps

        Return:
            None

        """
        return _steps_swig.API_setNSteps(*args)

    def getCompVol(*args):
        """
        Returns the volume of compartment with identifier string comp (in m^3).

        Syntax::
            
            getCompVol(comp)
            
        Arguments:
            string comp

        Return:
            float

        """
        return _steps_swig.API_getCompVol(*args)

    def setCompVol(*args):
        """
        Set the volume of compartment with identifier string comp (in m^3).

        Syntax::
            
            setCompVol(comp, vol)
            
        Arguments:
            * string comp
            * float vol

        Return:
            None

        """
        return _steps_swig.API_setCompVol(*args)

    def getCompCount(*args):
        """
        Returns the number of molecules of a species with identifier string spec 
        in compartment with identifier string comp.

        In a mesh-based simulation (i.e. Tetexact) this is the combined count from 
        all tetrahedral elements in the compartment.

        Syntax::
            
            getCompCount(comp, spec)
            
        Arguments:
            * string comp
            * string spec

        Return:
            float

        """
        return _steps_swig.API_getCompCount(*args)

    def setCompCount(*args):
        """
        Set the number of molecules of a species with identifier string spec 
        in compartment with identifier string comp.

        In a mesh-based simulation (i.e. Tetexact) this is the combined count from 
        all tetrahedral elements in the compartment.

        Syntax::
            
            setCompCount(comp, spec, nspec)
            
        Arguments:
            * string comp
            * string spec
            * uint nspec

        Return:
            None

        """
        return _steps_swig.API_setCompCount(*args)

    def getCompAmount(*args):
        """
        Returns the amount (in mols) of species with identifier string spec in compartment 
        with identifier string comp.

        In a mesh-based simulation (i.e. Tetexact) this is the combined amount from all 
        tetrahedral elements in the compartment.

        Syntax::
            
            getCompAmount(comp, spec)
            
        Arguments:
            * string comp
            * string spec

        Return:
            float

        """
        return _steps_swig.API_getCompAmount(*args)

    def setCompAmount(*args):
        """
        Set the amount (in mols) of species with identifier string spec in compartment 
        with identifier string comp.

        In a mesh-based simulation (i.e. Tetexact) this is the combined amount from all 
        tetrahedral elements in the compartment.

        Syntax::
            
            setCompAmount(comp, spec, amount)
            
        Arguments:
            * string comp
            * string spec
            * float amount

        Return:
            None

        """
        return _steps_swig.API_setCompAmount(*args)

    def getCompConc(*args):
        """
        Returns the concentration (in Molar units) of species with identifier string spec 
        in compartment with identifier string comp.

        Note: in a mesh-based simulation (i.e. Tetexact) this is calculated from the combined 
        number of molecules from all tetrahedral elements in the compartment and the total 
        volume of the tetrahedrons.

        Syntax::
            
            getCompConc(comp, spec)
            
        Arguments:
            * string comp
            * string spec

        Return:
            float

        """
        return _steps_swig.API_getCompConc(*args)

    def setCompConc(*args):
        """
        Sets the concentration (in Molar units) of species with identifier string spec 
        in compartment with identifier string comp to conc. In a discrete solver the 
        continuous concentration is converted to a discrete number of 
        molecules.

        Note: in a mesh-based simulation (i.e. Tetexact) the molecules are divided as 
        equally as possible over all tetrahedral elements in the compartment (i.e. a 
        uniform distribution).

        Syntax::

            setCompConc(comp, spec, conc)
            
        Arguments:
            * string comp
            * string spec
            * float conc

        Return:
            None

        """
        return _steps_swig.API_setCompConc(*args)

    def getCompClamped(*args):
        """
        Returns True if species with identifier string spec in compartment with identifier 
        string comp is clamped (buffered), which means the concentration remains the same 
        regardless of reactions that consume or produce molecules of this species. 
        Returns False if not.

        Note: in a mesh-based simulation (i.e. Tetexact) it returns True only if the species 
        is clamped in all tetrahedral elements of the compartment.

        Syntax::
            
            getCompClamped(comp, spec)
            
        Arguments:
            * string comp
            * string spec

        Return:
            bool

        """
        return _steps_swig.API_getCompClamped(*args)

    def setCompClamped(*args):
        """
        Sets whether the concentration of species with identifier string spec in compartment 
        with identifier string comp is clamped (clamped = True) or not (clamped = False). 
        If a species is clamped the concentration stays the same regardless of reactions 
        that consume or produce molecules of the species.

        Note: in a mesh-based simulation (i.e. Tetexact) this will set the species to be 
        clamped or not in all tetrahedral elements of the compartment.

        Syntax::
            
            setCompClamped(comp, spec, clamped)
            
        Arguments:
            * string comp
            * string spec
            * bool clamped

        Return:
            bool

        """
        return _steps_swig.API_setCompClamped(*args)

    def getCompReacK(*args):
        """
        Returns the macroscopic reaction constant of reaction with identifier string reac 
        in compartment with identifier string comp. The unit of the reaction constant depends 
        on the order of the reaction.

        Note: In a mesh-based simulation (i.e. Tetexact) the value for the compartment is 
        returned, although individual tetrahedral elements may have different values 
        (set with setTetReacK).

        Syntax::
            
            getCompReacK(comp, reac)
            
        Arguments:
            * string comp
            * string reac

        Return:
            float

        """
        return _steps_swig.API_getCompReacK(*args)

    def setCompReacK(*args):
        """
        Sets the macroscopic reaction constant of reaction with identifier string reac 
        in compartment with identifier string comp to kf. The unit of the reaction constant 
        depends on the order of the reaction.

        Note: In a mesh-based simulation (i.e. Tetexact) this method sets the reaction 
        constant in all tetrahedral elements of the compartment to kf

        Note: The default value still comes from the steps.model description, so 
        calling reset() will return the reaction constant to that value.

        Syntax::
            
            setCompReacK(comp, reac, kf)
            
        Arguments:
            * string comp
            * string reac
            * float kf

        Return:
            None

        """
        return _steps_swig.API_setCompReacK(*args)

    def getCompReacActive(*args):
        """
        Returns whether a reaction with identifier string reac in compartment with identifier 
        string comp is active (True) or not (False). If it's not active this means that a 
        reaction will never occur regardless of whether the reactants are present in 
        sufficient numbers or not. 

        Note: In a mesh-based simulation (i.e. Tetexact) this method will return True only 
        if the reaction is active in all tetrahedral elements in the compartment. 

        Syntax::
            
            getCompReacActive(comp, reac)
            
        Arguments:
            * string comp
            * string reac

        Return:
            bool

        """
        return _steps_swig.API_getCompReacActive(*args)

    def setCompReacActive(*args):
        """
        Activate (active = True) or deactivate (active = False) a reaction with identifier 
        string reac in compartment with identifier string comp. If a reaction is not active 
        this means that a reaction will never occur regardless of whether the reactants are 
        present in sufficient numbers or not.

        Note: In a mesh-based simulation (i.e. Tetexact) this will activate/deactivate the 
        reaction in all tetrahedral elements in the compartment. 

        Syntax::
            
            setCompReacActive(comp, reac, active)
            
        Arguments:
            * string comp
            * string reac
            * bool active

        Return:
            None

        """
        return _steps_swig.API_setCompReacActive(*args)

    def getCompDiffD(*args):
        """
        Returns the diffusion constant of diffusion rule with identifier string diff 
        in compartment with identifier string comp. This constant is in units m^2/s.

        Note: In a mesh-based solver (i.e. Tetexact) the value for the compartment is 
        returned, although individual or groups of tetrahedral elements may have different 
        values (set with setTetDiffD). 

        Syntax::
            
            getCompDiffD(comp, diff)
            
        Arguments:
            * string comp
            * string diff

        Return:
            float

        """
        return _steps_swig.API_getCompDiffD(*args)

    def setCompDiffD(*args):
        """
        Sets the diffusion constant of diffusion rule with identifier string diff 
        in compartment with identifier string comp to dcst (in m^2/s).

        Note: This method will set the diffusion constant in all tetrahedral elements 
        in the compartment.

        Note: The default value still comes from the steps.model description, 
        so calling reset() will return the diffusion constants to that value. 

        Syntax::
            
            setCompDiffD(comp, diff, dcst)
            
        Arguments:
            * string comp
            * string diff
            * float dcst

        Return:
            None

        """
        return _steps_swig.API_setCompDiffD(*args)

    def getCompDiffActive(*args):
        """
        Returns whether a diffusion rule with identifier string diff in compartment with 
        identifier string comp is active (True) or not (False). If diffusion of a species 
        is inactive this means the molecules will remain in place and has the same effect 
        as a diffusion constant of zero. 

        Syntax::
            
            getCompDiffActive(comp, diff)
            
        Arguments:
            * string comp
            * string diff

        Return:
            bool

        """
        return _steps_swig.API_getCompDiffActive(*args)

    def setCompDiffActive(*args):
        """
        Activate (active = True) or deactivate (active = False) a diffusion rule with 
        identifier string diff in compartment with identifier string comp. If diffusion 
        of a species is inactive this means the molecules will remain in place and is 
        effectively the same as setting the diffusion constant to zero

        Syntax::
            
            setCompDiffActive(comp, diff, active)
            
        Arguments:
            * string comp
            * string diff
            * bool active

        Return:
            None

        """
        return _steps_swig.API_setCompDiffActive(*args)

    def getCompReacC(*args):
        """
        Returns the 'stochastic reaction constant' (or 'specific probability rate constant') 
        of reaction with identifier string reac in compartment with identifier string comp.

        The 'stochastic reaction constant' multiplied by infinitesimal time interval dt 
        gives the average probability that one reaction channel of this reaction type 
        will react accordingly in dt.

        Note: in a mesh-based simulation (i.e. Tetexact), the stochastic reaction constant 
        is computed as the weighted mean of the stochastic reaction constants in all 
        tetrahedral elements of the compartment.

        Syntax::
            
            getCompReacC(comp, reac)
            
        Arguments:
            * string comp
            * string reac

        Return:
            float

        """
        return _steps_swig.API_getCompReacC(*args)

    def getCompReacH(*args):
        """
        Returns h_mu, the distinct number of ways in which reaction with identifier string 
        reac can occur in compartment with identifier string comp, by computing the product 
        of its reactants. Note: in a mesh-based simulation (i.e. Tetexact), returns the sum 
        of the h_mu's over all tetrahedral elements in the compartment. 

        Syntax::
            
            getCompReacH(comp, reac)
            
        Arguments:
            * string comp
            * string reac

        Return:
            float

        """
        return _steps_swig.API_getCompReacH(*args)

    def getCompReacA(*args):
        """
        Returns the propensity of reaction with identifier string reac in compartment 
        with identifier string comp. 

        The propensity of a reaction is a function of state and is defined as the 
        function whose product with infinitesimal time dt gives the probability 
        that the reaction will occur in the next dt. It is the 'stochastic reaction 
        constant' multiplied by 'h_mu'. 

        Note: in a mesh-based simulation (i.e. Tetexact), the propensity of a reaction 
        in a compartment is computed as the sum of the propensities in all tetrahedral 
        elements of the compartment. 

        Syntax::
            
            getCompReacA(comp, reac)
            
        Arguments:
            * string comp
            * string reac

        Return:
            float

        """
        return _steps_swig.API_getCompReacA(*args)

    def getCompReacExtent(*args):
        """
        Return the extent of reaction with identifier string reac in compartment with 
        identifier string comp, that is the number of times the reaction has occurred up 
        to the current simulation time. 

        Note: in a mesh-based simulation (i.e. Tetexact), returns the sum of the reaction 
        extents in all tetrahedral elements of the compartment.

        Syntax::
            
            getCompReacExtent(comp, reac)
            
        Arguments:
            * string comp
            * string reac

        Return:
            uint

        """
        return _steps_swig.API_getCompReacExtent(*args)

    def resetCompReacExtent(*args):
        """
        Resets the extent of reaction with identifier string reac in compartment with 
        identifier string comp to zero. 

        Note: in a mesh-based simulation (i.e. Tetexact), 
        resets the extents of the reaction in all tetrahedral elements of the compartment.

        Syntax::
            
            resetCompReacExtent(comp, reac)
            
        Arguments:
            * string comp
            * string reac

        Return:
            None

        """
        return _steps_swig.API_resetCompReacExtent(*args)

    def getTetVol(*args):
        """
        Returns the volume (in m^3) of the tetrahedral element with index idx.

        Syntax::
            
            getTetVol(idx)
            
        Arguments:
            * uint idx

        Return:
            float

        """
        return _steps_swig.API_getTetVol(*args)

    def getTetSpecDefined(*args):
        """
        Returns whether species with identifier string spec is defined
        in the tetrahedral element with index idx.

        Syntax::
            
            getTetSpecDefined(idx, spec)
            
        Arguments:
            * uint idx
            * string spec

        Return:
            bool

        """
        return _steps_swig.API_getTetSpecDefined(*args)

    def getTetCount(*args):
        """
        Returns the number of molecules of species with identifier string spec 
        in the tetrahedral element with index idx.

        Syntax::
            
            getTetCount(idx, spec)
            
        Arguments:
            * uint idx
            * string spec

        Return:
            uint

        """
        return _steps_swig.API_getTetCount(*args)

    def setTetCount(*args):
        """
        Sets the number of molecules of species with identifier string spec in 
        tetrahedral element with index idx to n.

        Syntax::
            
            setTetCount(idx, spec, n)
            
        Arguments:
            * uint idx
            * string spec
            * uint n

        Return:
            None

        """
        return _steps_swig.API_setTetCount(*args)

    def getTetAmount(*args):
        """
        Returns the amount (in mols) of species with identifier string spec in 
        tetrahedral element with index idx.

        Syntax::
            
            getTetAmount(idx, spec)
            
        Arguments:
            * uint idx
            * string spec

        Return:
            float

        """
        return _steps_swig.API_getTetAmount(*args)

    def setTetAmount(*args):
        """
        Sets the amount (in mols) of species with identifier string spec in tetrahedral 
        element with index idx to a. This continuous value must be converted internally 
        to a discrete number of molecules by multiplication with Avogadro's 
        number. 

        Due to the small volumes of tetrahedral elements the difference 
        between 'rounding up' and 'rounding down' can be a significant difference in 
        concentration.

        Syntax::
            
            setTetAmount(idx, spec, a)
            
        Arguments:
            * uint idx
            * string spec
            * float a

        Return:
            None

        """
        return _steps_swig.API_setTetAmount(*args)

    def getTetConc(*args):
        """
        Returns the concentration (in Molar units) of species with identifier 
        string spec in a tetrahedral element with index idx.

        Syntax::
            
            getTetConc(idx, spec)
            
        Arguments:
            * uint idx
            * string spec

        Return:
            float

        """
        return _steps_swig.API_getTetConc(*args)

    def setTetConc(*args):
        """
        Sets the concentration (in Molar units) of species with identifier string spec 
        in a tetrahedral element with index idx to conc.This continuous value must be 
        converted internally to a discrete number of molecules. 

        Due to the small volumes of tetrahedral elements the difference between 'rounding 
        up' and 'rounding down' can be a large difference in concentration.

        Syntax::
            
            setTetConc(idx, spec, conc)
            
        Arguments:
            * uint idx
            * string spec
            * conc

        Return:
            None

        """
        return _steps_swig.API_setTetConc(*args)

    def getTetClamped(*args):
        """
        Returns True if concentration of species with identifier string spec in tetrahedral 
        element with index idx is clamped (buffered), which means the concentration stays the 
        same regardless of reactions that consume or produce molecules of this species or 
        diffusion of this species into or out of the tetrahedral element. Returns False if 
        not.

        Syntax::
            
            getTetClamped(idx, spec)
            
        Arguments:
            * uint idx
            * string spec

        Return:
            bool

        """
        return _steps_swig.API_getTetClamped(*args)

    def setTetClamped(*args):
        """
        Sets whether the concentration of species spec in tetrahedral element with 
        index idx is clamped (clamped = True) or not (clamped = False). 
        If a species is clamped the concentration stays the same regardless 
        of reactions that consume or produce molecules of the species or 
        diffusion of the species into or out of the tetrahedral element.

        Syntax::
            
            setTetClamped(idx, spec, clamped)
            
        Arguments:
            * uint idx
            * string spec
            * bool clamped

        Return:
            None

        """
        return _steps_swig.API_setTetClamped(*args)

    def getTetReacK(*args):
        """
        Returns the macroscopic reaction constant of reaction with identifier string reac 
        in tetrahedral element with index idx. The unit of the reaction constant depends 
        on the order of the reaction.

        Syntax::
            
            getTetReacK(idx, reac)
            
        Arguments:
            * uint idx
            * string reac

        Return:
            float

        """
        return _steps_swig.API_getTetReacK(*args)

    def setTetReacK(*args):
        """
        Sets the macroscopic reaction constant of reaction with identifier string reac 
        in tetrahedral element with index idx to kf. The units of the reaction constant 
        depends on the order of the reaction.

        Syntax::
            
            setTetReacK(idx, reac, kf)
            
        Arguments:
            * uint idx
            * string reac
            * float kf

        Return:
            None

        """
        return _steps_swig.API_setTetReacK(*args)

    def getTetReacActive(*args):
        """
        Returns whether reaction with identifier string reac in tetrahedral element 
        with index idx is active (True) or not (False). If it's not active this means 
        that the reaction will never occur regardless of whether reactants are present 
        in sufficient numbers or not.

        Syntax::
            
            getTetReacActive(idx, reac)
            
        Arguments:
            * uint idx
            * string reac

        Return:
            bool

        """
        return _steps_swig.API_getTetReacActive(*args)

    def setTetReacActive(*args):
        """
        Activate (active = True) or deactivate (active = False) a reaction with identifier 
        string reac in tetrahedral element with index idx. If it's not active this means 
        that the reaction will never occur regardless of whether reactants are present 
        in sufficient numbers or not.

        Syntax::
            
            setTetReacActive(idx, reac, active)
            
        Arguments:
            * uint idx
            * string reac
            * bool active

        Return:
            None

        """
        return _steps_swig.API_setTetReacActive(*args)

    def getTetDiffD(*args):
        """
        Returns the diffusion constant of diffusion rule with identifier string diff 
        in tetrahedral element with index idx. This constant is in units m^2/s. 

        Syntax::
            
            getTetDiffD(idx, diff)
            
        Arguments:
            * uint idx
            * string diff

        Return:
            float

        """
        return _steps_swig.API_getTetDiffD(*args)

    def setTetDiffD(*args):
        """
        Sets the diffusion constant of diffusion rule with identifier string diff in 
        tetrahedral element with index idx to dcst (in m^2/s).

        Syntax::
            
            setTetDiffD(idx, diff, dcst)
            
        Arguments:
            * uint idx
            * string diff
            * dcst

        Return:
            None

        """
        return _steps_swig.API_setTetDiffD(*args)

    def getTetDiffActive(*args):
        """
        Returns whether diffusion with identifier string diff in tetrahedral element 
        with index idx is active (True) or not (False). If diffusion of a species 
        is inactive this means the molecules will never diffuse out of the tetrahedron 
        and has the same effect as a diffusion constant of zero.

        Syntax::
            
            getTetDiffActive(idx, diff)
            
        Arguments:
            * uint idx
            * string diff

        Return:
            bool

        """
        return _steps_swig.API_getTetDiffActive(*args)

    def setTetDiffActive(*args):
        """
        Activate (active = True) or deactivate (active = False) diffusion rule with 
        identifier string diff in tetrahedral element with index idx. If diffusion of 
        a species is inactive this means the molecules will never diffuse out of the 
        tetrahedron and has the same effect as a diffusion constant of zero. 

        Syntax::
            
            setTetDiffActive(idx, diff, active)
            
        Arguments:
            * uint idx
            * string diff
            * bool active

        Return:
            None

        """
        return _steps_swig.API_setTetDiffActive(*args)

    def getTetReacC(*args):
        """
        Returns the 'stochastic reaction constant' (or 'specific probability rate constant') 
        of reaction with identifier string reac in tetrahedral element with index idx.

        Syntax::
            
            getTetReacC(idx, reac)
            
        Arguments:
            * uint idx
            * string reac

        Return:
            float

        """
        return _steps_swig.API_getTetReacC(*args)

    def getTetReacH(*args):
        """
        Returns h_mu, the distinct number of ways in which reaction with identifier string 
        reac can occur in tetrahedral element with index idx, by computing the product of 
        its reactants.

        Syntax::
            
            getTetReacH(idx, reac)
            
        Arguments:
            * uint idx
            * string reac

        Return:
            float

        """
        return _steps_swig.API_getTetReacH(*args)

    def getTetReacA(*args):
        """
        Returns the propensity of reaction with identifier string reac in tetrahedral 
        element with index idx.

        Syntax::
            
            getTetReacA(idx, reac)
            
        Arguments:
            * uint idx
            * string reac

        Return:
            float

        """
        return _steps_swig.API_getTetReacA(*args)

    def getTetDiffA(*args):
        """
        Returns the propensityof diffusion rule with identifier string diff in 
        tetrahedral element with index idx. 

        Syntax::
            
            getTetDiffA(idx, reac)
            
        Arguments:
            * uint idx
            * string reac

        Return:
            float

        """
        return _steps_swig.API_getTetDiffA(*args)

    def getPatchArea(*args):
        """
        Returns the area of patch with identifier string pat (in m^2).

        Syntax::
            
            getPatchArea(pat)
            
        Arguments:
            * string pat

        Return:
            float

        """
        return _steps_swig.API_getPatchArea(*args)

    def setPatchArea(*args):
        """
        Sets the area of patch with identifier string pat to area a (in m^2).

        Syntax::
            
            setPatchArea(pat, area)
            
        Arguments:
            * string pat
            * float area

        Return:
            None

        """
        return _steps_swig.API_setPatchArea(*args)

    def getPatchCount(*args):
        """
        Returns the number of molecules of species with identifier string spec in patch 
        with identifier string pat.Note: in a mesh-based simulation (i.e. Tetexact) this 
        is the combined count from all triangular elements in the patch. 

        Syntax::
            
            getPatchCount(pat, spec)
            
        Arguments:
            * string pat
            * string spec

        Return:
            float

        """
        return _steps_swig.API_getPatchCount(*args)

    def setPatchCount(*args):
        """
        Sets the number of molecules of species with identifier string spec in patch 
        with identifier string pat to n. Note: in a mesh-based simulation (i.e. Tetexact) 
        the molecules are divided as equally as possible over all triangular elements in 
        the patch (i.e. a uniform distribution). 

        Syntax::
            
            setPatchCount(pat, spec, n)
            
        Arguments:
            * string pat
            * string spec
            * uint n

        Return:
            float

        """
        return _steps_swig.API_setPatchCount(*args)

    def getPatchAmount(*args):
        """
        Returns the amount (in mols) of species with identifier string spec in patch 
        with identifier string pat.

        Note: in a mesh-based simulation (i.e. Tetexact) this is the combined amount 
        from all triangular elements in the patch. 

        Syntax::
            
            getPatchAmount(pat, spec)
            
        Arguments:
            * string pat
            * string spec

        Return:
            float

        """
        return _steps_swig.API_getPatchAmount(*args)

    def setPatchAmount(*args):
        """
        Sets the amount (in mols) of species with identifier string spec in patch with 
        identifier string pat to a. In a discrete solver, such as Wmdirect and Tetexact, 
        this continuous value is converted internally into a discrete number of molecules 
        by multiplication with Avogadro's number. 

        Note: in a mesh-based simulation (i.e. Tetexact) the molecules are divided as 
        equally as possible over all triangular elements in the patch (i.e. a uniform 
        distribution).

        Syntax::
            
            setPatchAmount(pat, spec, a)
            
        Arguments:
            * string pat
            * string spec
            * float a

        Return:
            None

        """
        return _steps_swig.API_setPatchAmount(*args)

    def getPatchClamped(*args):
        """
        Sets the amount (in mols) of species with identifier string spec in patch with 
        identifier string pat to a. In a discrete solver, such as Wmdirect and Tetexact, 
        this continuous value is converted internally into a discrete number of molecules 
        by multiplication with Avogadro's number. 

        Note: in a mesh-based simulation (i.e. Tetexact) the molecules are divided as equally 
        as possible over all triangular elements in the patch (i.e. a uniform distribution).

        Syntax::
            
            getPatchClamped(pat, spec)
            
        Arguments:
            * string pat
            * string spec

        Return:
            bool

        """
        return _steps_swig.API_getPatchClamped(*args)

    def setPatchClamped(*args):
        """
        Sets whether the species with identifier string spec in patch with identifier 
        string pat is clamped (clamped = True) or not (clamped = False). If a species 
        is clamped the number of molecules stays the same regardless of surface reactions 
        that consume or produce molecules of the species.

        Note: in a mesh-based simulation this will set the species to be clamped in all 
        triangular elements of the patch.

        Syntax::
            
            setPatchClamped(pat, spec, clamped)
            
        Arguments:
            * string pat
            * string spec
            * bool clamped

        Return:
            None

        """
        return _steps_swig.API_setPatchClamped(*args)

    def getPatchSReacK(*args):
        """
        Returns the macroscopic reaction constant of surface reaction with identifier 
        string sreac in patch with identifier string pat. The unit of the reaction constant 
        depends on the order of the reaction.

        Note: In a mesh-based solver (i.e. Tetexact) the value for the patch is returned, 
        although individual triangle elements may have different values 
        (set with setTriSReacK).

        Syntax::
            
            getPatchSReacK(pat, reac)
            
        Arguments:
            * string pat
            * string reac

        Return:
            float

        """
        return _steps_swig.API_getPatchSReacK(*args)

    def setPatchSReacK(*args):
        """
        Sets the macroscopic reaction constant of surface reaction with identifier 
        string sreac in patch with identifier string pat to kf. The unit of the reaction 
        constant depends on the order of the reaction. 

        Note: In a mesh-based simulation (i.e. Tetexact) this method sets the surface 
        reaction constant in all triangular elements of the patch to kf.

        Note: The default value still comes from the steps.model description, so calling 
        reset() will return the surface reaction constant to that value.

        Syntax::
            
            setPatchSReacK(pat, reac, kf)
            
        Arguments:
            * string pat
            * string reac
            * float kf

        Return:
            None

        """
        return _steps_swig.API_setPatchSReacK(*args)

    def getPatchSReacActive(*args):
        """
        Returns whether a surface reaction with identifier string sreac in patch with 
        identifier string pat is active (True) or not (False). If it's not active this means 
        that a surface reaction will never occur regardless of whether the reactants are 
        present in sufficient numbers or not. 

        Note: In a mesh-based simulation (i.e. Tetexact) this method will return True only 
        if the surface reaction is active in all triangular elements in the patch.

        Syntax::
            
            getPatchSReacActive(pat, reac)
            
        Arguments:
            * string pat
            * string reac

        Return:
            bool

        """
        return _steps_swig.API_getPatchSReacActive(*args)

    def setPatchSReacActive(*args):
        """
        Activate (active = True) or deactivate (active = False) a surface reaction with 
        identifier string sreac in patch with identifier string pat. If a surface reaction 
        is not active this means that a reaction will never occur regardless of whether the 
        reactants are present in sufficient numbers or not.

        Note: In a mesh-based simulation (i.e. Tetexact) this will activate/ deactivate the 
        reaction in all triangular elements in the patch.

        Syntax::
            
            setPatchSReacActive(pat, reac, active)
            
        Arguments:
            * string pat
            * string reac
            * bool active

        Return:
            None

        """
        return _steps_swig.API_setPatchSReacActive(*args)

    def getPatchSReacC(*args):
        """
        Returns the 'stochastic reaction constant' (or 'specific probability rate constant') 
        of surface reaction with identifier string sreac in patch with identifier string pat.

        Note: in a mesh-based simulation (i.e. Tetexact), the stochastic reaction constant is 
        computed as the weighted mean of the stochastic reaction constants in all triangular 
        elements of the patch.

        Syntax::
            
            getPatchSReacC(pat, reac)
            
        Arguments:
            * string pat
            * string reac

        Return:
            float

        """
        return _steps_swig.API_getPatchSReacC(*args)

    def getPatchSReacH(*args):
        """
        Returns h_mu, the distinct number of ways in which surface reaction with identifier 
        string sreac can occur in patch with identifier string pat, by computing the product 
        of its reactants. Note: in a mesh-based simulation (i.e. Tetexact), returns the sum 
        of the h_mu's over all triangular elements in the patch. 

        Syntax::
            
            getPatchSReacH(pat, reac)
            
        Arguments:
            * string pat
            * string reac

        Return:
            float

        """
        return _steps_swig.API_getPatchSReacH(*args)

    def getPatchSReacA(*args):
        """
        Returns the propensity of surface reaction with identifier string sreac in patch 
        with identifier string pat. Note: in a mesh-based simulation (i.e. Tetexact), 
        the propensity of a surface reaction in a patch is computed as the sum of the 
        propensities in all triangular elements of the patch.

        Syntax::
            
            getPatchSReacA(pat, reac)
            
        Arguments:
            * string pat
            * string reac

        Return:
            float

        """
        return _steps_swig.API_getPatchSReacA(*args)

    def getPatchSReacExtent(*args):
        """
        Returns the extent of surface reaction with identifier string sreac in patch 
        with identifier string pat, that is the number of times the surface reaction 
        has occurred up to the current simulation time. 

        Note: in a mesh-based simulation (i.e. Tetexact), returns the sum of the reaction 
        extents in all triangular elements of the patch.

        Syntax::
            
            getPatchSReacExtent(pat,reac)
            
        Arguments:
            * string pat
            * string reac

        Return:
            uint

        """
        return _steps_swig.API_getPatchSReacExtent(*args)

    def resetPatchSReacExtent(*args):
        """
        Resets the extent of reaction with identifier string sreac in patch with identifier 
        string pat to zero. 

        Note: in a mesh-based simulation (i.e. Tetexact), resets the extents of the reaction 
        in all triangular elements of the patch.

        Syntax::
            
            resetPatchSReacExtent(pat, reac)
            
        Arguments:
            * string pat
            * string reac

        Return:
            None

        """
        return _steps_swig.API_resetPatchSReacExtent(*args)

    def setDiffBoundaryDiffusionActive(*args):
        """
        Activates or inactivates diffusion across a diffusion boundary for a species.

        Syntax::
                
            setDiffBoundaryDiffusionActive(diffb, spec, act)
            
        Arguments:
            * string diffb
            * string spec
            * bool act
                     
        Return:
            None

        """
        return _steps_swig.API_setDiffBoundaryDiffusionActive(*args)

    def getDiffBoundaryDiffusionActive(*args):
        """
        Returns whether diffusion is active across a diffusion boundary for a species.

        Syntax::

            getDiffBoundaryDiffusionActive(diffb, spec)

        Arguments:
            * string diffb
            * string spec

        Return:
            bool

        """
        return _steps_swig.API_getDiffBoundaryDiffusionActive(*args)

    def getTriArea(*args):
        """
        Returns the area (in m^2) of the triangular element with index idx.
                 
        ax::
                 
        getTriArea(idx)
                 
        ments:
        * uint idx
                 
        rn:
        float

        """
        return _steps_swig.API_getTriArea(*args)

    def getTriSpecDefined(*args):
        """
        Returns whether species with identifier string spec is defined
        in the triangle element with index idx.

        Syntax::
            
            getTriSpecDefined(idx, spec)
            
        Arguments:
            * uint idx
            * string spec

        Return:
            bool

        """
        return _steps_swig.API_getTriSpecDefined(*args)

    def getTriCount(*args):
        """
        Returns the number of molecules of species with identifier string spec 
        in the triangular element with index idx.

        Syntax::
            
            getTriCount(idx, spec)
            
        Arguments:
            * uint idx
            * string spec

        Return:
            float

        """
        return _steps_swig.API_getTriCount(*args)

    def setTriCount(*args):
        """
        Sets the number of molecules of species with identifier string spec in 
        triangular element with index idx to n. 

        Syntax::
            
            setTriCount(idx, spec, n)
            
        Arguments:
            * uint idx
            * string spec
            * uint n

        Return:
            None

        """
        return _steps_swig.API_setTriCount(*args)

    def getTriAmount(*args):
        """
        Returns the amount (in mols) of species with identifier string spec in triangular 
        element with index idx.  

        Syntax::
            
            getTriAmount(idx, spec)
            
        Arguments:
            * uint idx
            * string spec

        Return:
            float

        """
        return _steps_swig.API_getTriAmount(*args)

    def setTriAmount(*args):
        """
        Sets the amount (in mols) of species with identifier string spec in triangular 
        element with index idx to a. This continuous value must be converted internally 
        to a discrete number of molecules by multiplication with Avogadro's number. 

        Syntax::
            
            setTriAmount(idx, spec, a)
            
        Arguments:
            * uint idx
            * string spec
            * float a

        Return:
            None

        """
        return _steps_swig.API_setTriAmount(*args)

    def getTriClamped(*args):
        """
        Returns True if the species with identifier string spec in triangular element 
        with index idx is clamped (buffered), which means the number of molecules stays 
        the same regardless of reactions that consume or produce molecules of this species. 
        Returns False if not.

        Syntax::
            
            getTriClamped(idx, spec)
            
        Arguments:
            * uint idx
            * string spec

        Return:
            bool

        """
        return _steps_swig.API_getTriClamped(*args)

    def setTriClamped(*args):
        """
        Sets whether the concentration of species spec in triangular element with index idx 
        is clamped (clamped = True) or not (clamped = False). If a species is clamped the 
        concentration stays the same regardless of reactions that consume or produce 
        molecules of the species. 

        Syntax::
            
            setTriClamped(idx, spec, clamped)
            
        Arguments:
            * uint idx
            * string spec
            * bool clamped

        Return:
            None

        """
        return _steps_swig.API_setTriClamped(*args)

    def getTriSReacK(*args):
        """
        Returns the macroscopic reaction constant of surface reaction with identifier 
        string sreac in triangular element with index idx. The units of the reaction 
        constant depends on the order of the reaction. 

        Syntax::
            
            getTriSReacK(idx, reac)
            
        Arguments:
            * uint idx
            * string reac

        Return:
            float

        """
        return _steps_swig.API_getTriSReacK(*args)

    def setTriSReacK(*args):
        """
        Sets the macroscopic reaction constant of surface reaction with identifier 
        string sreac in triangular element with index idx to kf. The units of the 
        reaction constant depends on the order of the reaction.

        Syntax::
            
            setTriSReacK(idx, reac, kf)
            
        Arguments:
            * uint idx
            * string reac
            * float kf

        Return:
            None

        """
        return _steps_swig.API_setTriSReacK(*args)

    def getTriSReacActive(*args):
        """
        Returns whether surface reaction with identifier string sreac in triangular 
        element with index idx is active (True) or not (False). If it's not active 
        this means that the surface reaction will never occur regardless of whether 
        reactants are present in sufficient numbers or not. 

        Syntax::
            
            getTriSReacActive(idx, reac)
            
        Arguments:
            * uint idx
            * string reac

        Return:
            bool

        """
        return _steps_swig.API_getTriSReacActive(*args)

    def setTriSReacActive(*args):
        """
        Activate (active = True) or deactivate (active = False) a surface reaction 
        with identifier string sreac in triangular element with index idx. If it's 
        not active this means that the surface reaction will never occur regardless 
        of whether reactants are present in sufficient numbers or not.  

        Syntax::
            
            setTriSReacActive(idx, reac, active)
            
        Arguments:
            * uint idx
            * string reac
            * active

        Return:
            None

        """
        return _steps_swig.API_setTriSReacActive(*args)

    def getTriSReacC(*args):
        """
        Returns the 'stochastic reaction constant' (or 'specific probability rate constant') 
        of surface reaction with identifier string sreac in triangular element with index idx.  

        Syntax::
            
            getTriSReacC(idx, reac)
            
        Arguments:
            * uint idx
            * string reac

        Return:
           float

        """
        return _steps_swig.API_getTriSReacC(*args)

    def getTriSReacH(*args):
        """
        Returns h_mu, the distinct number of ways in which surface reaction with identifier 
        string sreac can occur in triangular element with index idx, by computing the product 
        of its reactants. 

        Syntax::
            
            getTriSReacH(idx, reac)
            
        Arguments:
            * uint idx
            * string reac

        Return:
           float

        """
        return _steps_swig.API_getTriSReacH(*args)

    def getTriSReacA(*args):
        """
        Returns the propensity of surface reaction with identifier string sreac 
        in triangular element with index idx. 

        Syntax::
            
            getTriSReacA(idx, reac)
            
        Arguments:
            * uint idx
            * string reac

        Return:
           float

        """
        return _steps_swig.API_getTriSReacA(*args)

API_swigregister = _steps_swig.API_swigregister
API_swigregister(API)

class Wmrk4(API):
    """Proxy of C++ Wmrk4 class"""
    __swig_setmethods__ = {}
    for _s in [API]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Wmrk4, name, value)
    __swig_getmethods__ = {}
    for _s in [API]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Wmrk4, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, Model m, Geom g, RNG r) -> Wmrk4"""
        this = _steps_swig.new_Wmrk4(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _steps_swig.delete_Wmrk4
    __del__ = lambda self : None;
    def getSolverName(*args):
        """
        Returns a string of the solver's name.

        Syntax::
            
            getSolverName()
            
        Arguments:
            None

        Return:
            string

        """
        return _steps_swig.Wmrk4_getSolverName(*args)

    def getSolverDesc(*args):
        """
        Returns a string giving a short description of the solver.

        Syntax::
            
            getSolverDesc()
            
        Arguments:
            None

        Return:
            string

        """
        return _steps_swig.Wmrk4_getSolverDesc(*args)

    def getSolverAuthors(*args):
        """
        Returns a string of the solver authors names.

        Syntax::
            
            getSolverAuthors()
            
        Arguments:
            None

        Return:
            string

        """
        return _steps_swig.Wmrk4_getSolverAuthors(*args)

    def getSolverEmail(*args):
        """
        Returns a string giving the author's email address.

        Syntax::
            
            getSolverEmail()
            
        Arguments:
            None

        Return:
            string

        """
        return _steps_swig.Wmrk4_getSolverEmail(*args)

    def reset(*args):
        """
        Reset the simulation to the state the solver was initialised to. 
        Typically, this resets all concentrations of all chemical species in 
        all elements (whether compartments and patches in a well-mixed solver 
        or tetrahedrons and triangles in a mesh-based solver) to zero, 
        resets the simulation time to zero and resets reaction (and diffusion) 
        rates to the default values described in the steps.model objects. 
        All reaction (and diffusion) rules are reset to active and all 
        compartment volumes and patch areas are reset to default values 
        described in steps.geom objects (for well-mixed solvers). 
        Usually, this method should be called before starting each simulation iteration.

        Syntax::
            
            reset()
            
        Arguments:
            None

        Return:
            None

        """
        return _steps_swig.Wmrk4_reset(*args)

    def run(*args):
        """
        Advance the simulation until endtime (given in seconds) is reached. 
        The endtime must be larger or equal to the current simulation time.

        Syntax::
            
            run(endtime)
            
        Arguments:
            float endtime

        Return:
            None

        """
        return _steps_swig.Wmrk4_run(*args)

    def getTime(*args):
        """
        Returns the current simulation time in seconds.

        Syntax::
            
            getTime()
            
        Arguments:
            None

        Return:
            float

        """
        return _steps_swig.Wmrk4_getTime(*args)

Wmrk4_swigregister = _steps_swig.Wmrk4_swigregister
Wmrk4_swigregister(Wmrk4)

class Wmdirect(API):
    """Proxy of C++ Wmdirect class"""
    __swig_setmethods__ = {}
    for _s in [API]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Wmdirect, name, value)
    __swig_getmethods__ = {}
    for _s in [API]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Wmdirect, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, Model m, Geom g, RNG r) -> Wmdirect"""
        this = _steps_swig.new_Wmdirect(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _steps_swig.delete_Wmdirect
    __del__ = lambda self : None;
    def getSolverName(*args):
        """
        Returns a string of the solver's name.

        Syntax::
            
            getSolverName()
            
        Arguments:
            None

        Return:
            string

        """
        return _steps_swig.Wmdirect_getSolverName(*args)

    def getSolverDesc(*args):
        """
        Returns a string giving a short description of the solver.

        Syntax::
            
            getSolverDesc()
            
        Arguments:
            None

        Return:
            string

        """
        return _steps_swig.Wmdirect_getSolverDesc(*args)

    def getSolverAuthors(*args):
        """
        Returns a string of the solver authors names.

        Syntax::
            
            getSolverAuthors()
            
        Arguments:
            None

        Return:
            string

        """
        return _steps_swig.Wmdirect_getSolverAuthors(*args)

    def getSolverEmail(*args):
        """
        Returns a string giving the author's email address.

        Syntax::
            
            getSolverEmail()
            
        Arguments:
            None

        Return:
            string

        """
        return _steps_swig.Wmdirect_getSolverEmail(*args)

    def reset(*args):
        """
        Reset the simulation to the state the solver was initialised to. 
        Typically, this resets all concentrations of all chemical species in 
        all elements (whether compartments and patches in a well-mixed solver 
        or tetrahedrons and triangles in a mesh-based solver) to zero, 
        resets the simulation time to zero and resets reaction (and diffusion) 
        rates to the default values described in the steps.model objects. 
        All reaction (and diffusion) rules are reset to active and all 
        compartment volumes and patch areas are reset to default values 
        described in steps.geom objects (for well-mixed solvers). 
        Usually, this method should be called before starting each simulation iteration.

        Syntax::
            
            reset()
            
        Arguments:
            None

        Return:
            None

        """
        return _steps_swig.Wmdirect_reset(*args)

    def run(*args):
        """
        Advance the simulation until endtime (given in seconds) is reached. 
        The endtime must be larger or equal to the current simulation time.

        Syntax::
            
            run(endtime)
            
        Arguments:
            float endtime

        Return:
            None

        """
        return _steps_swig.Wmdirect_run(*args)

    def getTime(*args):
        """
        Returns the current simulation time in seconds.

        Syntax::
            
            getTime()
            
        Arguments:
            None

        Return:
            float

        """
        return _steps_swig.Wmdirect_getTime(*args)

Wmdirect_swigregister = _steps_swig.Wmdirect_swigregister
Wmdirect_swigregister(Wmdirect)

class Tetexact(API):
    """Proxy of C++ Tetexact class"""
    __swig_setmethods__ = {}
    for _s in [API]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Tetexact, name, value)
    __swig_getmethods__ = {}
    for _s in [API]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Tetexact, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, Model m, Geom g, RNG r) -> Tetexact"""
        this = _steps_swig.new_Tetexact(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _steps_swig.delete_Tetexact
    __del__ = lambda self : None;
    def getSolverName(*args):
        """
        Returns a string of the solver's name.

        Syntax::
            
            getSolverName()
            
        Arguments:
            None

        Return:
            string

        """
        return _steps_swig.Tetexact_getSolverName(*args)

    def getSolverDesc(*args):
        """
        Returns a string giving a short description of the solver.

        Syntax::
            
            getSolverDesc()
            
        Arguments:
            None

        Return:
            string

        """
        return _steps_swig.Tetexact_getSolverDesc(*args)

    def getSolverAuthors(*args):
        """
        Returns a string of the solver authors names.

        Syntax::
            
            getSolverAuthors()
            
        Arguments:
            None

        Return:
            string

        """
        return _steps_swig.Tetexact_getSolverAuthors(*args)

    def getSolverEmail(*args):
        """
        Returns a string giving the author's email address.

        Syntax::
            
            getSolverEmail()
            
        Arguments:
            None

        Return:
            string

        """
        return _steps_swig.Tetexact_getSolverEmail(*args)

    def reset(*args):
        """
        Reset the simulation to the state the solver was initialised to. 
        Typically, this resets all concentrations of all chemical species in 
        all elements (whether compartments and patches in a well-mixed solver 
        or tetrahedrons and triangles in a mesh-based solver) to zero, 
        resets the simulation time to zero and resets reaction (and diffusion) 
        rates to the default values described in the steps.model objects. 
        All reaction (and diffusion) rules are reset to active and all 
        compartment volumes and patch areas are reset to default values 
        described in steps.geom objects (for well-mixed solvers). 
        Usually, this method should be called before starting each simulation iteration.

        Syntax::
            
            reset()
            
        Arguments:
            None

        Return:
            None

        """
        return _steps_swig.Tetexact_reset(*args)

    def run(*args):
        """
        Advance the simulation until endtime (given in seconds) is reached. 
        The endtime must be larger or equal to the current simulation time.

        Syntax::
            
            run(endtime)
            
        Arguments:
            float endtime

        Return:
            None

        """
        return _steps_swig.Tetexact_run(*args)

    def getTime(*args):
        """
        Returns the current simulation time in seconds.

        Syntax::
            
            getTime()
            
        Arguments:
            None

        Return:
            float

        """
        return _steps_swig.Tetexact_getTime(*args)

Tetexact_swigregister = _steps_swig.Tetexact_swigregister
Tetexact_swigregister(Tetexact)



