import collections
VERSION = "1.5.0"
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.

from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_biolccc', [dirname(__file__)])
        except ImportError:
            import _biolccc
            return _biolccc
        if fp is not None:
            try:
                _mod = imp.load_module('_biolccc', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _biolccc = swig_import_helper()
    del swig_import_helper
else:
    import _biolccc
del version_info
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__ == 'SwigPyObject':
            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,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


class SwigPyIterator(_object):
    """Proxy of C++ swig::SwigPyIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _biolccc.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(self) -> PyObject"""
        return _biolccc.SwigPyIterator_value(self)

    def incr(self, n = 1):
        """
        incr(self, n = 1) -> SwigPyIterator
        incr(self) -> SwigPyIterator
        """
        return _biolccc.SwigPyIterator_incr(self, n)

    def decr(self, n = 1):
        """
        decr(self, n = 1) -> SwigPyIterator
        decr(self) -> SwigPyIterator
        """
        return _biolccc.SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(self, x) -> ptrdiff_t"""
        return _biolccc.SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(self, x) -> bool"""
        return _biolccc.SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(self) -> SwigPyIterator"""
        return _biolccc.SwigPyIterator_copy(self)

    def next(self):
        """next(self) -> PyObject"""
        return _biolccc.SwigPyIterator_next(self)

    def __next__(self):
        """__next__(self) -> PyObject"""
        return _biolccc.SwigPyIterator___next__(self)

    def previous(self):
        """previous(self) -> PyObject"""
        return _biolccc.SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(self, n) -> SwigPyIterator"""
        return _biolccc.SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(self, x) -> bool"""
        return _biolccc.SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, x) -> bool"""
        return _biolccc.SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, n) -> SwigPyIterator"""
        return _biolccc.SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, n) -> SwigPyIterator"""
        return _biolccc.SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(self, n) -> SwigPyIterator"""
        return _biolccc.SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(self, n) -> SwigPyIterator
        __sub__(self, x) -> ptrdiff_t
        """
        return _biolccc.SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
SwigPyIterator_swigregister = _biolccc.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

import collections
class doubleArray(_object):
    """Proxy of C++ doubleArray class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, doubleArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, doubleArray, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, nelements) -> doubleArray"""
        this = _biolccc.new_doubleArray(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _biolccc.delete_doubleArray
    __del__ = lambda self : None;
    def __getitem__(self, *args):
        """__getitem__(self, index) -> double"""
        return _biolccc.doubleArray___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, index, value)"""
        return _biolccc.doubleArray___setitem__(self, *args)

    def cast(self):
        """cast(self) -> double"""
        return _biolccc.doubleArray_cast(self)

    def frompointer(*args):
        """frompointer(t) -> doubleArray"""
        return _biolccc.doubleArray_frompointer(*args)

    if _newclass:frompointer = staticmethod(frompointer)
    __swig_getmethods__["frompointer"] = lambda x: frompointer
doubleArray_swigregister = _biolccc.doubleArray_swigregister
doubleArray_swigregister(doubleArray)

def doubleArray_frompointer(*args):
  """doubleArray_frompointer(t) -> doubleArray"""
  return _biolccc.doubleArray_frompointer(*args)

class GradientPointVector(_object):
    """Proxy of C++ std::vector<(BioLCCC::GradientPoint)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GradientPointVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GradientPointVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _biolccc.GradientPointVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _biolccc.GradientPointVector___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _biolccc.GradientPointVector___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _biolccc.GradientPointVector___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _biolccc.GradientPointVector_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, i, j) -> GradientPointVector"""
        return _biolccc.GradientPointVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, i, j, v)"""
        return _biolccc.GradientPointVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, i, j)"""
        return _biolccc.GradientPointVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, i)
        __delitem__(self, slice)
        """
        return _biolccc.GradientPointVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, slice) -> GradientPointVector
        __getitem__(self, i) -> value_type
        """
        return _biolccc.GradientPointVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, slice, v)
        __setitem__(self, i, x)
        """
        return _biolccc.GradientPointVector___setitem__(self, *args)

    def append(self, *args):
        """append(self, x)"""
        return _biolccc.GradientPointVector_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _biolccc.GradientPointVector_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _biolccc.GradientPointVector_size(self)

    def clear(self):
        """clear(self)"""
        return _biolccc.GradientPointVector_clear(self)

    def swap(self, *args):
        """swap(self, v)"""
        return _biolccc.GradientPointVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _biolccc.GradientPointVector_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _biolccc.GradientPointVector_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _biolccc.GradientPointVector_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _biolccc.GradientPointVector_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _biolccc.GradientPointVector_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _biolccc.GradientPointVector_pop_back(self)

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

    def __init__(self, *args): 
        """
        __init__(self) -> GradientPointVector
        __init__(self, arg0) -> GradientPointVector
        __init__(self, size) -> GradientPointVector
        __init__(self, size, value) -> GradientPointVector
        """
        this = _biolccc.new_GradientPointVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, x)"""
        return _biolccc.GradientPointVector_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _biolccc.GradientPointVector_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _biolccc.GradientPointVector_back(self)

    def assign(self, *args):
        """assign(self, n, x)"""
        return _biolccc.GradientPointVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, new_size)
        resize(self, new_size, x)
        """
        return _biolccc.GradientPointVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, pos, x) -> iterator
        insert(self, pos, n, x)
        """
        return _biolccc.GradientPointVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, n)"""
        return _biolccc.GradientPointVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> size_type"""
        return _biolccc.GradientPointVector_capacity(self)

    __swig_destroy__ = _biolccc.delete_GradientPointVector
    __del__ = lambda self : None;
GradientPointVector_swigregister = _biolccc.GradientPointVector_swigregister
GradientPointVector_swigregister(GradientPointVector)

class ChemicalGroupVector(_object):
    """Proxy of C++ std::vector<(BioLCCC::ChemicalGroup)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChemicalGroupVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ChemicalGroupVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _biolccc.ChemicalGroupVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _biolccc.ChemicalGroupVector___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _biolccc.ChemicalGroupVector___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _biolccc.ChemicalGroupVector___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _biolccc.ChemicalGroupVector_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, i, j) -> ChemicalGroupVector"""
        return _biolccc.ChemicalGroupVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, i, j, v)"""
        return _biolccc.ChemicalGroupVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, i, j)"""
        return _biolccc.ChemicalGroupVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, i)
        __delitem__(self, slice)
        """
        return _biolccc.ChemicalGroupVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, slice) -> ChemicalGroupVector
        __getitem__(self, i) -> value_type
        """
        return _biolccc.ChemicalGroupVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, slice, v)
        __setitem__(self, i, x)
        """
        return _biolccc.ChemicalGroupVector___setitem__(self, *args)

    def append(self, *args):
        """append(self, x)"""
        return _biolccc.ChemicalGroupVector_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _biolccc.ChemicalGroupVector_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _biolccc.ChemicalGroupVector_size(self)

    def clear(self):
        """clear(self)"""
        return _biolccc.ChemicalGroupVector_clear(self)

    def swap(self, *args):
        """swap(self, v)"""
        return _biolccc.ChemicalGroupVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _biolccc.ChemicalGroupVector_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _biolccc.ChemicalGroupVector_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _biolccc.ChemicalGroupVector_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _biolccc.ChemicalGroupVector_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _biolccc.ChemicalGroupVector_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _biolccc.ChemicalGroupVector_pop_back(self)

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

    def __init__(self, *args): 
        """
        __init__(self) -> ChemicalGroupVector
        __init__(self, arg0) -> ChemicalGroupVector
        __init__(self, size) -> ChemicalGroupVector
        __init__(self, size, value) -> ChemicalGroupVector
        """
        this = _biolccc.new_ChemicalGroupVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, x)"""
        return _biolccc.ChemicalGroupVector_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _biolccc.ChemicalGroupVector_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _biolccc.ChemicalGroupVector_back(self)

    def assign(self, *args):
        """assign(self, n, x)"""
        return _biolccc.ChemicalGroupVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, new_size)
        resize(self, new_size, x)
        """
        return _biolccc.ChemicalGroupVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, pos, x) -> iterator
        insert(self, pos, n, x)
        """
        return _biolccc.ChemicalGroupVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, n)"""
        return _biolccc.ChemicalGroupVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> size_type"""
        return _biolccc.ChemicalGroupVector_capacity(self)

    __swig_destroy__ = _biolccc.delete_ChemicalGroupVector
    __del__ = lambda self : None;
ChemicalGroupVector_swigregister = _biolccc.ChemicalGroupVector_swigregister
ChemicalGroupVector_swigregister(ChemicalGroupVector)

class DoubleVector(_object):
    """Proxy of C++ std::vector<(double)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoubleVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _biolccc.DoubleVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _biolccc.DoubleVector___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _biolccc.DoubleVector___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _biolccc.DoubleVector___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _biolccc.DoubleVector_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, i, j) -> DoubleVector"""
        return _biolccc.DoubleVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, i, j, v)"""
        return _biolccc.DoubleVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, i, j)"""
        return _biolccc.DoubleVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, i)
        __delitem__(self, slice)
        """
        return _biolccc.DoubleVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, slice) -> DoubleVector
        __getitem__(self, i) -> value_type
        """
        return _biolccc.DoubleVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, slice, v)
        __setitem__(self, i, x)
        """
        return _biolccc.DoubleVector___setitem__(self, *args)

    def append(self, *args):
        """append(self, x)"""
        return _biolccc.DoubleVector_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _biolccc.DoubleVector_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _biolccc.DoubleVector_size(self)

    def clear(self):
        """clear(self)"""
        return _biolccc.DoubleVector_clear(self)

    def swap(self, *args):
        """swap(self, v)"""
        return _biolccc.DoubleVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _biolccc.DoubleVector_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _biolccc.DoubleVector_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _biolccc.DoubleVector_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _biolccc.DoubleVector_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _biolccc.DoubleVector_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _biolccc.DoubleVector_pop_back(self)

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

    def __init__(self, *args): 
        """
        __init__(self) -> DoubleVector
        __init__(self, arg0) -> DoubleVector
        __init__(self, size) -> DoubleVector
        __init__(self, size, value) -> DoubleVector
        """
        this = _biolccc.new_DoubleVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, x)"""
        return _biolccc.DoubleVector_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _biolccc.DoubleVector_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _biolccc.DoubleVector_back(self)

    def assign(self, *args):
        """assign(self, n, x)"""
        return _biolccc.DoubleVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, new_size)
        resize(self, new_size, x)
        """
        return _biolccc.DoubleVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, pos, x) -> iterator
        insert(self, pos, n, x)
        """
        return _biolccc.DoubleVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, n)"""
        return _biolccc.DoubleVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> size_type"""
        return _biolccc.DoubleVector_capacity(self)

    __swig_destroy__ = _biolccc.delete_DoubleVector
    __del__ = lambda self : None;
DoubleVector_swigregister = _biolccc.DoubleVector_swigregister
DoubleVector_swigregister(DoubleVector)

class StringChemicalGroupMap(_object):
    """Proxy of C++ std::map<(std::string,BioLCCC::ChemicalGroup)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringChemicalGroupMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringChemicalGroupMap, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _biolccc.StringChemicalGroupMap_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _biolccc.StringChemicalGroupMap___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _biolccc.StringChemicalGroupMap___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _biolccc.StringChemicalGroupMap___len__(self)

    def __getitem__(self, *args):
        """__getitem__(self, key) -> mapped_type"""
        return _biolccc.StringChemicalGroupMap___getitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(self, key)"""
        return _biolccc.StringChemicalGroupMap___delitem__(self, *args)

    def has_key(self, *args):
        """has_key(self, key) -> bool"""
        return _biolccc.StringChemicalGroupMap_has_key(self, *args)

    def keys(self):
        """keys(self) -> PyObject"""
        return _biolccc.StringChemicalGroupMap_keys(self)

    def values(self):
        """values(self) -> PyObject"""
        return _biolccc.StringChemicalGroupMap_values(self)

    def items(self):
        """items(self) -> PyObject"""
        return _biolccc.StringChemicalGroupMap_items(self)

    def __contains__(self, *args):
        """__contains__(self, key) -> bool"""
        return _biolccc.StringChemicalGroupMap___contains__(self, *args)

    def key_iterator(self):
        """key_iterator(self) -> SwigPyIterator"""
        return _biolccc.StringChemicalGroupMap_key_iterator(self)

    def value_iterator(self):
        """value_iterator(self) -> SwigPyIterator"""
        return _biolccc.StringChemicalGroupMap_value_iterator(self)

    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __setitem__(self, *args):
        """__setitem__(self, key, x)"""
        return _biolccc.StringChemicalGroupMap___setitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, arg0) -> StringChemicalGroupMap
        __init__(self) -> StringChemicalGroupMap
        __init__(self, arg0) -> StringChemicalGroupMap
        """
        this = _biolccc.new_StringChemicalGroupMap(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self):
        """empty(self) -> bool"""
        return _biolccc.StringChemicalGroupMap_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _biolccc.StringChemicalGroupMap_size(self)

    def clear(self):
        """clear(self)"""
        return _biolccc.StringChemicalGroupMap_clear(self)

    def swap(self, *args):
        """swap(self, v)"""
        return _biolccc.StringChemicalGroupMap_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _biolccc.StringChemicalGroupMap_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _biolccc.StringChemicalGroupMap_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _biolccc.StringChemicalGroupMap_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _biolccc.StringChemicalGroupMap_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _biolccc.StringChemicalGroupMap_rend(self)

    def count(self, *args):
        """count(self, x) -> size_type"""
        return _biolccc.StringChemicalGroupMap_count(self, *args)

    def erase(self, *args):
        """
        erase(self, x) -> size_type
        erase(self, position)
        erase(self, first, last)
        """
        return _biolccc.StringChemicalGroupMap_erase(self, *args)

    def find(self, *args):
        """find(self, x) -> iterator"""
        return _biolccc.StringChemicalGroupMap_find(self, *args)

    def lower_bound(self, *args):
        """lower_bound(self, x) -> iterator"""
        return _biolccc.StringChemicalGroupMap_lower_bound(self, *args)

    def upper_bound(self, *args):
        """upper_bound(self, x) -> iterator"""
        return _biolccc.StringChemicalGroupMap_upper_bound(self, *args)

    def __str__(self):
        return str(dict(self))

    def __repr__(self):
        return str(dict(self))

    def __eq__(self, other):
        return dict(self) == dict(other)

    __swig_destroy__ = _biolccc.delete_StringChemicalGroupMap
    __del__ = lambda self : None;
StringChemicalGroupMap_swigregister = _biolccc.StringChemicalGroupMap_swigregister
StringChemicalGroupMap_swigregister(StringChemicalGroupMap)

class StringChemicalGroupPtrMap(_object):
    """Proxy of C++ std::map<(std::string,p.BioLCCC::ChemicalGroup)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringChemicalGroupPtrMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringChemicalGroupPtrMap, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _biolccc.StringChemicalGroupPtrMap_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _biolccc.StringChemicalGroupPtrMap___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _biolccc.StringChemicalGroupPtrMap___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _biolccc.StringChemicalGroupPtrMap___len__(self)

    def __getitem__(self, *args):
        """__getitem__(self, key) -> mapped_type"""
        return _biolccc.StringChemicalGroupPtrMap___getitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(self, key)"""
        return _biolccc.StringChemicalGroupPtrMap___delitem__(self, *args)

    def has_key(self, *args):
        """has_key(self, key) -> bool"""
        return _biolccc.StringChemicalGroupPtrMap_has_key(self, *args)

    def keys(self):
        """keys(self) -> PyObject"""
        return _biolccc.StringChemicalGroupPtrMap_keys(self)

    def values(self):
        """values(self) -> PyObject"""
        return _biolccc.StringChemicalGroupPtrMap_values(self)

    def items(self):
        """items(self) -> PyObject"""
        return _biolccc.StringChemicalGroupPtrMap_items(self)

    def __contains__(self, *args):
        """__contains__(self, key) -> bool"""
        return _biolccc.StringChemicalGroupPtrMap___contains__(self, *args)

    def key_iterator(self):
        """key_iterator(self) -> SwigPyIterator"""
        return _biolccc.StringChemicalGroupPtrMap_key_iterator(self)

    def value_iterator(self):
        """value_iterator(self) -> SwigPyIterator"""
        return _biolccc.StringChemicalGroupPtrMap_value_iterator(self)

    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __setitem__(self, *args):
        """__setitem__(self, key, x)"""
        return _biolccc.StringChemicalGroupPtrMap___setitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, arg0) -> StringChemicalGroupPtrMap
        __init__(self) -> StringChemicalGroupPtrMap
        __init__(self, arg0) -> StringChemicalGroupPtrMap
        """
        this = _biolccc.new_StringChemicalGroupPtrMap(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self):
        """empty(self) -> bool"""
        return _biolccc.StringChemicalGroupPtrMap_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _biolccc.StringChemicalGroupPtrMap_size(self)

    def clear(self):
        """clear(self)"""
        return _biolccc.StringChemicalGroupPtrMap_clear(self)

    def swap(self, *args):
        """swap(self, v)"""
        return _biolccc.StringChemicalGroupPtrMap_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _biolccc.StringChemicalGroupPtrMap_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _biolccc.StringChemicalGroupPtrMap_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _biolccc.StringChemicalGroupPtrMap_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _biolccc.StringChemicalGroupPtrMap_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _biolccc.StringChemicalGroupPtrMap_rend(self)

    def count(self, *args):
        """count(self, x) -> size_type"""
        return _biolccc.StringChemicalGroupPtrMap_count(self, *args)

    def erase(self, *args):
        """
        erase(self, x) -> size_type
        erase(self, position)
        erase(self, first, last)
        """
        return _biolccc.StringChemicalGroupPtrMap_erase(self, *args)

    def find(self, *args):
        """find(self, x) -> iterator"""
        return _biolccc.StringChemicalGroupPtrMap_find(self, *args)

    def lower_bound(self, *args):
        """lower_bound(self, x) -> iterator"""
        return _biolccc.StringChemicalGroupPtrMap_lower_bound(self, *args)

    def upper_bound(self, *args):
        """upper_bound(self, x) -> iterator"""
        return _biolccc.StringChemicalGroupPtrMap_upper_bound(self, *args)

    def __str__(self):
        return str(dict(self))

    def __repr__(self):
        return str(dict(self))

    def __eq__(self, other):
        return dict(self) == dict(other)

    __swig_destroy__ = _biolccc.delete_StringChemicalGroupPtrMap
    __del__ = lambda self : None;
StringChemicalGroupPtrMap_swigregister = _biolccc.StringChemicalGroupPtrMap_swigregister
StringChemicalGroupPtrMap_swigregister(StringChemicalGroupPtrMap)

class BioLCCCException(Exception):
    """Proxy of C++ BioLCCC::BioLCCCException class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BioLCCCException, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BioLCCCException, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, message) -> BioLCCCException"""
        this = _biolccc.new_BioLCCCException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _biolccc.delete_BioLCCCException
    __del__ = lambda self : None;
    def what(self):
        """what(self) -> char"""
        return _biolccc.BioLCCCException_what(self)

BioLCCCException_swigregister = _biolccc.BioLCCCException_swigregister
BioLCCCException_swigregister(BioLCCCException)

class ChemicalGroup(collections.MutableMapping, _object):
    """Proxy of C++ BioLCCC::ChemicalGroup class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChemicalGroup, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ChemicalGroup, name)
    __repr__ = _swig_repr
    def __init__(self, name = "", label = "", bindEnergy = 0.0, averageMass = 0.0, 
    monoisotopicMass = 0.0, bindArea = 1.0): 
        """
        __init__(self, name = "", label = "", bindEnergy = 0.0, averageMass = 0.0, 
            monoisotopicMass = 0.0, bindArea = 1.0) -> ChemicalGroup
        __init__(self, name = "", label = "", bindEnergy = 0.0, averageMass = 0.0, 
            monoisotopicMass = 0.0) -> ChemicalGroup
        __init__(self, name = "", label = "", bindEnergy = 0.0, averageMass = 0.0) -> ChemicalGroup
        __init__(self, name = "", label = "", bindEnergy = 0.0) -> ChemicalGroup
        __init__(self, name = "", label = "") -> ChemicalGroup
        __init__(self, name = "") -> ChemicalGroup
        __init__(self) -> ChemicalGroup
        """
        this = _biolccc.new_ChemicalGroup(name, label, bindEnergy, averageMass, monoisotopicMass, 
    bindArea)
        try: self.this.append(this)
        except: self.this = this
    def name(self):
        """name(self) -> string"""
        return _biolccc.ChemicalGroup_name(self)

    def label(self):
        """label(self) -> string"""
        return _biolccc.ChemicalGroup_label(self)

    def averageMass(self):
        """averageMass(self) -> double"""
        return _biolccc.ChemicalGroup_averageMass(self)

    def monoisotopicMass(self):
        """monoisotopicMass(self) -> double"""
        return _biolccc.ChemicalGroup_monoisotopicMass(self)

    def bindEnergy(self):
        """bindEnergy(self) -> double"""
        return _biolccc.ChemicalGroup_bindEnergy(self)

    def bindArea(self):
        """bindArea(self) -> double"""
        return _biolccc.ChemicalGroup_bindArea(self)

    def isNTerminal(self):
        """isNTerminal(self) -> bool"""
        return _biolccc.ChemicalGroup_isNTerminal(self)

    def isCTerminal(self):
        """isCTerminal(self) -> bool"""
        return _biolccc.ChemicalGroup_isCTerminal(self)

    def isAminoAcid(self):
        """isAminoAcid(self) -> bool"""
        return _biolccc.ChemicalGroup_isAminoAcid(self)

    def setName(self, *args):
        """setName(self, newName)"""
        return _biolccc.ChemicalGroup_setName(self, *args)

    def setBindEnergy(self, *args):
        """setBindEnergy(self, newBindEnergy)"""
        return _biolccc.ChemicalGroup_setBindEnergy(self, *args)

    def setBindArea(self, *args):
        """setBindArea(self, newBindArea)"""
        return _biolccc.ChemicalGroup_setBindArea(self, *args)

    def setAverageMass(self, *args):
        """setAverageMass(self, newAverageMass)"""
        return _biolccc.ChemicalGroup_setAverageMass(self, *args)

    def setMonoisotopicMass(self, *args):
        """setMonoisotopicMass(self, newMonoisotopicMass)"""
        return _biolccc.ChemicalGroup_setMonoisotopicMass(self, *args)

    def __eq__(self, other):
        return dict(self) == dict(other)

    def __str__(self):
        return str(dict(self))

    def __repr__(self):
        return str(dict(self))

    def __len__(self):
        return len(self._keys);

    def __iter__(self):
        return iter(self._keys)

    def __contains__(self, key):
        return key in self._keys 

    def __getitem__(self, key):
        return {
            'name' : self.name,
            'label': self.label,
            'bindEnergy': self.bindEnergy,
            'bindArea': self.bindArea,
            'averageMass': self.averageMass,
            'monoisotopicMass': self.monoisotopicMass,
        }[key]()

    def __raiseLabelException__(self, value):
        raise RuntimeError('Label cannot be set')

    def __setitem__(self, key, value):
        {
            'name' : self.setName,
            'label': self.__raiseLabelException__,
            'bindEnergy': self.setBindEnergy,
            'bindArea': self.setBindArea,
            'averageMass': self.setAverageMass,
            'monoisotopicMass': self.setMonoisotopicMass,
        }[key](value)

    def __delitem__(self, key):
        pass

    _keys = ['name', 'label', 'bindEnergy', 'bindArea', 'averageMass',
            'monoisotopicMass']

    def keys(self):
        return self._keys

    __swig_destroy__ = _biolccc.delete_ChemicalGroup
    __del__ = lambda self : None;
ChemicalGroup_swigregister = _biolccc.ChemicalGroup_swigregister
ChemicalGroup_swigregister(ChemicalGroup)

class ChemicalBasisException(BioLCCCException):
    """Proxy of C++ BioLCCC::ChemicalBasisException class"""
    __swig_setmethods__ = {}
    for _s in [BioLCCCException]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChemicalBasisException, name, value)
    __swig_getmethods__ = {}
    for _s in [BioLCCCException]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ChemicalBasisException, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, message) -> ChemicalBasisException"""
        this = _biolccc.new_ChemicalBasisException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _biolccc.delete_ChemicalBasisException
    __del__ = lambda self : None;
ChemicalBasisException_swigregister = _biolccc.ChemicalBasisException_swigregister
ChemicalBasisException_swigregister(ChemicalBasisException)

ROD = _biolccc.ROD
CHAIN = _biolccc.CHAIN
RP_ACN_TFA_CHAIN = _biolccc.RP_ACN_TFA_CHAIN
RP_ACN_FA_ROD = _biolccc.RP_ACN_FA_ROD
class ChemicalBasis(collections.MutableMapping, _object):
    """Proxy of C++ BioLCCC::ChemicalBasis class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChemicalBasis, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ChemicalBasis, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> ChemicalBasis
        __init__(self, predefinedChemicalBasisId) -> ChemicalBasis
        """
        this = _biolccc.new_ChemicalBasis(*args)
        try: self.this.append(this)
        except: self.this = this
    def __chemicalGroups__(self):
        """__chemicalGroups__(self) -> StringChemicalGroupMap"""
        return _biolccc.ChemicalBasis___chemicalGroups__(self)

    def defaultNTerminus(self):
        """defaultNTerminus(self) -> ChemicalGroup"""
        return _biolccc.ChemicalBasis_defaultNTerminus(self)

    def defaultCTerminus(self):
        """defaultCTerminus(self) -> ChemicalGroup"""
        return _biolccc.ChemicalBasis_defaultCTerminus(self)

    def addChemicalGroup(self, *args):
        """addChemicalGroup(self, newChemicalGroup)"""
        return _biolccc.ChemicalBasis_addChemicalGroup(self, *args)

    def removeChemicalGroup(self, *args):
        """removeChemicalGroup(self, label)"""
        return _biolccc.ChemicalBasis_removeChemicalGroup(self, *args)

    def clearChemicalGroups(self):
        """clearChemicalGroups(self)"""
        return _biolccc.ChemicalBasis_clearChemicalGroups(self)

    def secondSolventBindEnergy(self):
        """secondSolventBindEnergy(self) -> double"""
        return _biolccc.ChemicalBasis_secondSolventBindEnergy(self)

    def setSecondSolventBindEnergy(self, *args):
        """setSecondSolventBindEnergy(self, newEnergy)"""
        return _biolccc.ChemicalBasis_setSecondSolventBindEnergy(self, *args)

    def setPolymerModel(self, *args):
        """setPolymerModel(self, newModel)"""
        return _biolccc.ChemicalBasis_setPolymerModel(self, *args)

    def polymerModel(self):
        """polymerModel(self) -> PolymerModel"""
        return _biolccc.ChemicalBasis_polymerModel(self)

    def monomerLength(self):
        """monomerLength(self) -> double"""
        return _biolccc.ChemicalBasis_monomerLength(self)

    def setMonomerLength(self, *args):
        """setMonomerLength(self, newMonomerLength)"""
        return _biolccc.ChemicalBasis_setMonomerLength(self, *args)

    def kuhnLength(self):
        """kuhnLength(self) -> double"""
        return _biolccc.ChemicalBasis_kuhnLength(self)

    def setKuhnLength(self, *args):
        """setKuhnLength(self, newKuhnLength)"""
        return _biolccc.ChemicalBasis_setKuhnLength(self, *args)

    def adsorptionLayerWidth(self):
        """adsorptionLayerWidth(self) -> double"""
        return _biolccc.ChemicalBasis_adsorptionLayerWidth(self)

    def setAdsorptionLayerWidth(self, *args):
        """setAdsorptionLayerWidth(self, newAdsorptionLayerWidth)"""
        return _biolccc.ChemicalBasis_setAdsorptionLayerWidth(self, *args)

    def adsorptionLayerFactors(self):
        """adsorptionLayerFactors(self) -> DoubleVector"""
        return _biolccc.ChemicalBasis_adsorptionLayerFactors(self)

    def setAdsorptionLayerFactors(self, *args):
        """setAdsorptionLayerFactors(self, newAdsorptionLayerFactors)"""
        return _biolccc.ChemicalBasis_setAdsorptionLayerFactors(self, *args)

    def snyderApproximation(self):
        """snyderApproximation(self) -> bool"""
        return _biolccc.ChemicalBasis_snyderApproximation(self)

    def setSnyderApproximation(self, *args):
        """setSnyderApproximation(self, flag)"""
        return _biolccc.ChemicalBasis_setSnyderApproximation(self, *args)

    def specialRodModel(self):
        """specialRodModel(self) -> bool"""
        return _biolccc.ChemicalBasis_specialRodModel(self)

    def setSpecialRodModel(self, *args):
        """setSpecialRodModel(self, flag)"""
        return _biolccc.ChemicalBasis_setSpecialRodModel(self, *args)

    def neglectPartiallyDesorbedStates(self):
        """neglectPartiallyDesorbedStates(self) -> bool"""
        return _biolccc.ChemicalBasis_neglectPartiallyDesorbedStates(self)

    def setNeglectPartiallyDesorbedStates(self, *args):
        """setNeglectPartiallyDesorbedStates(self, flag)"""
        return _biolccc.ChemicalBasis_setNeglectPartiallyDesorbedStates(self, *args)

    def firstSolventDensity(self):
        """firstSolventDensity(self) -> double"""
        return _biolccc.ChemicalBasis_firstSolventDensity(self)

    def setFirstSolventDensity(self, *args):
        """setFirstSolventDensity(self, newFirstSolventDensity)"""
        return _biolccc.ChemicalBasis_setFirstSolventDensity(self, *args)

    def secondSolventDensity(self):
        """secondSolventDensity(self) -> double"""
        return _biolccc.ChemicalBasis_secondSolventDensity(self)

    def setSecondSolventDensity(self, *args):
        """setSecondSolventDensity(self, newSecondSolventDensity)"""
        return _biolccc.ChemicalBasis_setSecondSolventDensity(self, *args)

    def firstSolventAverageMass(self):
        """firstSolventAverageMass(self) -> double"""
        return _biolccc.ChemicalBasis_firstSolventAverageMass(self)

    def setFirstSolventAverageMass(self, *args):
        """setFirstSolventAverageMass(self, newFirstSolventAverageMass)"""
        return _biolccc.ChemicalBasis_setFirstSolventAverageMass(self, *args)

    def secondSolventAverageMass(self):
        """secondSolventAverageMass(self) -> double"""
        return _biolccc.ChemicalBasis_secondSolventAverageMass(self)

    def setSecondSolventAverageMass(self, *args):
        """setSecondSolventAverageMass(self, newSecondSolventAverageMass)"""
        return _biolccc.ChemicalBasis_setSecondSolventAverageMass(self, *args)

    def setPredefinedChemicalBasis(self, *args):
        """setPredefinedChemicalBasis(self, predefinedChemicalBasisId) -> ChemicalBasis"""
        return _biolccc.ChemicalBasis_setPredefinedChemicalBasis(self, *args)

    def __ptrChemicalGroups__(self):
        """__ptrChemicalGroups__(self) -> StringChemicalGroupPtrMap"""
        return _biolccc.ChemicalBasis___ptrChemicalGroups__(self)

    def __eq__(self, other):
        return dict(self) == dict(other)

    def __repr__(self):
        return str(dict(self))

    def __str__(self):
        return str(dict(self))

    def __len__(self):
        return len(self._keys);

    def __iter__(self):
        return iter(self._keys)

    def __contains__(self, key):
        return key in self._keys 

    def chemicalGroups(self):
        return self.__ptrChemicalGroups__()

    def __getitem__(self, key):
        return {
            'chemicalGroups': self.__ptrChemicalGroups__,
            'firstSolventDensity': self.firstSolventDensity,
            'firstSolventAverageMass': self.firstSolventAverageMass,
            'secondSolventDensity': self.secondSolventDensity,
            'secondSolventAverageMass': self.secondSolventAverageMass,
            'secondSolventBindEnergy': self.secondSolventBindEnergy,
            'adsorptionLayerWidth': self.adsorptionLayerWidth,
            'adsorptionLayerFactors': self.adsorptionLayerFactors,
            'kuhnLength': self.kuhnLength,
            'monomerLength': self.monomerLength,
            'polymerModel': self.polymerModel,
            'snyderApproximation': self.snyderApproximation,
            'specialRodModel': self.specialRodModel,
        }[key]()

    def __setitem__(self, key, value):
        {
            'chemicalGroups' : self.setChemicalGroups,
            'firstSolventDensity': self.setFirstSolventDensity,
            'firstSolventAverageMass': self.setFirstSolventAverageMass,
            'secondSolventDensity': self.setSecondSolventDensity,
            'secondSolventAverageMass': self.setSecondSolventAverageMass,
            'secondSolventBindEnergy': self.setSecondSolventBindEnergy,
            'adsorptionLayerWidth': self.setAdsorptionLayerWidth,
            'adsorptionLayerFactors': self.setAdsorptionLayerFactors,
            'kuhnLength': self.setKuhnLength,
            'monomerLength': self.setMonomerLength,
            'polymerModel': self.setPolymerModel,
            'snyderApproximation': self.setSnyderApproximation,
            'specialRodModel': self.setSpecialRodModel,
        }[key](value)

    def __delitem__(self, key):
        pass

    _keys = ['chemicalGroups', 'firstSolventDensity', 
             'firstSolventAverageMass',
             'secondSolventDensity', 'secondSolventAverageMass',
             'secondSolventBindEnergy', 'adsorptionLayerWidth', 
             'adsorptionLayerFactors', 'kuhnLength', 'monomerLength', 
             'polymerModel', 'snyderApproximation', 'specialRodModel']

    def keys(self):
        return self._keys

    def __getstate__(self):
        state_dict = {}
        for key in self:
            if key != 'chemicalGroups':
                state_dict[key] = self[key]
        state_dict['chemicalGroups'] = {}
        for key in self['chemicalGroups']:
            state_dict['chemicalGroups'][key] = (
                dict(self['chemicalGroups'][key]))
        return state_dict

    def __setstate__(self, state_dict):
        for key in state_dict:
            self[key] = state_dict[key]

    def __reduce__(self):
        return (ChemicalBasis, (), self.__getstate__(),)

    def setChemicalGroups(self, chemicalGroupsDict):
        self.clearChemicalGroups()
        for key, value in chemicalGroupsDict.items():
            if type(value).__name__ == 'dict':
                self.addChemicalGroup(
                    ChemicalGroup(
                        value['name'],
                        value['label'],
                        value['bindEnergy'],
                        value['averageMass'],
                        value['monoisotopicMass'],
                        value['bindArea']))
            elif type(value).__name__ == 'pyteomics.biolccc.ChemicalBasis':
                self.addChemicalGroup(value)
            else:
                raise Exception('pyteomics.biolccc', 'wrong type for ChemicalGroup')

    __swig_destroy__ = _biolccc.delete_ChemicalBasis
    __del__ = lambda self : None;
ChemicalBasis_swigregister = _biolccc.ChemicalBasis_swigregister
ChemicalBasis_swigregister(ChemicalBasis)

class GradientPointException(BioLCCCException):
    """Proxy of C++ BioLCCC::GradientPointException class"""
    __swig_setmethods__ = {}
    for _s in [BioLCCCException]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GradientPointException, name, value)
    __swig_getmethods__ = {}
    for _s in [BioLCCCException]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GradientPointException, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, message) -> GradientPointException"""
        this = _biolccc.new_GradientPointException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _biolccc.delete_GradientPointException
    __del__ = lambda self : None;
GradientPointException_swigregister = _biolccc.GradientPointException_swigregister
GradientPointException_swigregister(GradientPointException)

class GradientPoint(collections.MutableMapping, _object):
    """Proxy of C++ BioLCCC::GradientPoint class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GradientPoint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GradientPoint, name)
    __repr__ = _swig_repr
    def __init__(self, iTime = 0.0, iConcentrationB = 0.0): 
        """
        __init__(self, iTime = 0.0, iConcentrationB = 0.0) -> GradientPoint
        __init__(self, iTime = 0.0) -> GradientPoint
        __init__(self) -> GradientPoint
        """
        this = _biolccc.new_GradientPoint(iTime, iConcentrationB)
        try: self.this.append(this)
        except: self.this = this
    def time(self):
        """time(self) -> double"""
        return _biolccc.GradientPoint_time(self)

    def concentrationB(self):
        """concentrationB(self) -> double"""
        return _biolccc.GradientPoint_concentrationB(self)

    def setTime(self, *args):
        """setTime(self, newTime)"""
        return _biolccc.GradientPoint_setTime(self, *args)

    def setConcentrationB(self, *args):
        """setConcentrationB(self, newConcentrationB)"""
        return _biolccc.GradientPoint_setConcentrationB(self, *args)

    def __eq__(self, other):
        return dict(self) == dict(other)

    def __str__(self):
        return str(dict(self))

    def __repr__(self):
        return str(dict(self))

    def __len__(self):
        return len(self._keys);

    def __iter__(self):
        return iter(self._keys)

    def __contains__(self, key):
        return key in self._keys 

    def __getitem__(self, key):
        return {
            'time' : self.time,
            'concentrationB': self.concentrationB,
        }[key]()

    def __setitem__(self, key, value):
        {
            'time' : self.setName,
            'concentrationB': self.setConcentrationB,
        }[key](value)

    def __delitem__(self, key):
        pass

    _keys = ['time', 'concentrationB']

    def keys(self):
        return self._keys

    __swig_destroy__ = _biolccc.delete_GradientPoint
    __del__ = lambda self : None;
GradientPoint_swigregister = _biolccc.GradientPoint_swigregister
GradientPoint_swigregister(GradientPoint)

class GradientException(BioLCCCException):
    """Proxy of C++ BioLCCC::GradientException class"""
    __swig_setmethods__ = {}
    for _s in [BioLCCCException]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GradientException, name, value)
    __swig_getmethods__ = {}
    for _s in [BioLCCCException]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GradientException, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, message) -> GradientException"""
        this = _biolccc.new_GradientException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _biolccc.delete_GradientException
    __del__ = lambda self : None;
GradientException_swigregister = _biolccc.GradientException_swigregister
GradientException_swigregister(GradientException)

class Gradient(GradientPointVector):
    """Proxy of C++ BioLCCC::Gradient class"""
    __swig_setmethods__ = {}
    for _s in [GradientPointVector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Gradient, name, value)
    __swig_getmethods__ = {}
    for _s in [GradientPointVector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Gradient, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> Gradient
        __init__(self, initialConcentrationB, finalConcentrationB, time) -> Gradient
        """
        this = _biolccc.new_Gradient(*args)
        try: self.this.append(this)
        except: self.this = this
    def addPoint(self, *args):
        """
        addPoint(self, iPoint) -> Gradient
        addPoint(self, iTime, iConcentrationB) -> Gradient
        """
        return _biolccc.Gradient_addPoint(self, *args)

    def __str__(self):
        return str(list(self))

    def __repr__(self):
        return str(list(self))

    def __eq__(self, other):
        return list(self) == list(other)

    __swig_destroy__ = _biolccc.delete_Gradient
    __del__ = lambda self : None;
Gradient_swigregister = _biolccc.Gradient_swigregister
Gradient_swigregister(Gradient)

class ChromoConditionsException(BioLCCCException):
    """Proxy of C++ BioLCCC::ChromoConditionsException class"""
    __swig_setmethods__ = {}
    for _s in [BioLCCCException]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChromoConditionsException, name, value)
    __swig_getmethods__ = {}
    for _s in [BioLCCCException]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ChromoConditionsException, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, message) -> ChromoConditionsException"""
        this = _biolccc.new_ChromoConditionsException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _biolccc.delete_ChromoConditionsException
    __del__ = lambda self : None;
ChromoConditionsException_swigregister = _biolccc.ChromoConditionsException_swigregister
ChromoConditionsException_swigregister(ChromoConditionsException)

class ChromoConditions(collections.MutableMapping, _object):
    """Proxy of C++ BioLCCC::ChromoConditions class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChromoConditions, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ChromoConditions, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, iColumnLength = 150.0, iColumnDiameter = 0.075, iColumnPoreSize = 100.0, 
            iGradient = BioLCCC::Gradient(0.0, 50.0, 60.0), 
            iSecondSolventConcentrationA = 2.0, 
            iSecondSolventConcentrationB = 80.0, 
            iDelayTime = 0.0, iFlowRate = 0.0003, 
            iDV = 0.0, iColumnRelativeStrength = 1.0, iColumnVpToVtot = 0.5, 
            iColumnPorosity = 0.9, iTemperature = 293.0) -> ChromoConditions
        __init__(self, iColumnLength = 150.0, iColumnDiameter = 0.075, iColumnPoreSize = 100.0, 
            iGradient = BioLCCC::Gradient(0.0, 50.0, 60.0), 
            iSecondSolventConcentrationA = 2.0, 
            iSecondSolventConcentrationB = 80.0, 
            iDelayTime = 0.0, iFlowRate = 0.0003, 
            iDV = 0.0, iColumnRelativeStrength = 1.0, iColumnVpToVtot = 0.5, 
            iColumnPorosity = 0.9) -> ChromoConditions
        __init__(self, iColumnLength = 150.0, iColumnDiameter = 0.075, iColumnPoreSize = 100.0, 
            iGradient = BioLCCC::Gradient(0.0, 50.0, 60.0), 
            iSecondSolventConcentrationA = 2.0, 
            iSecondSolventConcentrationB = 80.0, 
            iDelayTime = 0.0, iFlowRate = 0.0003, 
            iDV = 0.0, iColumnRelativeStrength = 1.0, iColumnVpToVtot = 0.5) -> ChromoConditions
        __init__(self, iColumnLength = 150.0, iColumnDiameter = 0.075, iColumnPoreSize = 100.0, 
            iGradient = BioLCCC::Gradient(0.0, 50.0, 60.0), 
            iSecondSolventConcentrationA = 2.0, 
            iSecondSolventConcentrationB = 80.0, 
            iDelayTime = 0.0, iFlowRate = 0.0003, 
            iDV = 0.0, iColumnRelativeStrength = 1.0) -> ChromoConditions
        __init__(self, iColumnLength = 150.0, iColumnDiameter = 0.075, iColumnPoreSize = 100.0, 
            iGradient = BioLCCC::Gradient(0.0, 50.0, 60.0), 
            iSecondSolventConcentrationA = 2.0, 
            iSecondSolventConcentrationB = 80.0, 
            iDelayTime = 0.0, iFlowRate = 0.0003, 
            iDV = 0.0) -> ChromoConditions
        __init__(self, iColumnLength = 150.0, iColumnDiameter = 0.075, iColumnPoreSize = 100.0, 
            iGradient = BioLCCC::Gradient(0.0, 50.0, 60.0), 
            iSecondSolventConcentrationA = 2.0, 
            iSecondSolventConcentrationB = 80.0, 
            iDelayTime = 0.0, iFlowRate = 0.0003) -> ChromoConditions
        __init__(self, iColumnLength = 150.0, iColumnDiameter = 0.075, iColumnPoreSize = 100.0, 
            iGradient = BioLCCC::Gradient(0.0, 50.0, 60.0), 
            iSecondSolventConcentrationA = 2.0, 
            iSecondSolventConcentrationB = 80.0, 
            iDelayTime = 0.0) -> ChromoConditions
        __init__(self, iColumnLength = 150.0, iColumnDiameter = 0.075, iColumnPoreSize = 100.0, 
            iGradient = BioLCCC::Gradient(0.0, 50.0, 60.0), 
            iSecondSolventConcentrationA = 2.0, 
            iSecondSolventConcentrationB = 80.0) -> ChromoConditions
        __init__(self, iColumnLength = 150.0, iColumnDiameter = 0.075, iColumnPoreSize = 100.0, 
            iGradient = BioLCCC::Gradient(0.0, 50.0, 60.0), 
            iSecondSolventConcentrationA = 2.0) -> ChromoConditions
        __init__(self, iColumnLength = 150.0, iColumnDiameter = 0.075, iColumnPoreSize = 100.0, 
            iGradient = BioLCCC::Gradient(0.0, 50.0, 60.0)) -> ChromoConditions
        __init__(self, iColumnLength = 150.0, iColumnDiameter = 0.075, iColumnPoreSize = 100.0) -> ChromoConditions
        __init__(self, iColumnLength = 150.0, iColumnDiameter = 0.075) -> ChromoConditions
        __init__(self, iColumnLength = 150.0) -> ChromoConditions
        __init__(self) -> ChromoConditions
        """
        this = _biolccc.new_ChromoConditions(*args)
        try: self.this.append(this)
        except: self.this = this
    def columnLength(self):
        """columnLength(self) -> double"""
        return _biolccc.ChromoConditions_columnLength(self)

    def setColumnLength(self, *args):
        """setColumnLength(self, newColumnLength)"""
        return _biolccc.ChromoConditions_setColumnLength(self, *args)

    def columnDiameter(self):
        """columnDiameter(self) -> double"""
        return _biolccc.ChromoConditions_columnDiameter(self)

    def setColumnDiameter(self, *args):
        """setColumnDiameter(self, newColumnDiameter)"""
        return _biolccc.ChromoConditions_setColumnDiameter(self, *args)

    def columnPoreSize(self):
        """columnPoreSize(self) -> double"""
        return _biolccc.ChromoConditions_columnPoreSize(self)

    def setColumnPoreSize(self, *args):
        """setColumnPoreSize(self, newColumnPoreSize)"""
        return _biolccc.ChromoConditions_setColumnPoreSize(self, *args)

    def columnVpToVtot(self):
        """columnVpToVtot(self) -> double"""
        return _biolccc.ChromoConditions_columnVpToVtot(self)

    def setColumnVpToVtot(self, *args):
        """setColumnVpToVtot(self, newColumnVpToVtot)"""
        return _biolccc.ChromoConditions_setColumnVpToVtot(self, *args)

    def columnPorosity(self):
        """columnPorosity(self) -> double"""
        return _biolccc.ChromoConditions_columnPorosity(self)

    def setColumnPorosity(self, *args):
        """setColumnPorosity(self, newColumnPorosity)"""
        return _biolccc.ChromoConditions_setColumnPorosity(self, *args)

    def columnTotalVolume(self):
        """columnTotalVolume(self) -> double"""
        return _biolccc.ChromoConditions_columnTotalVolume(self)

    def columnInterstitialVolume(self):
        """columnInterstitialVolume(self) -> double"""
        return _biolccc.ChromoConditions_columnInterstitialVolume(self)

    def columnPoreVolume(self):
        """columnPoreVolume(self) -> double"""
        return _biolccc.ChromoConditions_columnPoreVolume(self)

    def temperature(self):
        """temperature(self) -> double"""
        return _biolccc.ChromoConditions_temperature(self)

    def setTemperature(self, *args):
        """setTemperature(self, newTemperature)"""
        return _biolccc.ChromoConditions_setTemperature(self, *args)

    def columnRelativeStrength(self):
        """columnRelativeStrength(self) -> double"""
        return _biolccc.ChromoConditions_columnRelativeStrength(self)

    def setColumnRelativeStrength(self, *args):
        """setColumnRelativeStrength(self, newColumnRelativeStrength)"""
        return _biolccc.ChromoConditions_setColumnRelativeStrength(self, *args)

    def flowRate(self):
        """flowRate(self) -> double"""
        return _biolccc.ChromoConditions_flowRate(self)

    def setFlowRate(self, *args):
        """setFlowRate(self, newFlowRate)"""
        return _biolccc.ChromoConditions_setFlowRate(self, *args)

    def dV(self):
        """dV(self) -> double"""
        return _biolccc.ChromoConditions_dV(self)

    def setDV(self, *args):
        """setDV(self, newDV)"""
        return _biolccc.ChromoConditions_setDV(self, *args)

    def delayTime(self):
        """delayTime(self) -> double"""
        return _biolccc.ChromoConditions_delayTime(self)

    def setDelayTime(self, *args):
        """setDelayTime(self, newDelayTime)"""
        return _biolccc.ChromoConditions_setDelayTime(self, *args)

    def secondSolventConcentrationA(self):
        """secondSolventConcentrationA(self) -> double"""
        return _biolccc.ChromoConditions_secondSolventConcentrationA(self)

    def setSecondSolventConcentrationA(self, *args):
        """setSecondSolventConcentrationA(self, newSecondSolventConcentrationA)"""
        return _biolccc.ChromoConditions_setSecondSolventConcentrationA(self, *args)

    def secondSolventConcentrationB(self):
        """secondSolventConcentrationB(self) -> double"""
        return _biolccc.ChromoConditions_secondSolventConcentrationB(self)

    def setSecondSolventConcentrationB(self, *args):
        """setSecondSolventConcentrationB(self, newSecondSolventConcentrationB)"""
        return _biolccc.ChromoConditions_setSecondSolventConcentrationB(self, *args)

    def gradient(self):
        """gradient(self) -> Gradient"""
        return _biolccc.ChromoConditions_gradient(self)

    def setGradient(self, *args):
        """setGradient(self, newGradient)"""
        return _biolccc.ChromoConditions_setGradient(self, *args)

    def mixingCorrection(self):
        """mixingCorrection(self) -> bool"""
        return _biolccc.ChromoConditions_mixingCorrection(self)

    def setMixingCorrection(self, *args):
        """setMixingCorrection(self, flag)"""
        return _biolccc.ChromoConditions_setMixingCorrection(self, *args)

    def SSConcentrations(self):
        """SSConcentrations(self) -> DoubleVector"""
        return _biolccc.ChromoConditions_SSConcentrations(self)

    def __eq__(self, other):
        return dict(self) == dict(other)

    def __str__(self):
        return str(dict(self))

    def __repr__(self):
        return str(dict(self))

    def __len__(self):
        return len(self._keys);

    def __iter__(self):
        return iter(self._keys)

    def __contains__(self, key):
        return key in self._keys 

    def __getitem__(self, key):
        return {
            'columnLength': self.columnLength,
            'columnDiameter': self.columnDiameter,
            'columnPoreSize': self.columnPoreSize,
            'columnRelativeStrength': self.columnRelativeStrength,
            'columnVpToVtot': self.columnVpToVtot,
            'columnPorosity': self.columnPorosity,
            'delayTime': self.delayTime,
            'dV': self.dV,
            'flowRate': self.flowRate,
            'gradient': self.gradient,
            'secondSolventConcentrationA':
                self.secondSolventConcentrationA,
            'secondSolventConcentrationB':
                self.secondSolventConcentrationB,
            'temperature': self.temperature,
            'mixingCorrection': self.mixingCorrection,
        }[key]()

    def __setitem__(self, key, value):
        return {
            'columnLength': self.setColumnLength,
            'columnDiameter': self.setColumnDiameter,
            'columnPoreSize': self.setColumnPoreSize,
            'columnRelativeStrength': self.setColumnRelativeStrength,
            'columnVpToVtot': self.setColumnVpToVtot,
            'columnPorosity': self.setColumnPorosity,
            'delayTime': self.setDelayTime,
            'dV': self.setDV,
            'flowRate': self.setFlowRate,
            'gradient': self.setGradient,
            'secondSolventConcentrationA':
                self.setSecondSolventConcentrationA,
            'secondSolventConcentrationB':
                self.setSecondSolventConcentrationB,
            'temperature': self.setTemperature,
            'mixingCorrection': self.setMixingCorrection,
        }[key](value)

    def __delitem__(self, key):
        pass

    _keys = ['columnLength', 'columnDiameter', 'columnPoreSize', 
             'gradient', 'secondSolventConcentrationA',
             'secondSolventConcentrationB', 'delayTime', 'flowRate',
             'dV', 'columnRelativeStrength', 'columnVpToVtot',
             'columnPorosity', 'temperature', 'mixingCorrection']

    def keys(self):
        return self._keys

    def __getstate__(self):
        state_dict = {}
        for key in self:
            if key != 'gradient':
                state_dict[key] = self[key]
        state_dict['gradient'] = []
        for point in self['gradient']:
            state_dict['gradient'].append(dict(point))
        return state_dict

    def __setstate__(self, state_dict):
        for key in state_dict:
            if key != 'gradient':
                self[key] = state_dict[key]
        gradient = Gradient()
        for point in state_dict['gradient']:
            if type(point).__name__ == 'dict':
                gradient.addPoint(
                    point['time'], point['concentrationB'])
            elif type(point).__name__ == 'pyteomics.biolccc.GradientPoint':
                gradient.addPoint(point)
            else:
                raise Exception('pyteomics.biolccc', 'wrong type for GradientPoint')
        self['gradient'] = gradient

    def __reduce__(self):
        return (ChromoConditions, (), self.__getstate__(),)

    __swig_destroy__ = _biolccc.delete_ChromoConditions
    __del__ = lambda self : None;
ChromoConditions_swigregister = _biolccc.ChromoConditions_swigregister
ChromoConditions_swigregister(ChromoConditions)


def fitSpline(*args):
  """fitSpline(x, y, n, y2)"""
  return _biolccc.fitSpline(*args)

def calculateSpline(*args):
  """calculateSpline(x, y, y2, n, x_in) -> double"""
  return _biolccc.calculateSpline(*args)

def linInterpolate(*args):
  """linInterpolate(x, y, n, x_in) -> double"""
  return _biolccc.linInterpolate(*args)

def polInterpolate(*args):
  """polInterpolate(x, y, n, x_in) -> double"""
  return _biolccc.polInterpolate(*args)

def partPolInterpolate(*args):
  """partPolInterpolate(x, y, n, n_part, x_in) -> double"""
  return _biolccc.partPolInterpolate(*args)

def solveMatrixEquation(*args):
  """solveMatrixEquation(m, rhs, n)"""
  return _biolccc.solveMatrixEquation(*args)

def fitPolynomial(*args):
  """fitPolynomial(x, y, n)"""
  return _biolccc.fitPolynomial(*args)

def calculatePolynomial(*args):
  """calculatePolynomial(coeffs, n, x) -> double"""
  return _biolccc.calculatePolynomial(*args)
class ParsingException(BioLCCCException):
    """Proxy of C++ BioLCCC::ParsingException class"""
    __swig_setmethods__ = {}
    for _s in [BioLCCCException]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ParsingException, name, value)
    __swig_getmethods__ = {}
    for _s in [BioLCCCException]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ParsingException, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, message) -> ParsingException"""
        this = _biolccc.new_ParsingException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _biolccc.delete_ParsingException
    __del__ = lambda self : None;
ParsingException_swigregister = _biolccc.ParsingException_swigregister
ParsingException_swigregister(ParsingException)


def parseSequence(*args):
  """parseSequence(source, chemBasis) -> ChemicalGroupVector"""
  return _biolccc.parseSequence(*args)

def calculateMonomerEnergyProfile(*args):
  """
    calculateMonomerEnergyProfile(parsedSequence, chemBasis, secondSolventConcentration, 
        columnRelativeStrength, temperature) -> DoubleVector
    """
  return _biolccc.calculateMonomerEnergyProfile(*args)

def calculateSegmentEnergyProfile(*args):
  """calculateSegmentEnergyProfile(monomerEnergyProfile, monomerLength, kuhnLength) -> DoubleVector"""
  return _biolccc.calculateSegmentEnergyProfile(*args)

def calculateBoltzmannFactorProfile(*args):
  """calculateBoltzmannFactorProfile(effectiveEnergyProfile) -> DoubleVector"""
  return _biolccc.calculateBoltzmannFactorProfile(*args)

def calculateKdChain(*args):
  """
    calculateKdChain(parsedSequence, secondSolventConcentration, chemBasis, 
        columnPoreSize, columnRelativeStrength, temperature) -> double
    """
  return _biolccc.calculateKdChain(*args)

def partitionFunctionRodPartiallySubmergedTermSpecial(*args):
  """partitionFunctionRodPartiallySubmergedTermSpecial(segmentLength, slitWidth, layerWidth, N, n1) -> double"""
  return _biolccc.partitionFunctionRodPartiallySubmergedTermSpecial(*args)

def partitionFunctionRodPartiallySubmergedTermGeneral(*args):
  """partitionFunctionRodPartiallySubmergedTermGeneral(segmentLength, slitWidth, layerWidth, N, n1, n2) -> double"""
  return _biolccc.partitionFunctionRodPartiallySubmergedTermGeneral(*args)

def rodAdsorptionEnergy(*args):
  """rodAdsorptionEnergy(rodEnergyProfile, n1, n2) -> double"""
  return _biolccc.rodAdsorptionEnergy(*args)

def partitionFunctionRodFreeSlit(*args):
  """partitionFunctionRodFreeSlit(rodLength, slitWidth) -> double"""
  return _biolccc.partitionFunctionRodFreeSlit(*args)

def partitionFunctionRodFreeVolume(*args):
  """partitionFunctionRodFreeVolume(rodLength, slitWidth) -> double"""
  return _biolccc.partitionFunctionRodFreeVolume(*args)

def calculateKdRod(*args):
  """
    calculateKdRod(parsedSequence, secondSolventConcentration, chemBasis, 
        columnPoreSize, columnRelativeStrength, temperature) -> double
    """
  return _biolccc.calculateKdRod(*args)

def calculateAverageMass(*args):
  """calculateAverageMass(sequence, chemBasis) -> double"""
  return _biolccc.calculateAverageMass(*args)

def calculateMonoisotopicMass(*args):
  """calculateMonoisotopicMass(sequence, chemBasis) -> double"""
  return _biolccc.calculateMonoisotopicMass(*args)


def partitionFunctionRodPartiallySubmergedGeneral(*args):
  """
    partitionFunctionRodPartiallySubmergedGeneral(segmentLength, slitWidth, layerWidth, rodEnergyProfile, 
        reversed = False) -> double
    partitionFunctionRodPartiallySubmergedGeneral(segmentLength, slitWidth, layerWidth, rodEnergyProfile) -> double
    """
  return _biolccc.partitionFunctionRodPartiallySubmergedGeneral(*args)

def partitionFunctionRodPartiallySubmergedSpecial(*args):
  """
    partitionFunctionRodPartiallySubmergedSpecial(segmentLength, slitWidth, layerWidth, rodEnergyProfile, 
        reversed = False) -> double
    partitionFunctionRodPartiallySubmergedSpecial(segmentLength, slitWidth, layerWidth, rodEnergyProfile) -> double
    """
  return _biolccc.partitionFunctionRodPartiallySubmergedSpecial(*args)
cvar = _biolccc.cvar
standardChromoConditions = cvar.standardChromoConditions
rpAcnTfaChain = cvar.rpAcnTfaChain
rpAcnFaRod = cvar.rpAcnFaRod

def calculateRT(*args):
  """
    calculateRT(sequence, chemBasis, conditions = standardChromoConditions, 
        numInterpolationPoints = 0, continueGradient = True, 
        backwardCompatibility = False) -> double
    calculateRT(sequence, chemBasis, conditions = standardChromoConditions, 
        numInterpolationPoints = 0, continueGradient = True) -> double
    calculateRT(sequence, chemBasis, conditions = standardChromoConditions, 
        numInterpolationPoints = 0) -> double
    calculateRT(sequence, chemBasis, conditions = standardChromoConditions) -> double
    calculateRT(sequence, chemBasis) -> double
    """
  return _biolccc.calculateRT(*args)

def calculateKd(*args):
  """
    calculateKd(sequence, secondSolventConcentration, chemBasis, columnPoreSize = 100.0, 
        columnRelativeStrength = 1.0, 
        temperature = 293.0) -> double
    calculateKd(sequence, secondSolventConcentration, chemBasis, columnPoreSize = 100.0, 
        columnRelativeStrength = 1.0) -> double
    calculateKd(sequence, secondSolventConcentration, chemBasis, columnPoreSize = 100.0) -> double
    calculateKd(sequence, secondSolventConcentration, chemBasis) -> double
    """
  return _biolccc.calculateKd(*args)

