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

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _vsp_g
else:
    import _vsp_g

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class SwigPyIterator(object):
    r"""Proxy of C++ swig::SwigPyIterator class."""

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

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

    def value(self):
        r"""value(SwigPyIterator self) -> PyObject *"""
        return _vsp_g.SwigPyIterator_value(self)

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

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

    def distance(self, x):
        r"""distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _vsp_g.SwigPyIterator_distance(self, x)

    def equal(self, x):
        r"""equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _vsp_g.SwigPyIterator_equal(self, x)

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

    def next(self):
        r"""next(SwigPyIterator self) -> PyObject *"""
        return _vsp_g.SwigPyIterator_next(self)

    def __next__(self):
        r"""__next__(SwigPyIterator self) -> PyObject *"""
        return _vsp_g.SwigPyIterator___next__(self)

    def previous(self):
        r"""previous(SwigPyIterator self) -> PyObject *"""
        return _vsp_g.SwigPyIterator_previous(self)

    def advance(self, n):
        r"""advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _vsp_g.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        r"""__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _vsp_g.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        r"""__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _vsp_g.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        r"""__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _vsp_g.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        r"""__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _vsp_g.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        r"""__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _vsp_g.SwigPyIterator___add__(self, n)

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

# Register SwigPyIterator in _vsp_g:
_vsp_g.SwigPyIterator_swigregister(SwigPyIterator)

class IntVector(object):
    r"""Proxy of C++ std::vector< int > class."""

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

    def iterator(self):
        r"""iterator(IntVector self) -> SwigPyIterator"""
        return _vsp_g.IntVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(IntVector self) -> bool"""
        return _vsp_g.IntVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(IntVector self) -> bool"""
        return _vsp_g.IntVector___bool__(self)

    def __len__(self):
        r"""__len__(IntVector self) -> std::vector< int >::size_type"""
        return _vsp_g.IntVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> IntVector"""
        return _vsp_g.IntVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
        __setslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, IntVector v)
        """
        return _vsp_g.IntVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"""
        return _vsp_g.IntVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(IntVector self, std::vector< int >::difference_type i)
        __delitem__(IntVector self, PySliceObject * slice)
        """
        return _vsp_g.IntVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(IntVector self, PySliceObject * slice) -> IntVector
        __getitem__(IntVector self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
        """
        return _vsp_g.IntVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(IntVector self, PySliceObject * slice, IntVector v)
        __setitem__(IntVector self, PySliceObject * slice)
        __setitem__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
        """
        return _vsp_g.IntVector___setitem__(self, *args)

    def pop(self):
        r"""pop(IntVector self) -> std::vector< int >::value_type"""
        return _vsp_g.IntVector_pop(self)

    def append(self, x):
        r"""append(IntVector self, std::vector< int >::value_type const & x)"""
        return _vsp_g.IntVector_append(self, x)

    def empty(self):
        r"""empty(IntVector self) -> bool"""
        return _vsp_g.IntVector_empty(self)

    def size(self):
        r"""size(IntVector self) -> std::vector< int >::size_type"""
        return _vsp_g.IntVector_size(self)

    def swap(self, v):
        r"""swap(IntVector self, IntVector v)"""
        return _vsp_g.IntVector_swap(self, v)

    def begin(self):
        r"""begin(IntVector self) -> std::vector< int >::iterator"""
        return _vsp_g.IntVector_begin(self)

    def end(self):
        r"""end(IntVector self) -> std::vector< int >::iterator"""
        return _vsp_g.IntVector_end(self)

    def rbegin(self):
        r"""rbegin(IntVector self) -> std::vector< int >::reverse_iterator"""
        return _vsp_g.IntVector_rbegin(self)

    def rend(self):
        r"""rend(IntVector self) -> std::vector< int >::reverse_iterator"""
        return _vsp_g.IntVector_rend(self)

    def clear(self):
        r"""clear(IntVector self)"""
        return _vsp_g.IntVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(IntVector self) -> std::vector< int >::allocator_type"""
        return _vsp_g.IntVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(IntVector self)"""
        return _vsp_g.IntVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(IntVector self, std::vector< int >::iterator pos) -> std::vector< int >::iterator
        erase(IntVector self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator
        """
        return _vsp_g.IntVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(IntVector self) -> IntVector
        __init__(IntVector self, IntVector other) -> IntVector
        __init__(IntVector self, std::vector< int >::size_type size) -> IntVector
        __init__(IntVector self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> IntVector
        """
        _vsp_g.IntVector_swiginit(self, _vsp_g.new_IntVector(*args))

    def push_back(self, x):
        r"""push_back(IntVector self, std::vector< int >::value_type const & x)"""
        return _vsp_g.IntVector_push_back(self, x)

    def front(self):
        r"""front(IntVector self) -> std::vector< int >::value_type const &"""
        return _vsp_g.IntVector_front(self)

    def back(self):
        r"""back(IntVector self) -> std::vector< int >::value_type const &"""
        return _vsp_g.IntVector_back(self)

    def assign(self, n, x):
        r"""assign(IntVector self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)"""
        return _vsp_g.IntVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(IntVector self, std::vector< int >::size_type new_size)
        resize(IntVector self, std::vector< int >::size_type new_size, std::vector< int >::value_type const & x)
        """
        return _vsp_g.IntVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(IntVector self, std::vector< int >::iterator pos, std::vector< int >::value_type const & x) -> std::vector< int >::iterator
        insert(IntVector self, std::vector< int >::iterator pos, std::vector< int >::size_type n, std::vector< int >::value_type const & x)
        """
        return _vsp_g.IntVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(IntVector self, std::vector< int >::size_type n)"""
        return _vsp_g.IntVector_reserve(self, n)

    def capacity(self):
        r"""capacity(IntVector self) -> std::vector< int >::size_type"""
        return _vsp_g.IntVector_capacity(self)
    __swig_destroy__ = _vsp_g.delete_IntVector

# Register IntVector in _vsp_g:
_vsp_g.IntVector_swigregister(IntVector)

class DoubleVector(object):
    r"""Proxy of C++ std::vector< double > class."""

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

    def iterator(self):
        r"""iterator(DoubleVector self) -> SwigPyIterator"""
        return _vsp_g.DoubleVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(DoubleVector self) -> bool"""
        return _vsp_g.DoubleVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(DoubleVector self) -> bool"""
        return _vsp_g.DoubleVector___bool__(self)

    def __len__(self):
        r"""__len__(DoubleVector self) -> std::vector< double >::size_type"""
        return _vsp_g.DoubleVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> DoubleVector"""
        return _vsp_g.DoubleVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
        __setslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, DoubleVector v)
        """
        return _vsp_g.DoubleVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"""
        return _vsp_g.DoubleVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(DoubleVector self, std::vector< double >::difference_type i)
        __delitem__(DoubleVector self, PySliceObject * slice)
        """
        return _vsp_g.DoubleVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(DoubleVector self, PySliceObject * slice) -> DoubleVector
        __getitem__(DoubleVector self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
        """
        return _vsp_g.DoubleVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(DoubleVector self, PySliceObject * slice, DoubleVector v)
        __setitem__(DoubleVector self, PySliceObject * slice)
        __setitem__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
        """
        return _vsp_g.DoubleVector___setitem__(self, *args)

    def pop(self):
        r"""pop(DoubleVector self) -> std::vector< double >::value_type"""
        return _vsp_g.DoubleVector_pop(self)

    def append(self, x):
        r"""append(DoubleVector self, std::vector< double >::value_type const & x)"""
        return _vsp_g.DoubleVector_append(self, x)

    def empty(self):
        r"""empty(DoubleVector self) -> bool"""
        return _vsp_g.DoubleVector_empty(self)

    def size(self):
        r"""size(DoubleVector self) -> std::vector< double >::size_type"""
        return _vsp_g.DoubleVector_size(self)

    def swap(self, v):
        r"""swap(DoubleVector self, DoubleVector v)"""
        return _vsp_g.DoubleVector_swap(self, v)

    def begin(self):
        r"""begin(DoubleVector self) -> std::vector< double >::iterator"""
        return _vsp_g.DoubleVector_begin(self)

    def end(self):
        r"""end(DoubleVector self) -> std::vector< double >::iterator"""
        return _vsp_g.DoubleVector_end(self)

    def rbegin(self):
        r"""rbegin(DoubleVector self) -> std::vector< double >::reverse_iterator"""
        return _vsp_g.DoubleVector_rbegin(self)

    def rend(self):
        r"""rend(DoubleVector self) -> std::vector< double >::reverse_iterator"""
        return _vsp_g.DoubleVector_rend(self)

    def clear(self):
        r"""clear(DoubleVector self)"""
        return _vsp_g.DoubleVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(DoubleVector self) -> std::vector< double >::allocator_type"""
        return _vsp_g.DoubleVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(DoubleVector self)"""
        return _vsp_g.DoubleVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(DoubleVector self, std::vector< double >::iterator pos) -> std::vector< double >::iterator
        erase(DoubleVector self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator
        """
        return _vsp_g.DoubleVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(DoubleVector self) -> DoubleVector
        __init__(DoubleVector self, DoubleVector other) -> DoubleVector
        __init__(DoubleVector self, std::vector< double >::size_type size) -> DoubleVector
        __init__(DoubleVector self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> DoubleVector
        """
        _vsp_g.DoubleVector_swiginit(self, _vsp_g.new_DoubleVector(*args))

    def push_back(self, x):
        r"""push_back(DoubleVector self, std::vector< double >::value_type const & x)"""
        return _vsp_g.DoubleVector_push_back(self, x)

    def front(self):
        r"""front(DoubleVector self) -> std::vector< double >::value_type const &"""
        return _vsp_g.DoubleVector_front(self)

    def back(self):
        r"""back(DoubleVector self) -> std::vector< double >::value_type const &"""
        return _vsp_g.DoubleVector_back(self)

    def assign(self, n, x):
        r"""assign(DoubleVector self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)"""
        return _vsp_g.DoubleVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(DoubleVector self, std::vector< double >::size_type new_size)
        resize(DoubleVector self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)
        """
        return _vsp_g.DoubleVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(DoubleVector self, std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator
        insert(DoubleVector self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)
        """
        return _vsp_g.DoubleVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(DoubleVector self, std::vector< double >::size_type n)"""
        return _vsp_g.DoubleVector_reserve(self, n)

    def capacity(self):
        r"""capacity(DoubleVector self) -> std::vector< double >::size_type"""
        return _vsp_g.DoubleVector_capacity(self)
    __swig_destroy__ = _vsp_g.delete_DoubleVector

# Register DoubleVector in _vsp_g:
_vsp_g.DoubleVector_swigregister(DoubleVector)

class StringVector(object):
    r"""Proxy of C++ std::vector< std::string > class."""

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

    def iterator(self):
        r"""iterator(StringVector self) -> SwigPyIterator"""
        return _vsp_g.StringVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(StringVector self) -> bool"""
        return _vsp_g.StringVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(StringVector self) -> bool"""
        return _vsp_g.StringVector___bool__(self)

    def __len__(self):
        r"""__len__(StringVector self) -> std::vector< std::string >::size_type"""
        return _vsp_g.StringVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> StringVector"""
        return _vsp_g.StringVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
        __setslice__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, StringVector v)
        """
        return _vsp_g.StringVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"""
        return _vsp_g.StringVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(StringVector self, std::vector< std::string >::difference_type i)
        __delitem__(StringVector self, PySliceObject * slice)
        """
        return _vsp_g.StringVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(StringVector self, PySliceObject * slice) -> StringVector
        __getitem__(StringVector self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
        """
        return _vsp_g.StringVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(StringVector self, PySliceObject * slice, StringVector v)
        __setitem__(StringVector self, PySliceObject * slice)
        __setitem__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
        """
        return _vsp_g.StringVector___setitem__(self, *args)

    def pop(self):
        r"""pop(StringVector self) -> std::vector< std::string >::value_type"""
        return _vsp_g.StringVector_pop(self)

    def append(self, x):
        r"""append(StringVector self, std::vector< std::string >::value_type const & x)"""
        return _vsp_g.StringVector_append(self, x)

    def empty(self):
        r"""empty(StringVector self) -> bool"""
        return _vsp_g.StringVector_empty(self)

    def size(self):
        r"""size(StringVector self) -> std::vector< std::string >::size_type"""
        return _vsp_g.StringVector_size(self)

    def swap(self, v):
        r"""swap(StringVector self, StringVector v)"""
        return _vsp_g.StringVector_swap(self, v)

    def begin(self):
        r"""begin(StringVector self) -> std::vector< std::string >::iterator"""
        return _vsp_g.StringVector_begin(self)

    def end(self):
        r"""end(StringVector self) -> std::vector< std::string >::iterator"""
        return _vsp_g.StringVector_end(self)

    def rbegin(self):
        r"""rbegin(StringVector self) -> std::vector< std::string >::reverse_iterator"""
        return _vsp_g.StringVector_rbegin(self)

    def rend(self):
        r"""rend(StringVector self) -> std::vector< std::string >::reverse_iterator"""
        return _vsp_g.StringVector_rend(self)

    def clear(self):
        r"""clear(StringVector self)"""
        return _vsp_g.StringVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(StringVector self) -> std::vector< std::string >::allocator_type"""
        return _vsp_g.StringVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(StringVector self)"""
        return _vsp_g.StringVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(StringVector self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator
        erase(StringVector self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator
        """
        return _vsp_g.StringVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(StringVector self) -> StringVector
        __init__(StringVector self, StringVector other) -> StringVector
        __init__(StringVector self, std::vector< std::string >::size_type size) -> StringVector
        __init__(StringVector self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> StringVector
        """
        _vsp_g.StringVector_swiginit(self, _vsp_g.new_StringVector(*args))

    def push_back(self, x):
        r"""push_back(StringVector self, std::vector< std::string >::value_type const & x)"""
        return _vsp_g.StringVector_push_back(self, x)

    def front(self):
        r"""front(StringVector self) -> std::vector< std::string >::value_type const &"""
        return _vsp_g.StringVector_front(self)

    def back(self):
        r"""back(StringVector self) -> std::vector< std::string >::value_type const &"""
        return _vsp_g.StringVector_back(self)

    def assign(self, n, x):
        r"""assign(StringVector self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)"""
        return _vsp_g.StringVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(StringVector self, std::vector< std::string >::size_type new_size)
        resize(StringVector self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)
        """
        return _vsp_g.StringVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(StringVector self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator
        insert(StringVector self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)
        """
        return _vsp_g.StringVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(StringVector self, std::vector< std::string >::size_type n)"""
        return _vsp_g.StringVector_reserve(self, n)

    def capacity(self):
        r"""capacity(StringVector self) -> std::vector< std::string >::size_type"""
        return _vsp_g.StringVector_capacity(self)
    __swig_destroy__ = _vsp_g.delete_StringVector

# Register StringVector in _vsp_g:
_vsp_g.StringVector_swigregister(StringVector)

class BoolVector(object):
    r"""Proxy of C++ std::vector< bool > class."""

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

    def iterator(self):
        r"""iterator(BoolVector self) -> SwigPyIterator"""
        return _vsp_g.BoolVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(BoolVector self) -> bool"""
        return _vsp_g.BoolVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(BoolVector self) -> bool"""
        return _vsp_g.BoolVector___bool__(self)

    def __len__(self):
        r"""__len__(BoolVector self) -> std::vector< bool >::size_type"""
        return _vsp_g.BoolVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(BoolVector self, std::vector< bool >::difference_type i, std::vector< bool >::difference_type j) -> BoolVector"""
        return _vsp_g.BoolVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(BoolVector self, std::vector< bool >::difference_type i, std::vector< bool >::difference_type j)
        __setslice__(BoolVector self, std::vector< bool >::difference_type i, std::vector< bool >::difference_type j, BoolVector v)
        """
        return _vsp_g.BoolVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(BoolVector self, std::vector< bool >::difference_type i, std::vector< bool >::difference_type j)"""
        return _vsp_g.BoolVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(BoolVector self, std::vector< bool >::difference_type i)
        __delitem__(BoolVector self, PySliceObject * slice)
        """
        return _vsp_g.BoolVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(BoolVector self, PySliceObject * slice) -> BoolVector
        __getitem__(BoolVector self, std::vector< bool >::difference_type i) -> std::vector< bool >::value_type
        """
        return _vsp_g.BoolVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(BoolVector self, PySliceObject * slice, BoolVector v)
        __setitem__(BoolVector self, PySliceObject * slice)
        __setitem__(BoolVector self, std::vector< bool >::difference_type i, std::vector< bool >::value_type x)
        """
        return _vsp_g.BoolVector___setitem__(self, *args)

    def pop(self):
        r"""pop(BoolVector self) -> std::vector< bool >::value_type"""
        return _vsp_g.BoolVector_pop(self)

    def append(self, x):
        r"""append(BoolVector self, std::vector< bool >::value_type x)"""
        return _vsp_g.BoolVector_append(self, x)

    def empty(self):
        r"""empty(BoolVector self) -> bool"""
        return _vsp_g.BoolVector_empty(self)

    def size(self):
        r"""size(BoolVector self) -> std::vector< bool >::size_type"""
        return _vsp_g.BoolVector_size(self)

    def swap(self, v):
        r"""swap(BoolVector self, BoolVector v)"""
        return _vsp_g.BoolVector_swap(self, v)

    def begin(self):
        r"""begin(BoolVector self) -> std::vector< bool >::iterator"""
        return _vsp_g.BoolVector_begin(self)

    def end(self):
        r"""end(BoolVector self) -> std::vector< bool >::iterator"""
        return _vsp_g.BoolVector_end(self)

    def rbegin(self):
        r"""rbegin(BoolVector self) -> std::vector< bool >::reverse_iterator"""
        return _vsp_g.BoolVector_rbegin(self)

    def rend(self):
        r"""rend(BoolVector self) -> std::vector< bool >::reverse_iterator"""
        return _vsp_g.BoolVector_rend(self)

    def clear(self):
        r"""clear(BoolVector self)"""
        return _vsp_g.BoolVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(BoolVector self) -> std::vector< bool >::allocator_type"""
        return _vsp_g.BoolVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(BoolVector self)"""
        return _vsp_g.BoolVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(BoolVector self, std::vector< bool >::iterator pos) -> std::vector< bool >::iterator
        erase(BoolVector self, std::vector< bool >::iterator first, std::vector< bool >::iterator last) -> std::vector< bool >::iterator
        """
        return _vsp_g.BoolVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(BoolVector self) -> BoolVector
        __init__(BoolVector self, BoolVector other) -> BoolVector
        __init__(BoolVector self, std::vector< bool >::size_type size) -> BoolVector
        __init__(BoolVector self, std::vector< bool >::size_type size, std::vector< bool >::value_type value) -> BoolVector
        """
        _vsp_g.BoolVector_swiginit(self, _vsp_g.new_BoolVector(*args))

    def push_back(self, x):
        r"""push_back(BoolVector self, std::vector< bool >::value_type x)"""
        return _vsp_g.BoolVector_push_back(self, x)

    def front(self):
        r"""front(BoolVector self) -> std::vector< bool >::value_type"""
        return _vsp_g.BoolVector_front(self)

    def back(self):
        r"""back(BoolVector self) -> std::vector< bool >::value_type"""
        return _vsp_g.BoolVector_back(self)

    def assign(self, n, x):
        r"""assign(BoolVector self, std::vector< bool >::size_type n, std::vector< bool >::value_type x)"""
        return _vsp_g.BoolVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(BoolVector self, std::vector< bool >::size_type new_size)
        resize(BoolVector self, std::vector< bool >::size_type new_size, std::vector< bool >::value_type x)
        """
        return _vsp_g.BoolVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(BoolVector self, std::vector< bool >::iterator pos, std::vector< bool >::value_type x) -> std::vector< bool >::iterator
        insert(BoolVector self, std::vector< bool >::iterator pos, std::vector< bool >::size_type n, std::vector< bool >::value_type x)
        """
        return _vsp_g.BoolVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(BoolVector self, std::vector< bool >::size_type n)"""
        return _vsp_g.BoolVector_reserve(self, n)

    def capacity(self):
        r"""capacity(BoolVector self) -> std::vector< bool >::size_type"""
        return _vsp_g.BoolVector_capacity(self)
    __swig_destroy__ = _vsp_g.delete_BoolVector

# Register BoolVector in _vsp_g:
_vsp_g.BoolVector_swigregister(BoolVector)

class StringVecVec(object):
    r"""Proxy of C++ std::vector< std::vector< std::string > > class."""

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

    def iterator(self):
        r"""iterator(StringVecVec self) -> SwigPyIterator"""
        return _vsp_g.StringVecVec_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(StringVecVec self) -> bool"""
        return _vsp_g.StringVecVec___nonzero__(self)

    def __bool__(self):
        r"""__bool__(StringVecVec self) -> bool"""
        return _vsp_g.StringVecVec___bool__(self)

    def __len__(self):
        r"""__len__(StringVecVec self) -> std::vector< std::vector< std::string > >::size_type"""
        return _vsp_g.StringVecVec___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(StringVecVec self, std::vector< std::vector< std::string > >::difference_type i, std::vector< std::vector< std::string > >::difference_type j) -> StringVecVec"""
        return _vsp_g.StringVecVec___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(StringVecVec self, std::vector< std::vector< std::string > >::difference_type i, std::vector< std::vector< std::string > >::difference_type j)
        __setslice__(StringVecVec self, std::vector< std::vector< std::string > >::difference_type i, std::vector< std::vector< std::string > >::difference_type j, StringVecVec v)
        """
        return _vsp_g.StringVecVec___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(StringVecVec self, std::vector< std::vector< std::string > >::difference_type i, std::vector< std::vector< std::string > >::difference_type j)"""
        return _vsp_g.StringVecVec___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(StringVecVec self, std::vector< std::vector< std::string > >::difference_type i)
        __delitem__(StringVecVec self, PySliceObject * slice)
        """
        return _vsp_g.StringVecVec___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(StringVecVec self, PySliceObject * slice) -> StringVecVec
        __getitem__(StringVecVec self, std::vector< std::vector< std::string > >::difference_type i) -> StringVector
        """
        return _vsp_g.StringVecVec___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(StringVecVec self, PySliceObject * slice, StringVecVec v)
        __setitem__(StringVecVec self, PySliceObject * slice)
        __setitem__(StringVecVec self, std::vector< std::vector< std::string > >::difference_type i, StringVector x)
        """
        return _vsp_g.StringVecVec___setitem__(self, *args)

    def pop(self):
        r"""pop(StringVecVec self) -> StringVector"""
        return _vsp_g.StringVecVec_pop(self)

    def append(self, x):
        r"""append(StringVecVec self, StringVector x)"""
        return _vsp_g.StringVecVec_append(self, x)

    def empty(self):
        r"""empty(StringVecVec self) -> bool"""
        return _vsp_g.StringVecVec_empty(self)

    def size(self):
        r"""size(StringVecVec self) -> std::vector< std::vector< std::string > >::size_type"""
        return _vsp_g.StringVecVec_size(self)

    def swap(self, v):
        r"""swap(StringVecVec self, StringVecVec v)"""
        return _vsp_g.StringVecVec_swap(self, v)

    def begin(self):
        r"""begin(StringVecVec self) -> std::vector< std::vector< std::string > >::iterator"""
        return _vsp_g.StringVecVec_begin(self)

    def end(self):
        r"""end(StringVecVec self) -> std::vector< std::vector< std::string > >::iterator"""
        return _vsp_g.StringVecVec_end(self)

    def rbegin(self):
        r"""rbegin(StringVecVec self) -> std::vector< std::vector< std::string > >::reverse_iterator"""
        return _vsp_g.StringVecVec_rbegin(self)

    def rend(self):
        r"""rend(StringVecVec self) -> std::vector< std::vector< std::string > >::reverse_iterator"""
        return _vsp_g.StringVecVec_rend(self)

    def clear(self):
        r"""clear(StringVecVec self)"""
        return _vsp_g.StringVecVec_clear(self)

    def get_allocator(self):
        r"""get_allocator(StringVecVec self) -> std::vector< std::vector< std::string > >::allocator_type"""
        return _vsp_g.StringVecVec_get_allocator(self)

    def pop_back(self):
        r"""pop_back(StringVecVec self)"""
        return _vsp_g.StringVecVec_pop_back(self)

    def erase(self, *args):
        r"""
        erase(StringVecVec self, std::vector< std::vector< std::string > >::iterator pos) -> std::vector< std::vector< std::string > >::iterator
        erase(StringVecVec self, std::vector< std::vector< std::string > >::iterator first, std::vector< std::vector< std::string > >::iterator last) -> std::vector< std::vector< std::string > >::iterator
        """
        return _vsp_g.StringVecVec_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(StringVecVec self) -> StringVecVec
        __init__(StringVecVec self, StringVecVec other) -> StringVecVec
        __init__(StringVecVec self, std::vector< std::vector< std::string > >::size_type size) -> StringVecVec
        __init__(StringVecVec self, std::vector< std::vector< std::string > >::size_type size, StringVector value) -> StringVecVec
        """
        _vsp_g.StringVecVec_swiginit(self, _vsp_g.new_StringVecVec(*args))

    def push_back(self, x):
        r"""push_back(StringVecVec self, StringVector x)"""
        return _vsp_g.StringVecVec_push_back(self, x)

    def front(self):
        r"""front(StringVecVec self) -> StringVector"""
        return _vsp_g.StringVecVec_front(self)

    def back(self):
        r"""back(StringVecVec self) -> StringVector"""
        return _vsp_g.StringVecVec_back(self)

    def assign(self, n, x):
        r"""assign(StringVecVec self, std::vector< std::vector< std::string > >::size_type n, StringVector x)"""
        return _vsp_g.StringVecVec_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(StringVecVec self, std::vector< std::vector< std::string > >::size_type new_size)
        resize(StringVecVec self, std::vector< std::vector< std::string > >::size_type new_size, StringVector x)
        """
        return _vsp_g.StringVecVec_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(StringVecVec self, std::vector< std::vector< std::string > >::iterator pos, StringVector x) -> std::vector< std::vector< std::string > >::iterator
        insert(StringVecVec self, std::vector< std::vector< std::string > >::iterator pos, std::vector< std::vector< std::string > >::size_type n, StringVector x)
        """
        return _vsp_g.StringVecVec_insert(self, *args)

    def reserve(self, n):
        r"""reserve(StringVecVec self, std::vector< std::vector< std::string > >::size_type n)"""
        return _vsp_g.StringVecVec_reserve(self, n)

    def capacity(self):
        r"""capacity(StringVecVec self) -> std::vector< std::vector< std::string > >::size_type"""
        return _vsp_g.StringVecVec_capacity(self)
    __swig_destroy__ = _vsp_g.delete_StringVecVec

# Register StringVecVec in _vsp_g:
_vsp_g.StringVecVec_swigregister(StringVecVec)

class IntVecVec(object):
    r"""Proxy of C++ std::vector< std::vector< int > > class."""

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

    def iterator(self):
        r"""iterator(IntVecVec self) -> SwigPyIterator"""
        return _vsp_g.IntVecVec_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(IntVecVec self) -> bool"""
        return _vsp_g.IntVecVec___nonzero__(self)

    def __bool__(self):
        r"""__bool__(IntVecVec self) -> bool"""
        return _vsp_g.IntVecVec___bool__(self)

    def __len__(self):
        r"""__len__(IntVecVec self) -> std::vector< std::vector< int > >::size_type"""
        return _vsp_g.IntVecVec___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(IntVecVec self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j) -> IntVecVec"""
        return _vsp_g.IntVecVec___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(IntVecVec self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j)
        __setslice__(IntVecVec self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j, IntVecVec v)
        """
        return _vsp_g.IntVecVec___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(IntVecVec self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j)"""
        return _vsp_g.IntVecVec___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(IntVecVec self, std::vector< std::vector< int > >::difference_type i)
        __delitem__(IntVecVec self, PySliceObject * slice)
        """
        return _vsp_g.IntVecVec___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(IntVecVec self, PySliceObject * slice) -> IntVecVec
        __getitem__(IntVecVec self, std::vector< std::vector< int > >::difference_type i) -> IntVector
        """
        return _vsp_g.IntVecVec___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(IntVecVec self, PySliceObject * slice, IntVecVec v)
        __setitem__(IntVecVec self, PySliceObject * slice)
        __setitem__(IntVecVec self, std::vector< std::vector< int > >::difference_type i, IntVector x)
        """
        return _vsp_g.IntVecVec___setitem__(self, *args)

    def pop(self):
        r"""pop(IntVecVec self) -> IntVector"""
        return _vsp_g.IntVecVec_pop(self)

    def append(self, x):
        r"""append(IntVecVec self, IntVector x)"""
        return _vsp_g.IntVecVec_append(self, x)

    def empty(self):
        r"""empty(IntVecVec self) -> bool"""
        return _vsp_g.IntVecVec_empty(self)

    def size(self):
        r"""size(IntVecVec self) -> std::vector< std::vector< int > >::size_type"""
        return _vsp_g.IntVecVec_size(self)

    def swap(self, v):
        r"""swap(IntVecVec self, IntVecVec v)"""
        return _vsp_g.IntVecVec_swap(self, v)

    def begin(self):
        r"""begin(IntVecVec self) -> std::vector< std::vector< int > >::iterator"""
        return _vsp_g.IntVecVec_begin(self)

    def end(self):
        r"""end(IntVecVec self) -> std::vector< std::vector< int > >::iterator"""
        return _vsp_g.IntVecVec_end(self)

    def rbegin(self):
        r"""rbegin(IntVecVec self) -> std::vector< std::vector< int > >::reverse_iterator"""
        return _vsp_g.IntVecVec_rbegin(self)

    def rend(self):
        r"""rend(IntVecVec self) -> std::vector< std::vector< int > >::reverse_iterator"""
        return _vsp_g.IntVecVec_rend(self)

    def clear(self):
        r"""clear(IntVecVec self)"""
        return _vsp_g.IntVecVec_clear(self)

    def get_allocator(self):
        r"""get_allocator(IntVecVec self) -> std::vector< std::vector< int > >::allocator_type"""
        return _vsp_g.IntVecVec_get_allocator(self)

    def pop_back(self):
        r"""pop_back(IntVecVec self)"""
        return _vsp_g.IntVecVec_pop_back(self)

    def erase(self, *args):
        r"""
        erase(IntVecVec self, std::vector< std::vector< int > >::iterator pos) -> std::vector< std::vector< int > >::iterator
        erase(IntVecVec self, std::vector< std::vector< int > >::iterator first, std::vector< std::vector< int > >::iterator last) -> std::vector< std::vector< int > >::iterator
        """
        return _vsp_g.IntVecVec_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(IntVecVec self) -> IntVecVec
        __init__(IntVecVec self, IntVecVec other) -> IntVecVec
        __init__(IntVecVec self, std::vector< std::vector< int > >::size_type size) -> IntVecVec
        __init__(IntVecVec self, std::vector< std::vector< int > >::size_type size, IntVector value) -> IntVecVec
        """
        _vsp_g.IntVecVec_swiginit(self, _vsp_g.new_IntVecVec(*args))

    def push_back(self, x):
        r"""push_back(IntVecVec self, IntVector x)"""
        return _vsp_g.IntVecVec_push_back(self, x)

    def front(self):
        r"""front(IntVecVec self) -> IntVector"""
        return _vsp_g.IntVecVec_front(self)

    def back(self):
        r"""back(IntVecVec self) -> IntVector"""
        return _vsp_g.IntVecVec_back(self)

    def assign(self, n, x):
        r"""assign(IntVecVec self, std::vector< std::vector< int > >::size_type n, IntVector x)"""
        return _vsp_g.IntVecVec_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(IntVecVec self, std::vector< std::vector< int > >::size_type new_size)
        resize(IntVecVec self, std::vector< std::vector< int > >::size_type new_size, IntVector x)
        """
        return _vsp_g.IntVecVec_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(IntVecVec self, std::vector< std::vector< int > >::iterator pos, IntVector x) -> std::vector< std::vector< int > >::iterator
        insert(IntVecVec self, std::vector< std::vector< int > >::iterator pos, std::vector< std::vector< int > >::size_type n, IntVector x)
        """
        return _vsp_g.IntVecVec_insert(self, *args)

    def reserve(self, n):
        r"""reserve(IntVecVec self, std::vector< std::vector< int > >::size_type n)"""
        return _vsp_g.IntVecVec_reserve(self, n)

    def capacity(self):
        r"""capacity(IntVecVec self) -> std::vector< std::vector< int > >::size_type"""
        return _vsp_g.IntVecVec_capacity(self)
    __swig_destroy__ = _vsp_g.delete_IntVecVec

# Register IntVecVec in _vsp_g:
_vsp_g.IntVecVec_swigregister(IntVecVec)

class DoubleVecVec(object):
    r"""Proxy of C++ std::vector< std::vector< double > > class."""

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

    def iterator(self):
        r"""iterator(DoubleVecVec self) -> SwigPyIterator"""
        return _vsp_g.DoubleVecVec_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(DoubleVecVec self) -> bool"""
        return _vsp_g.DoubleVecVec___nonzero__(self)

    def __bool__(self):
        r"""__bool__(DoubleVecVec self) -> bool"""
        return _vsp_g.DoubleVecVec___bool__(self)

    def __len__(self):
        r"""__len__(DoubleVecVec self) -> std::vector< std::vector< double > >::size_type"""
        return _vsp_g.DoubleVecVec___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(DoubleVecVec self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j) -> DoubleVecVec"""
        return _vsp_g.DoubleVecVec___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(DoubleVecVec self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)
        __setslice__(DoubleVecVec self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j, DoubleVecVec v)
        """
        return _vsp_g.DoubleVecVec___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(DoubleVecVec self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)"""
        return _vsp_g.DoubleVecVec___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(DoubleVecVec self, std::vector< std::vector< double > >::difference_type i)
        __delitem__(DoubleVecVec self, PySliceObject * slice)
        """
        return _vsp_g.DoubleVecVec___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(DoubleVecVec self, PySliceObject * slice) -> DoubleVecVec
        __getitem__(DoubleVecVec self, std::vector< std::vector< double > >::difference_type i) -> DoubleVector
        """
        return _vsp_g.DoubleVecVec___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(DoubleVecVec self, PySliceObject * slice, DoubleVecVec v)
        __setitem__(DoubleVecVec self, PySliceObject * slice)
        __setitem__(DoubleVecVec self, std::vector< std::vector< double > >::difference_type i, DoubleVector x)
        """
        return _vsp_g.DoubleVecVec___setitem__(self, *args)

    def pop(self):
        r"""pop(DoubleVecVec self) -> DoubleVector"""
        return _vsp_g.DoubleVecVec_pop(self)

    def append(self, x):
        r"""append(DoubleVecVec self, DoubleVector x)"""
        return _vsp_g.DoubleVecVec_append(self, x)

    def empty(self):
        r"""empty(DoubleVecVec self) -> bool"""
        return _vsp_g.DoubleVecVec_empty(self)

    def size(self):
        r"""size(DoubleVecVec self) -> std::vector< std::vector< double > >::size_type"""
        return _vsp_g.DoubleVecVec_size(self)

    def swap(self, v):
        r"""swap(DoubleVecVec self, DoubleVecVec v)"""
        return _vsp_g.DoubleVecVec_swap(self, v)

    def begin(self):
        r"""begin(DoubleVecVec self) -> std::vector< std::vector< double > >::iterator"""
        return _vsp_g.DoubleVecVec_begin(self)

    def end(self):
        r"""end(DoubleVecVec self) -> std::vector< std::vector< double > >::iterator"""
        return _vsp_g.DoubleVecVec_end(self)

    def rbegin(self):
        r"""rbegin(DoubleVecVec self) -> std::vector< std::vector< double > >::reverse_iterator"""
        return _vsp_g.DoubleVecVec_rbegin(self)

    def rend(self):
        r"""rend(DoubleVecVec self) -> std::vector< std::vector< double > >::reverse_iterator"""
        return _vsp_g.DoubleVecVec_rend(self)

    def clear(self):
        r"""clear(DoubleVecVec self)"""
        return _vsp_g.DoubleVecVec_clear(self)

    def get_allocator(self):
        r"""get_allocator(DoubleVecVec self) -> std::vector< std::vector< double > >::allocator_type"""
        return _vsp_g.DoubleVecVec_get_allocator(self)

    def pop_back(self):
        r"""pop_back(DoubleVecVec self)"""
        return _vsp_g.DoubleVecVec_pop_back(self)

    def erase(self, *args):
        r"""
        erase(DoubleVecVec self, std::vector< std::vector< double > >::iterator pos) -> std::vector< std::vector< double > >::iterator
        erase(DoubleVecVec self, std::vector< std::vector< double > >::iterator first, std::vector< std::vector< double > >::iterator last) -> std::vector< std::vector< double > >::iterator
        """
        return _vsp_g.DoubleVecVec_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(DoubleVecVec self) -> DoubleVecVec
        __init__(DoubleVecVec self, DoubleVecVec other) -> DoubleVecVec
        __init__(DoubleVecVec self, std::vector< std::vector< double > >::size_type size) -> DoubleVecVec
        __init__(DoubleVecVec self, std::vector< std::vector< double > >::size_type size, DoubleVector value) -> DoubleVecVec
        """
        _vsp_g.DoubleVecVec_swiginit(self, _vsp_g.new_DoubleVecVec(*args))

    def push_back(self, x):
        r"""push_back(DoubleVecVec self, DoubleVector x)"""
        return _vsp_g.DoubleVecVec_push_back(self, x)

    def front(self):
        r"""front(DoubleVecVec self) -> DoubleVector"""
        return _vsp_g.DoubleVecVec_front(self)

    def back(self):
        r"""back(DoubleVecVec self) -> DoubleVector"""
        return _vsp_g.DoubleVecVec_back(self)

    def assign(self, n, x):
        r"""assign(DoubleVecVec self, std::vector< std::vector< double > >::size_type n, DoubleVector x)"""
        return _vsp_g.DoubleVecVec_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(DoubleVecVec self, std::vector< std::vector< double > >::size_type new_size)
        resize(DoubleVecVec self, std::vector< std::vector< double > >::size_type new_size, DoubleVector x)
        """
        return _vsp_g.DoubleVecVec_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(DoubleVecVec self, std::vector< std::vector< double > >::iterator pos, DoubleVector x) -> std::vector< std::vector< double > >::iterator
        insert(DoubleVecVec self, std::vector< std::vector< double > >::iterator pos, std::vector< std::vector< double > >::size_type n, DoubleVector x)
        """
        return _vsp_g.DoubleVecVec_insert(self, *args)

    def reserve(self, n):
        r"""reserve(DoubleVecVec self, std::vector< std::vector< double > >::size_type n)"""
        return _vsp_g.DoubleVecVec_reserve(self, n)

    def capacity(self):
        r"""capacity(DoubleVecVec self) -> std::vector< std::vector< double > >::size_type"""
        return _vsp_g.DoubleVecVec_capacity(self)
    __swig_destroy__ = _vsp_g.delete_DoubleVecVec

# Register DoubleVecVec in _vsp_g:
_vsp_g.DoubleVecVec_swigregister(DoubleVecVec)

class Vec3dVec(object):
    r"""Proxy of C++ std::vector< vec3d > class."""

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

    def iterator(self):
        r"""iterator(Vec3dVec self) -> SwigPyIterator"""
        return _vsp_g.Vec3dVec_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(Vec3dVec self) -> bool"""
        return _vsp_g.Vec3dVec___nonzero__(self)

    def __bool__(self):
        r"""__bool__(Vec3dVec self) -> bool"""
        return _vsp_g.Vec3dVec___bool__(self)

    def __len__(self):
        r"""__len__(Vec3dVec self) -> std::vector< vec3d >::size_type"""
        return _vsp_g.Vec3dVec___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(Vec3dVec self, std::vector< vec3d >::difference_type i, std::vector< vec3d >::difference_type j) -> Vec3dVec"""
        return _vsp_g.Vec3dVec___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(Vec3dVec self, std::vector< vec3d >::difference_type i, std::vector< vec3d >::difference_type j)
        __setslice__(Vec3dVec self, std::vector< vec3d >::difference_type i, std::vector< vec3d >::difference_type j, Vec3dVec v)
        """
        return _vsp_g.Vec3dVec___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(Vec3dVec self, std::vector< vec3d >::difference_type i, std::vector< vec3d >::difference_type j)"""
        return _vsp_g.Vec3dVec___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(Vec3dVec self, std::vector< vec3d >::difference_type i)
        __delitem__(Vec3dVec self, PySliceObject * slice)
        """
        return _vsp_g.Vec3dVec___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(Vec3dVec self, PySliceObject * slice) -> Vec3dVec
        __getitem__(Vec3dVec self, std::vector< vec3d >::difference_type i) -> vec3d
        """
        return _vsp_g.Vec3dVec___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(Vec3dVec self, PySliceObject * slice, Vec3dVec v)
        __setitem__(Vec3dVec self, PySliceObject * slice)
        __setitem__(Vec3dVec self, std::vector< vec3d >::difference_type i, vec3d x)
        """
        return _vsp_g.Vec3dVec___setitem__(self, *args)

    def pop(self):
        r"""pop(Vec3dVec self) -> vec3d"""
        return _vsp_g.Vec3dVec_pop(self)

    def append(self, x):
        r"""append(Vec3dVec self, vec3d x)"""
        return _vsp_g.Vec3dVec_append(self, x)

    def empty(self):
        r"""empty(Vec3dVec self) -> bool"""
        return _vsp_g.Vec3dVec_empty(self)

    def size(self):
        r"""size(Vec3dVec self) -> std::vector< vec3d >::size_type"""
        return _vsp_g.Vec3dVec_size(self)

    def swap(self, v):
        r"""swap(Vec3dVec self, Vec3dVec v)"""
        return _vsp_g.Vec3dVec_swap(self, v)

    def begin(self):
        r"""begin(Vec3dVec self) -> std::vector< vec3d >::iterator"""
        return _vsp_g.Vec3dVec_begin(self)

    def end(self):
        r"""end(Vec3dVec self) -> std::vector< vec3d >::iterator"""
        return _vsp_g.Vec3dVec_end(self)

    def rbegin(self):
        r"""rbegin(Vec3dVec self) -> std::vector< vec3d >::reverse_iterator"""
        return _vsp_g.Vec3dVec_rbegin(self)

    def rend(self):
        r"""rend(Vec3dVec self) -> std::vector< vec3d >::reverse_iterator"""
        return _vsp_g.Vec3dVec_rend(self)

    def clear(self):
        r"""clear(Vec3dVec self)"""
        return _vsp_g.Vec3dVec_clear(self)

    def get_allocator(self):
        r"""get_allocator(Vec3dVec self) -> std::vector< vec3d >::allocator_type"""
        return _vsp_g.Vec3dVec_get_allocator(self)

    def pop_back(self):
        r"""pop_back(Vec3dVec self)"""
        return _vsp_g.Vec3dVec_pop_back(self)

    def erase(self, *args):
        r"""
        erase(Vec3dVec self, std::vector< vec3d >::iterator pos) -> std::vector< vec3d >::iterator
        erase(Vec3dVec self, std::vector< vec3d >::iterator first, std::vector< vec3d >::iterator last) -> std::vector< vec3d >::iterator
        """
        return _vsp_g.Vec3dVec_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(Vec3dVec self) -> Vec3dVec
        __init__(Vec3dVec self, Vec3dVec other) -> Vec3dVec
        __init__(Vec3dVec self, std::vector< vec3d >::size_type size) -> Vec3dVec
        __init__(Vec3dVec self, std::vector< vec3d >::size_type size, vec3d value) -> Vec3dVec
        """
        _vsp_g.Vec3dVec_swiginit(self, _vsp_g.new_Vec3dVec(*args))

    def push_back(self, x):
        r"""push_back(Vec3dVec self, vec3d x)"""
        return _vsp_g.Vec3dVec_push_back(self, x)

    def front(self):
        r"""front(Vec3dVec self) -> vec3d"""
        return _vsp_g.Vec3dVec_front(self)

    def back(self):
        r"""back(Vec3dVec self) -> vec3d"""
        return _vsp_g.Vec3dVec_back(self)

    def assign(self, n, x):
        r"""assign(Vec3dVec self, std::vector< vec3d >::size_type n, vec3d x)"""
        return _vsp_g.Vec3dVec_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(Vec3dVec self, std::vector< vec3d >::size_type new_size)
        resize(Vec3dVec self, std::vector< vec3d >::size_type new_size, vec3d x)
        """
        return _vsp_g.Vec3dVec_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(Vec3dVec self, std::vector< vec3d >::iterator pos, vec3d x) -> std::vector< vec3d >::iterator
        insert(Vec3dVec self, std::vector< vec3d >::iterator pos, std::vector< vec3d >::size_type n, vec3d x)
        """
        return _vsp_g.Vec3dVec_insert(self, *args)

    def reserve(self, n):
        r"""reserve(Vec3dVec self, std::vector< vec3d >::size_type n)"""
        return _vsp_g.Vec3dVec_reserve(self, n)

    def capacity(self):
        r"""capacity(Vec3dVec self) -> std::vector< vec3d >::size_type"""
        return _vsp_g.Vec3dVec_capacity(self)

    def as_numpy(self):
        return _vsp_g.Vec3dVec_as_numpy(self)
    __swig_destroy__ = _vsp_g.delete_Vec3dVec

# Register Vec3dVec in _vsp_g:
_vsp_g.Vec3dVec_swigregister(Vec3dVec)

class Matrix4dVec(object):
    r"""Proxy of C++ std::vector< Matrix4d > class."""

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

    def iterator(self):
        r"""iterator(Matrix4dVec self) -> SwigPyIterator"""
        return _vsp_g.Matrix4dVec_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(Matrix4dVec self) -> bool"""
        return _vsp_g.Matrix4dVec___nonzero__(self)

    def __bool__(self):
        r"""__bool__(Matrix4dVec self) -> bool"""
        return _vsp_g.Matrix4dVec___bool__(self)

    def __len__(self):
        r"""__len__(Matrix4dVec self) -> std::vector< Matrix4d >::size_type"""
        return _vsp_g.Matrix4dVec___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(Matrix4dVec self, std::vector< Matrix4d >::difference_type i, std::vector< Matrix4d >::difference_type j) -> Matrix4dVec"""
        return _vsp_g.Matrix4dVec___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(Matrix4dVec self, std::vector< Matrix4d >::difference_type i, std::vector< Matrix4d >::difference_type j)
        __setslice__(Matrix4dVec self, std::vector< Matrix4d >::difference_type i, std::vector< Matrix4d >::difference_type j, Matrix4dVec v)
        """
        return _vsp_g.Matrix4dVec___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(Matrix4dVec self, std::vector< Matrix4d >::difference_type i, std::vector< Matrix4d >::difference_type j)"""
        return _vsp_g.Matrix4dVec___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(Matrix4dVec self, std::vector< Matrix4d >::difference_type i)
        __delitem__(Matrix4dVec self, PySliceObject * slice)
        """
        return _vsp_g.Matrix4dVec___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(Matrix4dVec self, PySliceObject * slice) -> Matrix4dVec
        __getitem__(Matrix4dVec self, std::vector< Matrix4d >::difference_type i) -> Matrix4d
        """
        return _vsp_g.Matrix4dVec___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(Matrix4dVec self, PySliceObject * slice, Matrix4dVec v)
        __setitem__(Matrix4dVec self, PySliceObject * slice)
        __setitem__(Matrix4dVec self, std::vector< Matrix4d >::difference_type i, Matrix4d x)
        """
        return _vsp_g.Matrix4dVec___setitem__(self, *args)

    def pop(self):
        r"""pop(Matrix4dVec self) -> Matrix4d"""
        return _vsp_g.Matrix4dVec_pop(self)

    def append(self, x):
        r"""append(Matrix4dVec self, Matrix4d x)"""
        return _vsp_g.Matrix4dVec_append(self, x)

    def empty(self):
        r"""empty(Matrix4dVec self) -> bool"""
        return _vsp_g.Matrix4dVec_empty(self)

    def size(self):
        r"""size(Matrix4dVec self) -> std::vector< Matrix4d >::size_type"""
        return _vsp_g.Matrix4dVec_size(self)

    def swap(self, v):
        r"""swap(Matrix4dVec self, Matrix4dVec v)"""
        return _vsp_g.Matrix4dVec_swap(self, v)

    def begin(self):
        r"""begin(Matrix4dVec self) -> std::vector< Matrix4d >::iterator"""
        return _vsp_g.Matrix4dVec_begin(self)

    def end(self):
        r"""end(Matrix4dVec self) -> std::vector< Matrix4d >::iterator"""
        return _vsp_g.Matrix4dVec_end(self)

    def rbegin(self):
        r"""rbegin(Matrix4dVec self) -> std::vector< Matrix4d >::reverse_iterator"""
        return _vsp_g.Matrix4dVec_rbegin(self)

    def rend(self):
        r"""rend(Matrix4dVec self) -> std::vector< Matrix4d >::reverse_iterator"""
        return _vsp_g.Matrix4dVec_rend(self)

    def clear(self):
        r"""clear(Matrix4dVec self)"""
        return _vsp_g.Matrix4dVec_clear(self)

    def get_allocator(self):
        r"""get_allocator(Matrix4dVec self) -> std::vector< Matrix4d >::allocator_type"""
        return _vsp_g.Matrix4dVec_get_allocator(self)

    def pop_back(self):
        r"""pop_back(Matrix4dVec self)"""
        return _vsp_g.Matrix4dVec_pop_back(self)

    def erase(self, *args):
        r"""
        erase(Matrix4dVec self, std::vector< Matrix4d >::iterator pos) -> std::vector< Matrix4d >::iterator
        erase(Matrix4dVec self, std::vector< Matrix4d >::iterator first, std::vector< Matrix4d >::iterator last) -> std::vector< Matrix4d >::iterator
        """
        return _vsp_g.Matrix4dVec_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(Matrix4dVec self) -> Matrix4dVec
        __init__(Matrix4dVec self, Matrix4dVec other) -> Matrix4dVec
        __init__(Matrix4dVec self, std::vector< Matrix4d >::size_type size) -> Matrix4dVec
        __init__(Matrix4dVec self, std::vector< Matrix4d >::size_type size, Matrix4d value) -> Matrix4dVec
        """
        _vsp_g.Matrix4dVec_swiginit(self, _vsp_g.new_Matrix4dVec(*args))

    def push_back(self, x):
        r"""push_back(Matrix4dVec self, Matrix4d x)"""
        return _vsp_g.Matrix4dVec_push_back(self, x)

    def front(self):
        r"""front(Matrix4dVec self) -> Matrix4d"""
        return _vsp_g.Matrix4dVec_front(self)

    def back(self):
        r"""back(Matrix4dVec self) -> Matrix4d"""
        return _vsp_g.Matrix4dVec_back(self)

    def assign(self, n, x):
        r"""assign(Matrix4dVec self, std::vector< Matrix4d >::size_type n, Matrix4d x)"""
        return _vsp_g.Matrix4dVec_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(Matrix4dVec self, std::vector< Matrix4d >::size_type new_size)
        resize(Matrix4dVec self, std::vector< Matrix4d >::size_type new_size, Matrix4d x)
        """
        return _vsp_g.Matrix4dVec_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(Matrix4dVec self, std::vector< Matrix4d >::iterator pos, Matrix4d x) -> std::vector< Matrix4d >::iterator
        insert(Matrix4dVec self, std::vector< Matrix4d >::iterator pos, std::vector< Matrix4d >::size_type n, Matrix4d x)
        """
        return _vsp_g.Matrix4dVec_insert(self, *args)

    def reserve(self, n):
        r"""reserve(Matrix4dVec self, std::vector< Matrix4d >::size_type n)"""
        return _vsp_g.Matrix4dVec_reserve(self, n)

    def capacity(self):
        r"""capacity(Matrix4dVec self) -> std::vector< Matrix4d >::size_type"""
        return _vsp_g.Matrix4dVec_capacity(self)
    __swig_destroy__ = _vsp_g.delete_Matrix4dVec

# Register Matrix4dVec in _vsp_g:
_vsp_g.Matrix4dVec_swigregister(Matrix4dVec)

ABS = _vsp_g.ABS
r""" Absolute position"""
REL = _vsp_g.REL
r""" Relative position"""
SELIG_AF_EXPORT = _vsp_g.SELIG_AF_EXPORT
r""" Selig airfoil file format"""
BEZIER_AF_EXPORT = _vsp_g.BEZIER_AF_EXPORT
r""" Bezier airfoil file format"""
ALIGN_LEFT = _vsp_g.ALIGN_LEFT
r""" Align to left"""
ALIGN_CENTER = _vsp_g.ALIGN_CENTER
r""" Align to center"""
ALIGN_RIGHT = _vsp_g.ALIGN_RIGHT
r""" Align to right"""
ALIGN_PIXEL = _vsp_g.ALIGN_PIXEL
r""" Align to specified pixel"""
ALIGN_TOP = _vsp_g.ALIGN_TOP
r""" Align to top"""
ALIGN_MIDDLE = _vsp_g.ALIGN_MIDDLE
r""" Align to middle"""
ALIGN_BOTTOM = _vsp_g.ALIGN_BOTTOM
r""" Align to bottom"""
NUM_ALIGN_TYPE = _vsp_g.NUM_ALIGN_TYPE
r""" Number of alignment types"""
ANG_RAD = _vsp_g.ANG_RAD
r""" Radians"""
ANG_DEG = _vsp_g.ANG_DEG
r""" Degrees"""
ANG_0 = _vsp_g.ANG_0
r""" Zero deg"""
ANG_90 = _vsp_g.ANG_90
r""" 90 deg"""
ANG_180 = _vsp_g.ANG_180
r""" 180 deg"""
ANG_270 = _vsp_g.ANG_270
r""" 270 deg"""
NUM_ANG = _vsp_g.NUM_ANG
r""" Number of angle choices"""
ATMOS_TYPE_US_STANDARD_1976 = _vsp_g.ATMOS_TYPE_US_STANDARD_1976
r""" US Standard Atmosphere 1976 (default)"""
ATMOS_TYPE_HERRINGTON_1966 = _vsp_g.ATMOS_TYPE_HERRINGTON_1966
r""" USAF 1966"""
ATMOS_TYPE_MANUAL_P_R = _vsp_g.ATMOS_TYPE_MANUAL_P_R
r""" Manual: pressure and density control"""
ATMOS_TYPE_MANUAL_P_T = _vsp_g.ATMOS_TYPE_MANUAL_P_T
r""" Manual: pressure and temperature control"""
ATMOS_TYPE_MANUAL_R_T = _vsp_g.ATMOS_TYPE_MANUAL_R_T
r""" Manual: density and temperature control"""
ATMOS_TYPE_MANUAL_RE_L = _vsp_g.ATMOS_TYPE_MANUAL_RE_L
r""" Manual: Reynolds number and length control"""
ATTACH_TRANS_NONE = _vsp_g.ATTACH_TRANS_NONE
r""" No parent attachment for translations"""
ATTACH_TRANS_COMP = _vsp_g.ATTACH_TRANS_COMP
r""" Translation relative to parent body axes"""
ATTACH_TRANS_UV = _vsp_g.ATTACH_TRANS_UV
r""" Translation relative to parent surface coordinate frame"""
ATTACH_TRANS_RST = _vsp_g.ATTACH_TRANS_RST
r""" Translation relative to parent per-section volume coordinate frame"""
ATTACH_TRANS_LMN = _vsp_g.ATTACH_TRANS_LMN
r""" Translation relative to parent uniform volume coordinate frame"""
ATTACH_TRANS_EtaMN = _vsp_g.ATTACH_TRANS_EtaMN
r""" Translation relative to wing parent uniform eta volume coordinate frame"""
ATTACH_TRANS_NUM_TYPES = _vsp_g.ATTACH_TRANS_NUM_TYPES
r""" Number of translation attachment types"""
ATTACH_ROT_NONE = _vsp_g.ATTACH_ROT_NONE
r""" No parent attachment for rotations"""
ATTACH_ROT_COMP = _vsp_g.ATTACH_ROT_COMP
r""" Rotation relative to parent body axes"""
ATTACH_ROT_UV = _vsp_g.ATTACH_ROT_UV
r""" Rotation relative to parent surface coordinate frame"""
ATTACH_ROT_RST = _vsp_g.ATTACH_ROT_RST
r""" Rotation relative to parent per-section volume coordinate frame"""
ATTACH_ROT_LMN = _vsp_g.ATTACH_ROT_LMN
r""" Rotation relative to parent uniform volume coordinate frame"""
ATTACH_ROT_EtaMN = _vsp_g.ATTACH_ROT_EtaMN
r""" Rotation relative to wing parent eta volume coordinate frame"""
ATTACH_ROT_NUM_TYPES = _vsp_g.ATTACH_ROT_NUM_TYPES
r""" Number of rotation attachment types"""
ATTROBJ_PARM = _vsp_g.ATTROBJ_PARM
r""" Parm"""
ATTROBJ_GEOM = _vsp_g.ATTROBJ_GEOM
r""" Geom"""
ATTROBJ_VEH = _vsp_g.ATTROBJ_VEH
r""" Vehicle"""
ATTROBJ_SUBSURF = _vsp_g.ATTROBJ_SUBSURF
r""" SubSurf"""
ATTROBJ_MEASURE = _vsp_g.ATTROBJ_MEASURE
r""" Measure"""
ATTROBJ_LINK = _vsp_g.ATTROBJ_LINK
r""" Link"""
ATTROBJ_ADVLINK = _vsp_g.ATTROBJ_ADVLINK
r""" Adv Link"""
ATTROBJ_ATTR = _vsp_g.ATTROBJ_ATTR
r""" Attribute"""
ATTROBJ_COLLECTION = _vsp_g.ATTROBJ_COLLECTION
r""" Attribute Collection"""
ATTROBJ_XSEC = _vsp_g.ATTROBJ_XSEC
r""" Cross Section"""
ATTROBJ_SEC = _vsp_g.ATTROBJ_SEC
r""" Wing Section"""
ATTROBJ_MODE = _vsp_g.ATTROBJ_MODE
r""" Mode"""
ATTROBJ_SET = _vsp_g.ATTROBJ_SET
r""" Geom Set"""
ATTROBJ_VARGROUP = _vsp_g.ATTROBJ_VARGROUP
r""" Var Preset Group"""
ATTROBJ_VARSETTING = _vsp_g.ATTROBJ_VARSETTING
r""" Var Preset Setting"""
ATTROBJ_FREE = _vsp_g.ATTROBJ_FREE
r""" Unattached attribute"""
ATTR_GROUP_NONE = _vsp_g.ATTR_GROUP_NONE
r""" No event (user attributes)"""
ATTR_GROUP_WATERMARK = _vsp_g.ATTR_GROUP_WATERMARK
r""" Watermark group"""
NUM_ATTR_EVENT_GROUPS = _vsp_g.NUM_ATTR_EVENT_GROUPS
r""" Number attribute event groups"""
AUX_GEOM_ROTOR_TIP_PATH = _vsp_g.AUX_GEOM_ROTOR_TIP_PATH
r""" Rotor tip path"""
AUX_GEOM_ROTOR_BURST = _vsp_g.AUX_GEOM_ROTOR_BURST
r""" Rotor burst zone"""
AUX_GEOM_THREE_PT_GROUND = _vsp_g.AUX_GEOM_THREE_PT_GROUND
r""" Three contact point ground plane"""
AUX_GEOM_TWO_PT_GROUND = _vsp_g.AUX_GEOM_TWO_PT_GROUND
r""" Two contact point ground plane"""
AUX_GEOM_ONE_PT_GROUND = _vsp_g.AUX_GEOM_ONE_PT_GROUND
r""" One contact point ground plane"""
AUX_GEOM_THREE_PT_CCE = _vsp_g.AUX_GEOM_THREE_PT_CCE
r""" Three contact point composite clearance envelope"""
AUX_GEOM_SUPER_CONE = _vsp_g.AUX_GEOM_SUPER_CONE
r""" Super cone (XSecCurve based profile)"""
AUX_GEOM_SINGLE_GEAR = _vsp_g.AUX_GEOM_SINGLE_GEAR
r""" Single (potentially) off nominal gear"""
AUX_GEOM_ROTOR_FRAGMENT = _vsp_g.AUX_GEOM_ROTOR_FRAGMENT
r""" AC 20-128 A rotor fragment"""
AUX_GEOM_THROWN_BLADE = _vsp_g.AUX_GEOM_THROWN_BLADE
r""" AC 25.905-1 thrown blade"""
AUX_GEOM_TIRE_SPRAY = _vsp_g.AUX_GEOM_TIRE_SPRAY
r""" ESDU 83042a Tire spray pattern"""
AUX_GEOM_WHEEL_TIRE_FAILURE = _vsp_g.AUX_GEOM_WHEEL_TIRE_FAILURE
r""" AMC 25.734 Wheel and tire failure models"""
NUM_AUX_GEOM_MODES = _vsp_g.NUM_AUX_GEOM_MODES
r""" Number of auxiliary geom modes."""
BOGIE_CENTER_DIST = _vsp_g.BOGIE_CENTER_DIST
r""" Distance between centers"""
BOGIE_CENTER_DIST_FRAC = _vsp_g.BOGIE_CENTER_DIST_FRAC
r""" Fractional distance between centers"""
BOGIE_GAP = _vsp_g.BOGIE_GAP
r""" Gap"""
BOGIE_GAP_FRAC = _vsp_g.BOGIE_GAP_FRAC
r""" Fractional gap"""
NUM_BOGIE_SPACING_TYPE = _vsp_g.NUM_BOGIE_SPACING_TYPE
r""" Number of bogie spacing control modes"""
BOR_FLOWTHROUGH = _vsp_g.BOR_FLOWTHROUGH
r""" Flowthrough mode (default)"""
BOR_UPPER = _vsp_g.BOR_UPPER
r""" Upper surface mode"""
BOR_LOWER = _vsp_g.BOR_LOWER
r""" Lower surface mode"""
BOR_NUM_MODES = _vsp_g.BOR_NUM_MODES
r""" Number of Body of Revolution modes"""
MAX_CAMB = _vsp_g.MAX_CAMB
r""" Input maximum camber, calculate ideal lift coefficient"""
DESIGN_CL = _vsp_g.DESIGN_CL
r""" Input ideal lift coefficient, calculate maximum camber"""
CAM_TOP = _vsp_g.CAM_TOP
r""" Camera top view"""
CAM_FRONT = _vsp_g.CAM_FRONT
r""" Camera front view"""
CAM_FRONT_YUP = _vsp_g.CAM_FRONT_YUP
r""" Camera front Y-up view"""
CAM_LEFT = _vsp_g.CAM_LEFT
r""" Camera left view"""
CAM_LEFT_ISO = _vsp_g.CAM_LEFT_ISO
r""" Camera left isometric view"""
CAM_BOTTOM = _vsp_g.CAM_BOTTOM
r""" Camera bottom view"""
CAM_REAR = _vsp_g.CAM_REAR
r""" Camera rear view"""
CAM_RIGHT = _vsp_g.CAM_RIGHT
r""" Camera right view"""
CAM_RIGHT_ISO = _vsp_g.CAM_RIGHT_ISO
r""" Camera right isometric view"""
CAM_CENTER = _vsp_g.CAM_CENTER
r""" Camera center view"""
NO_END_CAP = _vsp_g.NO_END_CAP
r""" No end cap"""
FLAT_END_CAP = _vsp_g.FLAT_END_CAP
r""" Flat end cap"""
ROUND_END_CAP = _vsp_g.ROUND_END_CAP
r""" Round end cap"""
EDGE_END_CAP = _vsp_g.EDGE_END_CAP
r""" Edge end cap"""
SHARP_END_CAP = _vsp_g.SHARP_END_CAP
r""" Sharp end cap"""
POINT_END_CAP = _vsp_g.POINT_END_CAP
r""" Point end cap"""
ROUND_EXT_END_CAP_NONE = _vsp_g.ROUND_EXT_END_CAP_NONE
r""" Extended round end cap, but not extended"""
ROUND_EXT_END_CAP_LE = _vsp_g.ROUND_EXT_END_CAP_LE
r""" Extended round end cap, extend LE"""
ROUND_EXT_END_CAP_TE = _vsp_g.ROUND_EXT_END_CAP_TE
r""" Extended round end cap, extend TE"""
ROUND_EXT_END_CAP_BOTH = _vsp_g.ROUND_EXT_END_CAP_BOTH
r""" Extended round end cap, extend both"""
NUM_END_CAP_OPTIONS = _vsp_g.NUM_END_CAP_OPTIONS
r""" Number of end cap options"""
CFD_MIN_EDGE_LEN = _vsp_g.CFD_MIN_EDGE_LEN
r""" Minimum mesh edge length"""
CFD_MAX_EDGE_LEN = _vsp_g.CFD_MAX_EDGE_LEN
r""" Maximum mesh edge length"""
CFD_MAX_GAP = _vsp_g.CFD_MAX_GAP
r""" Maximum mesh edge gap"""
CFD_NUM_CIRCLE_SEGS = _vsp_g.CFD_NUM_CIRCLE_SEGS
r""" Number of edge segments to resolve circle"""
CFD_GROWTH_RATIO = _vsp_g.CFD_GROWTH_RATIO
r""" Maximum allowed edge growth ratio"""
CFD_LIMIT_GROWTH_FLAG = _vsp_g.CFD_LIMIT_GROWTH_FLAG
r""" Rigorous 3D growth limiting flag"""
CFD_INTERSECT_SUBSURFACE_FLAG = _vsp_g.CFD_INTERSECT_SUBSURFACE_FLAG
r""" Flag to intersect sub-surfaces"""
CFD_HALF_MESH_FLAG = _vsp_g.CFD_HALF_MESH_FLAG
r""" Flag to generate a half mesh"""
CFD_FAR_FIELD_FLAG = _vsp_g.CFD_FAR_FIELD_FLAG
r""" Flag to generate a far field mesh"""
CFD_FAR_MAX_EDGE_LEN = _vsp_g.CFD_FAR_MAX_EDGE_LEN
r""" Maximum far field mesh edge length"""
CFD_FAR_MAX_GAP = _vsp_g.CFD_FAR_MAX_GAP
r""" Maximum far field mesh edge gap"""
CFD_FAR_NUM_CIRCLE_SEGS = _vsp_g.CFD_FAR_NUM_CIRCLE_SEGS
r""" Number of far field edge segments to resolve circle"""
CFD_FAR_SIZE_ABS_FLAG = _vsp_g.CFD_FAR_SIZE_ABS_FLAG
r""" Relative or absolute size flag"""
CFD_FAR_LENGTH = _vsp_g.CFD_FAR_LENGTH
r""" Far field length"""
CFD_FAR_WIDTH = _vsp_g.CFD_FAR_WIDTH
r""" Far field width"""
CFD_FAR_HEIGHT = _vsp_g.CFD_FAR_HEIGHT
r""" Far field height"""
CFD_FAR_X_SCALE = _vsp_g.CFD_FAR_X_SCALE
r"""  Far field X scale"""
CFD_FAR_Y_SCALE = _vsp_g.CFD_FAR_Y_SCALE
r"""  Far field Y scale"""
CFD_FAR_Z_SCALE = _vsp_g.CFD_FAR_Z_SCALE
r"""  Far field Z scale"""
CFD_FAR_LOC_MAN_FLAG = _vsp_g.CFD_FAR_LOC_MAN_FLAG
r""" Far field location flag: centered or manual"""
CFD_FAR_LOC_X = _vsp_g.CFD_FAR_LOC_X
r""" Far field X location"""
CFD_FAR_LOC_Y = _vsp_g.CFD_FAR_LOC_Y
r""" Far field Y location"""
CFD_FAR_LOC_Z = _vsp_g.CFD_FAR_LOC_Z
r""" Far field Z location"""
CFD_SRF_XYZ_FLAG = _vsp_g.CFD_SRF_XYZ_FLAG
r""" Flag to include X,Y,Z intersection curves in export files"""
CFD_STL_FILE_NAME = _vsp_g.CFD_STL_FILE_NAME
r""" STL export type"""
CFD_POLY_FILE_NAME = _vsp_g.CFD_POLY_FILE_NAME
r""" POLY export type"""
CFD_TRI_FILE_NAME = _vsp_g.CFD_TRI_FILE_NAME
r""" TRI export type"""
CFD_OBJ_FILE_NAME = _vsp_g.CFD_OBJ_FILE_NAME
r""" OBJ export type"""
CFD_DAT_FILE_NAME = _vsp_g.CFD_DAT_FILE_NAME
r""" DAT export type"""
CFD_KEY_FILE_NAME = _vsp_g.CFD_KEY_FILE_NAME
r""" KEY export type"""
CFD_GMSH_FILE_NAME = _vsp_g.CFD_GMSH_FILE_NAME
r""" GMSH export type"""
CFD_TKEY_FILE_NAME = _vsp_g.CFD_TKEY_FILE_NAME
r""" TKEY export type"""
CFD_FACET_FILE_NAME = _vsp_g.CFD_FACET_FILE_NAME
r""" FACET export type"""
CFD_VSPGEOM_FILE_NAME = _vsp_g.CFD_VSPGEOM_FILE_NAME
r""" VSPGEOM export type"""
CFD_NUM_FILE_NAMES = _vsp_g.CFD_NUM_FILE_NAMES
r""" Number of CFD Mesh export file types"""
POINT_SOURCE = _vsp_g.POINT_SOURCE
r""" Point source"""
LINE_SOURCE = _vsp_g.LINE_SOURCE
r""" Line source"""
BOX_SOURCE = _vsp_g.BOX_SOURCE
r""" Box source"""
ULINE_SOURCE = _vsp_g.ULINE_SOURCE
r""" Constant U Line source"""
WLINE_SOURCE = _vsp_g.WLINE_SOURCE
r""" Constant W Line source"""
NUM_SOURCE_TYPES = _vsp_g.NUM_SOURCE_TYPES
r""" Number of CFD Mesh source types"""
TAG = _vsp_g.TAG
r""" Color mesh by tag value (component, subsurface, part, etc)"""
REASON = _vsp_g.REASON
r""" Color mesh by local edge length reason"""
CF_LAM_BLASIUS = _vsp_g.CF_LAM_BLASIUS
r""" Blasius laminar Cf equation"""
CF_LAM_BLASIUS_W_HEAT = _vsp_g.CF_LAM_BLASIUS_W_HEAT
r""" Blasius laminar Cf equation with heat (NOT IMPLEMENTED)"""
CF_TURB_EXPLICIT_FIT_SPALDING = _vsp_g.CF_TURB_EXPLICIT_FIT_SPALDING
r""" Explicit Fit of Spalding turbulent Cf equation"""
CF_TURB_EXPLICIT_FIT_SPALDING_CHI = _vsp_g.CF_TURB_EXPLICIT_FIT_SPALDING_CHI
r""" Explicit Fit of Spalding and Chi turbulent Cf equation"""
CF_TURB_EXPLICIT_FIT_SCHOENHERR = _vsp_g.CF_TURB_EXPLICIT_FIT_SCHOENHERR
r""" Explicit Fit of Schoenherr turbulent Cf equation"""
DO_NOT_USE_CF_TURB_IMPLICIT_KARMAN = _vsp_g.DO_NOT_USE_CF_TURB_IMPLICIT_KARMAN
r""" Implicit Karman turbulent Cf equation (DO NOT USE)"""
CF_TURB_IMPLICIT_SCHOENHERR = _vsp_g.CF_TURB_IMPLICIT_SCHOENHERR
r""" Implicit Schoenherr turbulent Cf equation"""
CF_TURB_IMPLICIT_KARMAN_SCHOENHERR = _vsp_g.CF_TURB_IMPLICIT_KARMAN_SCHOENHERR
r""" Implicit Karman-Schoenherr turbulent Cf equation"""
CF_TURB_POWER_LAW_BLASIUS = _vsp_g.CF_TURB_POWER_LAW_BLASIUS
r""" Power Law Blasius turbulent Cf equation"""
CF_TURB_POWER_LAW_PRANDTL_LOW_RE = _vsp_g.CF_TURB_POWER_LAW_PRANDTL_LOW_RE
r"""Power Law Prandtl Low Re turbulent Cf equation"""
CF_TURB_POWER_LAW_PRANDTL_MEDIUM_RE = _vsp_g.CF_TURB_POWER_LAW_PRANDTL_MEDIUM_RE
r""" Power Law Prandtl Medium Re turbulent Cf equation"""
CF_TURB_POWER_LAW_PRANDTL_HIGH_RE = _vsp_g.CF_TURB_POWER_LAW_PRANDTL_HIGH_RE
r""" Power Law Prandtl High Re turbulent Cf equation"""
CF_TURB_SCHLICHTING_COMPRESSIBLE = _vsp_g.CF_TURB_SCHLICHTING_COMPRESSIBLE
r""" Schlichting Compressible turbulent Cf equation"""
DO_NOT_USE_CF_TURB_SCHLICHTING_INCOMPRESSIBLE = _vsp_g.DO_NOT_USE_CF_TURB_SCHLICHTING_INCOMPRESSIBLE
r""" Schlichting Incompressible turbulent Cf equation (DO NOT USE)"""
DO_NOT_USE_CF_TURB_SCHLICHTING_PRANDTL = _vsp_g.DO_NOT_USE_CF_TURB_SCHLICHTING_PRANDTL
r""" Schlichting-Prandtl turbulent Cf equation (DO NOT USE)"""
DO_NOT_USE_CF_TURB_SCHULTZ_GRUNOW_HIGH_RE = _vsp_g.DO_NOT_USE_CF_TURB_SCHULTZ_GRUNOW_HIGH_RE
r""" Schultz-Grunow High Re turbulent Cf equation (DO NOT USE)"""
CF_TURB_SCHULTZ_GRUNOW_SCHOENHERR = _vsp_g.CF_TURB_SCHULTZ_GRUNOW_SCHOENHERR
r""" Schultz-Grunow Estimate of Schoenherr turbulent Cf equation."""
DO_NOT_USE_CF_TURB_WHITE_CHRISTOPH_COMPRESSIBLE = _vsp_g.DO_NOT_USE_CF_TURB_WHITE_CHRISTOPH_COMPRESSIBLE
r""" White-Christoph Compressible turbulent Cf equation (DO NOT USE)"""
CF_TURB_ROUGHNESS_SCHLICHTING_AVG = _vsp_g.CF_TURB_ROUGHNESS_SCHLICHTING_AVG
r""" Roughness Schlichting Avg turbulent Cf equation."""
DO_NOT_USE_CF_TURB_ROUGHNESS_SCHLICHTING_LOCAL = _vsp_g.DO_NOT_USE_CF_TURB_ROUGHNESS_SCHLICHTING_LOCAL
r""" Roughness Schlichting Local turbulent Cf equation (DO NOT USE)"""
DO_NOT_USE_CF_TURB_ROUGHNESS_WHITE = _vsp_g.DO_NOT_USE_CF_TURB_ROUGHNESS_WHITE
r""" Roughness White turbulent Cf equation (DO NOT USE)"""
CF_TURB_ROUGHNESS_SCHLICHTING_AVG_FLOW_CORRECTION = _vsp_g.CF_TURB_ROUGHNESS_SCHLICHTING_AVG_FLOW_CORRECTION
r""" Roughness Schlichting Avg Compressible turbulent Cf equation."""
CF_TURB_HEATTRANSFER_WHITE_CHRISTOPH = _vsp_g.CF_TURB_HEATTRANSFER_WHITE_CHRISTOPH
r""" Heat Transfer White-Christoph turbulent Cf equation."""
CHEVRON_NONE = _vsp_g.CHEVRON_NONE
r""" No chevron."""
CHEVRON_PARTIAL = _vsp_g.CHEVRON_PARTIAL
r""" One or more chevrons of limited extent."""
CHEVRON_FULL = _vsp_g.CHEVRON_FULL
r""" Full period of chevrons."""
CHEVRON_NUM_TYPES = _vsp_g.CHEVRON_NUM_TYPES
r""" Number of chevron types."""
CHEVRON_W01_SE = _vsp_g.CHEVRON_W01_SE
r""" Start and End"""
CHEVRON_W01_CW = _vsp_g.CHEVRON_W01_CW
r""" Center and Width"""
CHEVRON_W01_NUM_MODES = _vsp_g.CHEVRON_W01_NUM_MODES
r""" Number of chevron W parameter mode types."""
COLLISION_OK = _vsp_g.COLLISION_OK
r""" No Error."""
COLLISION_INTERSECT_NO_SOLUTION = _vsp_g.COLLISION_INTERSECT_NO_SOLUTION
r""" Touching, no solution"""
COLLISION_CLEAR_NO_SOLUTION = _vsp_g.COLLISION_CLEAR_NO_SOLUTION
r""" Not touching, no solution"""
NO_FILE_TYPE = _vsp_g.NO_FILE_TYPE
r""" No export file type"""
COMP_GEOM_TXT_TYPE = _vsp_g.COMP_GEOM_TXT_TYPE

COMP_GEOM_CSV_TYPE = _vsp_g.COMP_GEOM_CSV_TYPE

DRAG_BUILD_TSV_TYPE_DEPRECATED = _vsp_g.DRAG_BUILD_TSV_TYPE_DEPRECATED

SLICE_TXT_TYPE = _vsp_g.SLICE_TXT_TYPE

MASS_PROP_TXT_TYPE = _vsp_g.MASS_PROP_TXT_TYPE

DEGEN_GEOM_CSV_TYPE = _vsp_g.DEGEN_GEOM_CSV_TYPE

DEGEN_GEOM_M_TYPE = _vsp_g.DEGEN_GEOM_M_TYPE

CFD_STL_TYPE = _vsp_g.CFD_STL_TYPE

CFD_POLY_TYPE = _vsp_g.CFD_POLY_TYPE

CFD_TRI_TYPE = _vsp_g.CFD_TRI_TYPE

CFD_OBJ_TYPE = _vsp_g.CFD_OBJ_TYPE

CFD_DAT_TYPE = _vsp_g.CFD_DAT_TYPE

CFD_KEY_TYPE = _vsp_g.CFD_KEY_TYPE

CFD_GMSH_TYPE = _vsp_g.CFD_GMSH_TYPE

CFD_SRF_TYPE_DEPRECATED = _vsp_g.CFD_SRF_TYPE_DEPRECATED

CFD_TKEY_TYPE = _vsp_g.CFD_TKEY_TYPE

PROJ_AREA_CSV_TYPE = _vsp_g.PROJ_AREA_CSV_TYPE

WAVE_DRAG_TXT_TYPE = _vsp_g.WAVE_DRAG_TXT_TYPE

VSPAERO_PANEL_TRI_TYPE = _vsp_g.VSPAERO_PANEL_TRI_TYPE

DRAG_BUILD_CSV_TYPE = _vsp_g.DRAG_BUILD_CSV_TYPE

CFD_FACET_TYPE = _vsp_g.CFD_FACET_TYPE

CFD_CURV_TYPE_DEPRECATED = _vsp_g.CFD_CURV_TYPE_DEPRECATED

CFD_PLOT3D_TYPE_DEPRECATED = _vsp_g.CFD_PLOT3D_TYPE_DEPRECATED

CFD_VSPGEOM_TYPE = _vsp_g.CFD_VSPGEOM_TYPE

VSPAERO_VSPGEOM_TYPE = _vsp_g.VSPAERO_VSPGEOM_TYPE

U_TRIM = _vsp_g.U_TRIM
r""" Trim by U coordinate"""
L_TRIM = _vsp_g.L_TRIM
r""" Trim by L coordinate"""
ETA_TRIM = _vsp_g.ETA_TRIM
r""" Trim by Eta coordinate"""
NUM_TRIM_TYPES = _vsp_g.NUM_TRIM_TYPES
r""" Number of conformal component trim types"""
DELIM_COMMA = _vsp_g.DELIM_COMMA
r""" Comma delimiter"""
DELIM_USCORE = _vsp_g.DELIM_USCORE
r""" Underscore delimiter"""
DELIM_SPACE = _vsp_g.DELIM_SPACE
r""" Space delimiter"""
DELIM_NONE = _vsp_g.DELIM_NONE
r""" No delimiter"""
DELIM_NUM_TYPES = _vsp_g.DELIM_NUM_TYPES
r""" Number of delimiter types"""
DEPTH_FRONT = _vsp_g.DEPTH_FRONT
r""" Set 3D background before model"""
DEPTH_REAR = _vsp_g.DEPTH_REAR
r""" Set 3D background behind model"""
DEPTH_FREE = _vsp_g.DEPTH_FREE
r""" Set 3D background at specified location"""
NUM_DEPTH_TYPE = _vsp_g.NUM_DEPTH_TYPE
r""" Number of depth types"""
SET_3D = _vsp_g.SET_3D
r""" 3D DXF export (default)"""
SET_2D = _vsp_g.SET_2D
r""" 2D DXF export"""
X_DIR = _vsp_g.X_DIR
r""" X direction"""
Y_DIR = _vsp_g.Y_DIR

Z_DIR = _vsp_g.Z_DIR

ALL_DIR = _vsp_g.ALL_DIR

DISPLAY_BEZIER = _vsp_g.DISPLAY_BEZIER
r""" Display the normal Bezier surface (default)"""
DISPLAY_DEGEN_SURF = _vsp_g.DISPLAY_DEGEN_SURF
r""" Display as surface Degen Geom"""
DISPLAY_DEGEN_PLATE = _vsp_g.DISPLAY_DEGEN_PLATE
r""" Display as plate Degen Geom"""
DISPLAY_DEGEN_CAMBER = _vsp_g.DISPLAY_DEGEN_CAMBER
r""" Display as camber Degen Geom"""
GEOM_DRAW_WIRE = _vsp_g.GEOM_DRAW_WIRE
r""" Draw the wireframe mesh (see through)"""
GEOM_DRAW_HIDDEN = _vsp_g.GEOM_DRAW_HIDDEN
r""" Draw the hidden mesh"""
GEOM_DRAW_SHADE = _vsp_g.GEOM_DRAW_SHADE
r""" Draw the shaded mesh"""
GEOM_DRAW_TEXTURE = _vsp_g.GEOM_DRAW_TEXTURE
r""" Draw the textured mesh"""
GEOM_DRAW_NONE = _vsp_g.GEOM_DRAW_NONE
r""" Do not draw anything"""
ENGINE_GEOM_NONE = _vsp_g.ENGINE_GEOM_NONE
r""" Component is not an integrated flowpath component."""
ENGINE_GEOM_INLET = _vsp_g.ENGINE_GEOM_INLET
r""" Component represents integrated flowpath inlet."""
ENGINE_GEOM_INLET_OUTLET = _vsp_g.ENGINE_GEOM_INLET_OUTLET
r""" Component represents integrated flowpath inlet and outlet."""
ENGINE_GEOM_OUTLET = _vsp_g.ENGINE_GEOM_OUTLET
r""" Component represents integrated flowpath outlet."""
ENGINE_GEOM_IO_NUM_TYPES = _vsp_g.ENGINE_GEOM_IO_NUM_TYPES
r""" Number of integrated flowpath component types."""
ENGINE_GEOM_FLOWTHROUGH = _vsp_g.ENGINE_GEOM_FLOWTHROUGH
r""" Component is modeled as flowthrough engine."""
ENGINE_GEOM_TO_LIP = _vsp_g.ENGINE_GEOM_TO_LIP
r""" Component is modeled to the lip."""
ENGINE_GEOM_FLOWPATH = _vsp_g.ENGINE_GEOM_FLOWPATH
r""" Component flowpath is modeled."""
ENGINE_GEOM_TO_FACE = _vsp_g.ENGINE_GEOM_TO_FACE
r""" Component is modeled to face."""
ENGINE_GEOM_NUM_TYPES = _vsp_g.ENGINE_GEOM_NUM_TYPES
r""" Number of integrated flowpath modeling types."""
ENGINE_LOC_INDEX = _vsp_g.ENGINE_LOC_INDEX
r""" Integrated flowpath key point identified by XSec index."""
ENGINE_LOC_U = _vsp_g.ENGINE_LOC_U
r""" Integrated flowpath key point identified by U parameter."""
ENGINE_LOC_INLET_LIP = _vsp_g.ENGINE_LOC_INLET_LIP
r""" Integrated flowpath key point is inlet lip."""
ENGINE_LOC_INLET_FACE = _vsp_g.ENGINE_LOC_INLET_FACE
r""" Integrated flowpath key point is inlet face."""
ENGINE_LOC_OUTLET_LIP = _vsp_g.ENGINE_LOC_OUTLET_LIP
r""" Integrated flowpath key point is outlet lip."""
ENGINE_LOC_OUTLET_FACE = _vsp_g.ENGINE_LOC_OUTLET_FACE
r""" Integrated flowpath key point is outlet face."""
ENGINE_LOC_NUM = _vsp_g.ENGINE_LOC_NUM
r""" Number of integrated flowpath key point locations."""
ENGINE_MODE_FLOWTHROUGH = _vsp_g.ENGINE_MODE_FLOWTHROUGH
r""" Represent integrated flowpath as flowthrough engine."""
ENGINE_MODE_FLOWTHROUGH_NEG = _vsp_g.ENGINE_MODE_FLOWTHROUGH_NEG
r""" Represent integrated flowpath as flowthrough engine with negative flowpath."""
ENGINE_MODE_FLOWTHROUGH_NEG_ONLY = _vsp_g.ENGINE_MODE_FLOWTHROUGH_NEG_ONLY
r""" Represent ONLY the integrated flowpath as flowthrough engine with negative flowpath."""
ENGINE_MODE_TO_LIP = _vsp_g.ENGINE_MODE_TO_LIP
r""" Represent integrated flowpath to the lip."""
ENGINE_MODE_TO_FACE = _vsp_g.ENGINE_MODE_TO_FACE
r""" Represent integrated flowpath to the face."""
ENGINE_MODE_TO_FACE_NEG = _vsp_g.ENGINE_MODE_TO_FACE_NEG
r""" Represent integrated flowpath to the face with negative flowpath to the face."""
ENGINE_MODE_TO_FACE_NEG_ONLY = _vsp_g.ENGINE_MODE_TO_FACE_NEG_ONLY
r""" Represent ONLY the integrated flowpath to the face with negative flowpath to the face."""
ENGINE_MODE_EXTEND = _vsp_g.ENGINE_MODE_EXTEND
r""" Represent integrated flowpath with farfield extensions."""
ENGINE_MODE_NUM_TYPES = _vsp_g.ENGINE_MODE_NUM_TYPES
r""" Number of integrated flowpath representations."""
VSP_UNKNOWN = _vsp_g.VSP_UNKNOWN
r""" Unknown error"""
VSP_OK = _vsp_g.VSP_OK
r""" No error"""
VSP_INVALID_PTR = _vsp_g.VSP_INVALID_PTR
r""" Invalid pointer error"""
VSP_INVALID_TYPE = _vsp_g.VSP_INVALID_TYPE
r""" Invalid type error"""
VSP_CANT_FIND_TYPE = _vsp_g.VSP_CANT_FIND_TYPE
r""" Can't find type error"""
VSP_CANT_FIND_PARM = _vsp_g.VSP_CANT_FIND_PARM
r""" Can't find parm error"""
VSP_CANT_FIND_NAME = _vsp_g.VSP_CANT_FIND_NAME
r""" Can't find name error"""
VSP_INVALID_GEOM_ID = _vsp_g.VSP_INVALID_GEOM_ID
r""" Invalid Geom ID error"""
VSP_FILE_DOES_NOT_EXIST = _vsp_g.VSP_FILE_DOES_NOT_EXIST
r""" File does not exist error"""
VSP_FILE_WRITE_FAILURE = _vsp_g.VSP_FILE_WRITE_FAILURE
r""" File write failure error"""
VSP_FILE_READ_FAILURE = _vsp_g.VSP_FILE_READ_FAILURE
r""" File read failure error"""
VSP_WRONG_GEOM_TYPE = _vsp_g.VSP_WRONG_GEOM_TYPE
r""" Wrong Geom type error"""
VSP_WRONG_XSEC_TYPE = _vsp_g.VSP_WRONG_XSEC_TYPE
r""" Wrong XSec type error"""
VSP_WRONG_FILE_TYPE = _vsp_g.VSP_WRONG_FILE_TYPE
r""" Wrong file type error"""
VSP_INDEX_OUT_RANGE = _vsp_g.VSP_INDEX_OUT_RANGE
r""" Index out of range error"""
VSP_INVALID_XSEC_ID = _vsp_g.VSP_INVALID_XSEC_ID
r""" Invalid XSec ID error"""
VSP_INVALID_ID = _vsp_g.VSP_INVALID_ID
r""" Invalid ID error"""
VSP_CANT_SET_NOT_EQ_PARM = _vsp_g.VSP_CANT_SET_NOT_EQ_PARM
r""" Can't set NotEqParm error"""
VSP_AMBIGUOUS_SUBSURF = _vsp_g.VSP_AMBIGUOUS_SUBSURF
r""" Ambiguous flow-through sub-surface error"""
VSP_INVALID_VARPRESET_SETNAME = _vsp_g.VSP_INVALID_VARPRESET_SETNAME
r""" Invalid Variable Preset set name error"""
VSP_INVALID_VARPRESET_GROUPNAME = _vsp_g.VSP_INVALID_VARPRESET_GROUPNAME
r""" Invalid Variable Preset group name error"""
VSP_CONFORMAL_PARENT_UNSUPPORTED = _vsp_g.VSP_CONFORMAL_PARENT_UNSUPPORTED
r""" Unsupported Conformal Geom parent error"""
VSP_UNEXPECTED_RESET_REMAP_ID = _vsp_g.VSP_UNEXPECTED_RESET_REMAP_ID
r""" Unexpected reset remap ID error"""
VSP_INVALID_INPUT_VAL = _vsp_g.VSP_INVALID_INPUT_VAL
r""" Invalid input value error"""
VSP_INVALID_CF_EQN = _vsp_g.VSP_INVALID_CF_EQN
r""" Invalid friction coefficient equation error"""
VSP_INVALID_DRIVERS = _vsp_g.VSP_INVALID_DRIVERS
r""" Invalid drivers for driver group"""
VSP_ADV_LINK_BUILD_FAIL = _vsp_g.VSP_ADV_LINK_BUILD_FAIL
r""" Advanced link build failure"""
VSP_DEPRECATED = _vsp_g.VSP_DEPRECATED
r""" This capability has been deprecated and is not longer supported"""
VSP_LINK_LOOP_DETECTED = _vsp_g.VSP_LINK_LOOP_DETECTED
r""" A parameter link loop was detected and stopped"""
VSP_LINK_OUTPUT_NOT_ASSIGNED = _vsp_g.VSP_LINK_OUTPUT_NOT_ASSIGNED
r""" An output of a parameter link was not set"""
VSP_DUPLICATE_NAME = _vsp_g.VSP_DUPLICATE_NAME
r""" A duplicate name has been provided"""
VSP_GUI_DEVICE_DEACTIVATED = _vsp_g.VSP_GUI_DEVICE_DEACTIVATED
r""" A deactivated GUI device was touched"""
VSP_COULD_NOT_CREATE_BACKGROUND3D = _vsp_g.VSP_COULD_NOT_CREATE_BACKGROUND3D
r""" Could not create and add Background3D"""
VSP_NUM_ERROR_CODE = _vsp_g.VSP_NUM_ERROR_CODE
r""" Total number of VSP error codes"""
EXCRESCENCE_COUNT = _vsp_g.EXCRESCENCE_COUNT
r""" Drag counts excressence type"""
EXCRESCENCE_CD = _vsp_g.EXCRESCENCE_CD
r""" Drag coefficient excressence type"""
EXCRESCENCE_PERCENT_GEOM = _vsp_g.EXCRESCENCE_PERCENT_GEOM
r""" Percent of parent Geom drag coefficient excressence type"""
EXCRESCENCE_MARGIN = _vsp_g.EXCRESCENCE_MARGIN
r""" Percent margin excressence type"""
EXCRESCENCE_DRAGAREA = _vsp_g.EXCRESCENCE_DRAGAREA
r""" Drag area (D/q) excressence type"""
EXPORT_FELISA = _vsp_g.EXPORT_FELISA
r""" FELISA export type (NOT IMPLEMENTED)"""
EXPORT_XSEC = _vsp_g.EXPORT_XSEC
r""" XSec (\*.hrm) export type"""
EXPORT_STL = _vsp_g.EXPORT_STL
r""" Stereolith (\*.stl) export type"""
EXPORT_AWAVE = _vsp_g.EXPORT_AWAVE
r""" AWAVE export type (NOT IMPLEMENTED)"""
EXPORT_NASCART = _vsp_g.EXPORT_NASCART
r""" NASCART (\*.dat) export type"""
EXPORT_POVRAY = _vsp_g.EXPORT_POVRAY
r""" POVRAY (\*.pov) export type"""
EXPORT_CART3D = _vsp_g.EXPORT_CART3D
r""" Cart3D (\*.tri) export type"""
EXPORT_VSPGEOM = _vsp_g.EXPORT_VSPGEOM
r""" VSPGeom (\*.vspgeom) export type"""
EXPORT_VORXSEC = _vsp_g.EXPORT_VORXSEC
r""" VORXSEC  export type (NOT IMPLEMENTED)"""
EXPORT_XSECGEOM = _vsp_g.EXPORT_XSECGEOM
r""" XSECGEOM export type (NOT IMPLEMENTED)"""
EXPORT_GMSH = _vsp_g.EXPORT_GMSH
r""" Gmsh (\*.msh) export type"""
EXPORT_X3D = _vsp_g.EXPORT_X3D
r""" X3D (\*.x3d) export type"""
EXPORT_STEP = _vsp_g.EXPORT_STEP
r""" STEP (\*.stp) export type"""
EXPORT_PLOT3D = _vsp_g.EXPORT_PLOT3D
r""" PLOT3D (\*.p3d) export type"""
EXPORT_IGES = _vsp_g.EXPORT_IGES
r""" IGES (\*.igs) export type"""
EXPORT_BEM = _vsp_g.EXPORT_BEM
r""" Blade Element (\*.bem) export type"""
EXPORT_DXF = _vsp_g.EXPORT_DXF
r""" AutoCAD (\*.dxf) export type"""
EXPORT_FACET = _vsp_g.EXPORT_FACET
r""" Xpatch (\*.facet) export type"""
EXPORT_SVG = _vsp_g.EXPORT_SVG
r""" SVG (\*.svg) export type"""
EXPORT_PMARC = _vsp_g.EXPORT_PMARC
r""" PMARC 12 (\*.pmin) export type"""
EXPORT_OBJ = _vsp_g.EXPORT_OBJ
r""" OBJ (\*.obj) export type"""
EXPORT_SELIG_AIRFOIL = _vsp_g.EXPORT_SELIG_AIRFOIL
r""" Airfoil points (\*.dat) export type"""
EXPORT_BEZIER_AIRFOIL = _vsp_g.EXPORT_BEZIER_AIRFOIL
r""" Airfoil curves (\*.bz) export type"""
EXPORT_IGES_STRUCTURE = _vsp_g.EXPORT_IGES_STRUCTURE
r""" IGES structure (\*.igs) export type"""
EXPORT_STEP_STRUCTURE = _vsp_g.EXPORT_STEP_STRUCTURE
r""" STEP structure (\*.stp) export type"""
FEA_BCM_USER = _vsp_g.FEA_BCM_USER
r""" FEA boundary condition constraints user defined."""
FEA_BCM_ALL = _vsp_g.FEA_BCM_ALL
r""" FEA boundary condition constrains all DOF."""
FEA_BCM_PIN = _vsp_g.FEA_BCM_PIN
r""" FEA boundary condition pin constraints."""
FEA_BCM_SYMM = _vsp_g.FEA_BCM_SYMM
r""" FEA boundary condition symmetrical constraints."""
FEA_BCM_ASYMM = _vsp_g.FEA_BCM_ASYMM
r""" FEA boundary condition antisymmetrical constraints."""
FEA_NUM_BCM_MODES = _vsp_g.FEA_NUM_BCM_MODES
r""" Number of FEA boundary condition constraint types."""
FEA_BC_STRUCTURE = _vsp_g.FEA_BC_STRUCTURE
r""" FEA boundary condition assigned to structure."""
FEA_BC_PART = _vsp_g.FEA_BC_PART
r""" FEA boundary condition assigned to part."""
FEA_BC_SUBSURF = _vsp_g.FEA_BC_SUBSURF
r""" FEA boundary condition assigned to subsurface."""
FEA_NUM_BC_TYPES = _vsp_g.FEA_NUM_BC_TYPES
r""" Number of FEA boundary condition definition types."""
FEA_XSEC_GENERAL = _vsp_g.FEA_XSEC_GENERAL
r""" General XSec type"""
FEA_XSEC_CIRC = _vsp_g.FEA_XSEC_CIRC
r""" Circle XSec type"""
FEA_XSEC_PIPE = _vsp_g.FEA_XSEC_PIPE
r""" Pipe XSec type"""
FEA_XSEC_I = _vsp_g.FEA_XSEC_I
r""" I XSec type"""
FEA_XSEC_RECT = _vsp_g.FEA_XSEC_RECT
r""" Rectangle XSec type"""
FEA_XSEC_BOX = _vsp_g.FEA_XSEC_BOX
r""" Box XSec type"""
FEA_MASS_FILE_NAME = _vsp_g.FEA_MASS_FILE_NAME
r""" FEA Mesh mass export type"""
FEA_NASTRAN_FILE_NAME = _vsp_g.FEA_NASTRAN_FILE_NAME
r""" FEA Mesh NASTRAN export type"""
FEA_NKEY_FILE_NAME = _vsp_g.FEA_NKEY_FILE_NAME
r""" FEA Mesh NKey export type"""
FEA_CALCULIX_FILE_NAME = _vsp_g.FEA_CALCULIX_FILE_NAME
r""" FEA Mesh Calculix export type"""
FEA_STL_FILE_NAME = _vsp_g.FEA_STL_FILE_NAME
r""" FEA Mesh STL export type"""
FEA_GMSH_FILE_NAME = _vsp_g.FEA_GMSH_FILE_NAME
r""" FEA Mesh GMSH export type"""
FEA_SRF_FILE_NAME = _vsp_g.FEA_SRF_FILE_NAME
r""" FEA Mesh SRF export type"""
FEA_CURV_FILE_NAME = _vsp_g.FEA_CURV_FILE_NAME
r""" FEA Mesh CURV export type"""
FEA_PLOT3D_FILE_NAME = _vsp_g.FEA_PLOT3D_FILE_NAME
r""" FEA Mesh PLOT3D export type"""
FEA_IGES_FILE_NAME = _vsp_g.FEA_IGES_FILE_NAME
r""" FEA Mesh trimmed IGES export type"""
FEA_STEP_FILE_NAME = _vsp_g.FEA_STEP_FILE_NAME
r""" FEA Mesh trimmed STEP export type"""
FEA_NUM_FILE_NAMES = _vsp_g.FEA_NUM_FILE_NAMES
r""" Number of FEA Mesh export type."""
FEA_FIX_PT_ON_BODY = _vsp_g.FEA_FIX_PT_ON_BODY
r""" On body fixed point type"""
FEA_FIX_PT_GLOBAL_XYZ = _vsp_g.FEA_FIX_PT_GLOBAL_XYZ
r""" Global XYZ off body fixed point type"""
FEA_FIX_PT_DELTA_XYZ = _vsp_g.FEA_FIX_PT_DELTA_XYZ
r""" Delta XYZ off body fixed point type"""
FEA_FIX_PT_DELTA_UVN = _vsp_g.FEA_FIX_PT_DELTA_UVN
r""" Delta UVN off body fixed point type"""
FEA_FIX_PT_GEOM_ORIGIN = _vsp_g.FEA_FIX_PT_GEOM_ORIGIN
r""" Geom origin off body fixed point type"""
FEA_FIX_PT_GEOM_CG = _vsp_g.FEA_FIX_PT_GEOM_CG
r""" Geom CG off body fixed point type"""
FEA_NUM_FIX_PT_TYPES = _vsp_g.FEA_NUM_FIX_PT_TYPES
r""" Number of off body fixed point types"""
FEA_ISOTROPIC = _vsp_g.FEA_ISOTROPIC
r""" Isotropic material"""
FEA_ENG_ORTHO = _vsp_g.FEA_ENG_ORTHO
r""" Orthotropic material in engineering parameters"""
FEA_ENG_ORTHO_TRANS_ISO = _vsp_g.FEA_ENG_ORTHO_TRANS_ISO
r""" Orthotropic material with transverse isotropy assumed in engineering parameters"""
FEA_LAMINATE = _vsp_g.FEA_LAMINATE
r""" Laminate buildup material"""
FEA_NUM_MAT_TYPES = _vsp_g.FEA_NUM_MAT_TYPES
r""" Number of FEA material types"""
FEA_ORIENT_GLOBAL_X = _vsp_g.FEA_ORIENT_GLOBAL_X
r""" FEA Global X material orientation"""
FEA_ORIENT_GLOBAL_Y = _vsp_g.FEA_ORIENT_GLOBAL_Y
r""" FEA Global Y material orientation"""
FEA_ORIENT_GLOBAL_Z = _vsp_g.FEA_ORIENT_GLOBAL_Z
r""" FEA Global Z material orientation"""
FEA_ORIENT_COMP_X = _vsp_g.FEA_ORIENT_COMP_X
r""" FEA Comp X material orientation"""
FEA_ORIENT_COMP_Y = _vsp_g.FEA_ORIENT_COMP_Y
r""" FEA Comp Y material orientation"""
FEA_ORIENT_COMP_Z = _vsp_g.FEA_ORIENT_COMP_Z
r""" FEA Comp Z material orientation"""
FEA_ORIENT_PART_U = _vsp_g.FEA_ORIENT_PART_U
r""" FEA Part U material orientation"""
FEA_ORIENT_PART_V = _vsp_g.FEA_ORIENT_PART_V
r""" FEA Part V material orientation"""
FEA_ORIENT_OML_U = _vsp_g.FEA_ORIENT_OML_U
r""" FEA OML U material orientation"""
FEA_ORIENT_OML_V = _vsp_g.FEA_ORIENT_OML_V
r""" FEA OML V material orientation"""
FEA_ORIENT_OML_R = _vsp_g.FEA_ORIENT_OML_R
r""" FEA OML R material orientation"""
FEA_ORIENT_OML_S = _vsp_g.FEA_ORIENT_OML_S
r""" FEA OML S material orientation"""
FEA_ORIENT_OML_T = _vsp_g.FEA_ORIENT_OML_T
r""" FEA OML T material orientation"""
FEA_NUM_ORIENT_TYPES = _vsp_g.FEA_NUM_ORIENT_TYPES
r""" Number of FEA material orientation types"""
FEA_DEPRECATED = _vsp_g.FEA_DEPRECATED
r""" Flag for deprecated element type option"""
FEA_SHELL = _vsp_g.FEA_SHELL
r""" Shell (tris) FEA element type"""
FEA_BEAM = _vsp_g.FEA_BEAM
r""" Beam FEA element type"""
FEA_SHELL_AND_BEAM = _vsp_g.FEA_SHELL_AND_BEAM
r""" Both Shell and Beam FEA element types"""
FEA_NO_ELEMENTS = _vsp_g.FEA_NO_ELEMENTS
r""" FEA part with no elements"""
FEA_NUM_ELEMENT_TYPES = _vsp_g.FEA_NUM_ELEMENT_TYPES
r""" Number of FEA element type choices"""
FEA_SLICE = _vsp_g.FEA_SLICE
r""" Slice FEA Part type"""
FEA_RIB = _vsp_g.FEA_RIB
r""" Rib FEA Part type"""
FEA_SPAR = _vsp_g.FEA_SPAR
r""" Spar FEA Part type"""
FEA_FIX_POINT = _vsp_g.FEA_FIX_POINT
r""" Fixed Point FEA Part type"""
FEA_DOME = _vsp_g.FEA_DOME
r""" Dome FEA Part type"""
FEA_RIB_ARRAY = _vsp_g.FEA_RIB_ARRAY
r""" Rib array FEA Part type"""
FEA_SLICE_ARRAY = _vsp_g.FEA_SLICE_ARRAY
r""" Slice array FEA Part type"""
FEA_SKIN = _vsp_g.FEA_SKIN
r""" Skin FEA Part type"""
FEA_TRIM = _vsp_g.FEA_TRIM
r""" Trim FEA Part type"""
FEA_POLY_SPAR = _vsp_g.FEA_POLY_SPAR
r""" Poly Spar FEA Part type"""
FEA_NUM_TYPES = _vsp_g.FEA_NUM_TYPES
r""" Number of FEA Part types"""
NO_NORMAL = _vsp_g.NO_NORMAL
r""" FEA Rib or Rib Array has no set perpendicular edge"""
LE_NORMAL = _vsp_g.LE_NORMAL
r""" FEA Rib or Rib Array is set perpendicular to the leading edge"""
TE_NORMAL = _vsp_g.TE_NORMAL
r""" FEA Rib or Rib Array is set perpendicular to the trailing edge"""
SPAR_NORMAL = _vsp_g.SPAR_NORMAL
r""" FEA Rib or Rib Array is set perpendicular to an FEA Spar"""
FEA_KEEP = _vsp_g.FEA_KEEP
r""" Keep shell elements"""
FEA_DELETE = _vsp_g.FEA_DELETE
r""" Delete shell elements"""
FEA_NUM_SHELL_TREATMENT_TYPES = _vsp_g.FEA_NUM_SHELL_TREATMENT_TYPES
r""" Number of FEA subsurface treatment choices"""
XY_BODY = _vsp_g.XY_BODY
r""" Slice is parallel to parent Geom body XY plane"""
YZ_BODY = _vsp_g.YZ_BODY
r""" Slice is parallel to parent Geom body YZ plane"""
XZ_BODY = _vsp_g.XZ_BODY
r""" Slice is parallel to parent Geom body XZ plane"""
XY_ABS = _vsp_g.XY_ABS
r""" Slice is parallel to absolute XY plane"""
YZ_ABS = _vsp_g.YZ_ABS
r""" Slice is parallel to absolute YZ plane"""
XZ_ABS = _vsp_g.XZ_ABS
r""" Slice is parallel to absolute XZ plane"""
SPINE_NORMAL = _vsp_g.SPINE_NORMAL
r""" Slice is perpendicular to thespine of the parent Geom"""
POLY_SPAR_POINT_U01 = _vsp_g.POLY_SPAR_POINT_U01
r""" Spar points span specified in U01"""
POLY_SPAR_POINT_U0N = _vsp_g.POLY_SPAR_POINT_U0N
r""" Spar points span specified in U0N"""
POLY_SPAR_POINT_ETA = _vsp_g.POLY_SPAR_POINT_ETA
r""" Spar points span specified in eta"""
NUM_POLY_SPAR_POINT_TYPES = _vsp_g.NUM_POLY_SPAR_POINT_TYPES
r""" Number of poly spar point types"""
SI_UNIT = _vsp_g.SI_UNIT
r""" FEA Files output in (m, kg)"""
CGS_UNIT = _vsp_g.CGS_UNIT
r""" FEA Files output in (cm, g)"""
MPA_UNIT = _vsp_g.MPA_UNIT
r""" FEA Files output in (mm, tonne)"""
BFT_UNIT = _vsp_g.BFT_UNIT
r""" FEA Files output in (ft, slug)"""
BIN_UNIT = _vsp_g.BIN_UNIT
r""" FEA Files output in (in, lbf*sec^2/in)"""
FF_B_MANUAL = _vsp_g.FF_B_MANUAL
r""" Manual FF equation"""
FF_B_SCHEMENSKY_FUSE = _vsp_g.FF_B_SCHEMENSKY_FUSE
r""" Schemensky Fuselage FF equation"""
FF_B_SCHEMENSKY_NACELLE = _vsp_g.FF_B_SCHEMENSKY_NACELLE
r""" Schemensky Nacelle FF equation"""
FF_B_HOERNER_STREAMBODY = _vsp_g.FF_B_HOERNER_STREAMBODY
r""" Hoerner Streamlined Body FF equation"""
FF_B_TORENBEEK = _vsp_g.FF_B_TORENBEEK
r""" Torenbeek FF equation"""
FF_B_SHEVELL = _vsp_g.FF_B_SHEVELL
r""" Shevell FF equation"""
FF_B_COVERT = _vsp_g.FF_B_COVERT
r""" Covert FF equation"""
FF_B_JENKINSON_FUSE = _vsp_g.FF_B_JENKINSON_FUSE
r""" Jenkinson Fuselage FF equation"""
FF_B_JENKINSON_WING_NACELLE = _vsp_g.FF_B_JENKINSON_WING_NACELLE
r""" Jenkinson Wing Nacelle FF equation"""
FF_B_JENKINSON_AFT_FUSE_NACELLE = _vsp_g.FF_B_JENKINSON_AFT_FUSE_NACELLE
r""" Jenkinson Aft Fuselage Nacelle FF equation"""
FF_W_MANUAL = _vsp_g.FF_W_MANUAL
r""" Manual FF equation"""
FF_W_EDET_CONV = _vsp_g.FF_W_EDET_CONV
r""" EDET Conventional Airfoil FF equation"""
FF_W_EDET_ADV = _vsp_g.FF_W_EDET_ADV
r""" EDET Advanced Airfoil FF equation"""
FF_W_HOERNER = _vsp_g.FF_W_HOERNER
r""" Hoerner FF equation"""
FF_W_COVERT = _vsp_g.FF_W_COVERT
r""" Covert FF equation"""
FF_W_SHEVELL = _vsp_g.FF_W_SHEVELL
r""" Shevell FF equation"""
FF_W_KROO = _vsp_g.FF_W_KROO
r""" Kroo FF equation"""
FF_W_TORENBEEK = _vsp_g.FF_W_TORENBEEK
r""" Torenbeek FF equation"""
FF_W_DATCOM = _vsp_g.FF_W_DATCOM
r""" DATCOM FF equation"""
FF_W_SCHEMENSKY_6_SERIES_AF = _vsp_g.FF_W_SCHEMENSKY_6_SERIES_AF
r""" Schemensky 6 Series Airfoil FF equation"""
FF_W_SCHEMENSKY_4_SERIES_AF = _vsp_g.FF_W_SCHEMENSKY_4_SERIES_AF
r""" Schemensky 4 Series Airfoil FF equation"""
FF_W_JENKINSON_WING = _vsp_g.FF_W_JENKINSON_WING
r""" Jenkinson Wing FF equation"""
FF_W_JENKINSON_TAIL = _vsp_g.FF_W_JENKINSON_TAIL
r""" Jenkinson Tail FF equation"""
FF_W_SCHEMENSKY_SUPERCRITICAL_AF = _vsp_g.FF_W_SCHEMENSKY_SUPERCRITICAL_AF
r""" Schemensky Supercritical Airfoil FF equation"""
ONE_THIRD_ROTOR_FRAGMENT = _vsp_g.ONE_THIRD_ROTOR_FRAGMENT
r""" One third rotor fragment"""
INTERMEDIATE_FRAGMENT = _vsp_g.INTERMEDIATE_FRAGMENT
r""" Intermediate rotor fragment"""
ALTERNATE_FRAGMENT = _vsp_g.ALTERNATE_FRAGMENT
r""" Alternate rotor fragment model"""
FAN_FRAGMENT = _vsp_g.FAN_FRAGMENT
r""" Fan blade fragment"""
SMALL_FRAGMENT = _vsp_g.SMALL_FRAGMENT
r""" Small fragment"""
GENERIC_FRAGMENT = _vsp_g.GENERIC_FRAGMENT
r""" Generic fragment"""
NUM_FRAGMENT_MODES = _vsp_g.NUM_FRAGMENT_MODES
r""" Number of auxiliary geom modes."""
PD_UNITS_IMPERIAL = _vsp_g.PD_UNITS_IMPERIAL
r""" Imperial unit system"""
PD_UNITS_METRIC = _vsp_g.PD_UNITS_METRIC
r""" Metric unit system"""
OPEN = _vsp_g.OPEN
r""" Browse files that already exist"""
SAVE = _vsp_g.SAVE
r""" Browse file system and enter file name"""
NUM_FILE_CHOOSER_MODES = _vsp_g.NUM_FILE_CHOOSER_MODES
r""" Number of file chooser modes"""
FC_OPENVSP = _vsp_g.FC_OPENVSP
r""" OpenVSP's own file chooser with directory preferences."""
FC_NATIVE = _vsp_g.FC_NATIVE
r""" Operating system's native file chooser"""
NUM_FILE_CHOOSER_TYPES = _vsp_g.NUM_FILE_CHOOSER_TYPES
r""" Number of file chooser types"""
GDEV_TAB = _vsp_g.GDEV_TAB
r""" Custom GUI Tab"""
GDEV_SCROLL_TAB = _vsp_g.GDEV_SCROLL_TAB
r""" Custom GUI Fl_Scroll and Tab"""
GDEV_GROUP = _vsp_g.GDEV_GROUP
r""" Custom GUI Group"""
GDEV_PARM_BUTTON = _vsp_g.GDEV_PARM_BUTTON
r""" Custom GUI ParmButton"""
GDEV_INPUT = _vsp_g.GDEV_INPUT
r""" Custom GUI Input"""
GDEV_OUTPUT = _vsp_g.GDEV_OUTPUT
r""" Custom GUI Output"""
GDEV_SLIDER = _vsp_g.GDEV_SLIDER
r""" Custom GUI Slider"""
GDEV_SLIDER_ADJ_RANGE = _vsp_g.GDEV_SLIDER_ADJ_RANGE
r""" Custom GUI SliderAdjRangeInput"""
GDEV_CHECK_BUTTON = _vsp_g.GDEV_CHECK_BUTTON
r""" Custom GUI CheckButton"""
GDEV_CHECK_BUTTON_BIT = _vsp_g.GDEV_CHECK_BUTTON_BIT
r""" Custom GUI CheckButtonBit"""
GDEV_RADIO_BUTTON = _vsp_g.GDEV_RADIO_BUTTON
r""" Custom GUI RadioButton"""
GDEV_TOGGLE_BUTTON = _vsp_g.GDEV_TOGGLE_BUTTON
r""" Custom GUI ToggleButton"""
GDEV_TOGGLE_BUTTON_FREE = _vsp_g.GDEV_TOGGLE_BUTTON_FREE
r""" Custom GUI ToggleButton without Parm"""
GDEV_TOGGLE_RADIO_GROUP = _vsp_g.GDEV_TOGGLE_RADIO_GROUP
r""" Custom GUI ToggleRadioGroup (NOT IMPLEMENTED)"""
GDEV_TRIGGER_BUTTON = _vsp_g.GDEV_TRIGGER_BUTTON
r""" Custom GUI TriggerButton"""
GDEV_COUNTER = _vsp_g.GDEV_COUNTER
r""" Custom GUI Counter"""
GDEV_CHOICE = _vsp_g.GDEV_CHOICE
r""" Custom GUI Choice"""
GDEV_ADD_CHOICE_ITEM = _vsp_g.GDEV_ADD_CHOICE_ITEM
r""" Add item to custom GUI Choice"""
GDEV_SLIDER_INPUT = _vsp_g.GDEV_SLIDER_INPUT
r""" Custom GUI SliderInput"""
GDEV_SLIDER_ADJ_RANGE_INPUT = _vsp_g.GDEV_SLIDER_ADJ_RANGE_INPUT
r""" Custom GUI SliderAdjRangeInput"""
GDEV_SLIDER_ADJ_RANGE_TWO_INPUT = _vsp_g.GDEV_SLIDER_ADJ_RANGE_TWO_INPUT
r""" Custom GUI SliderAdjRangeInput with two inputs (NOT IMPLEMENTED)"""
GDEV_FRACT_PARM_SLIDER = _vsp_g.GDEV_FRACT_PARM_SLIDER
r""" Custom GUI FractParmSlider"""
GDEV_STRING_INPUT = _vsp_g.GDEV_STRING_INPUT
r""" Custom GUI StringInput"""
GDEV_INDEX_SELECTOR = _vsp_g.GDEV_INDEX_SELECTOR
r""" Custom GUI IndexSelector"""
GDEV_COLOR_PICKER = _vsp_g.GDEV_COLOR_PICKER
r""" Custom GUI ColorPicker"""
GDEV_YGAP = _vsp_g.GDEV_YGAP
r""" Custom GUI Y gap"""
GDEV_DIVIDER_BOX = _vsp_g.GDEV_DIVIDER_BOX
r""" Custom GUI divider box"""
GDEV_BEGIN_SAME_LINE = _vsp_g.GDEV_BEGIN_SAME_LINE
r""" Set begin same line flag for custom GUI"""
GDEV_END_SAME_LINE = _vsp_g.GDEV_END_SAME_LINE
r""" Set end same line flag for custom GUI"""
GDEV_FORCE_WIDTH = _vsp_g.GDEV_FORCE_WIDTH
r""" Set forced width for custom GUI"""
GDEV_SET_FORMAT = _vsp_g.GDEV_SET_FORMAT
r""" Set format label for custom GUI"""
NUM_GDEV_TYPES = _vsp_g.NUM_GDEV_TYPES
r""" Number of GDEV types"""
ALL_GDEV_TYPES = _vsp_g.ALL_GDEV_TYPES
r""" Flag for all GDEV types"""
GEAR_CONFIGURATION_DOWN = _vsp_g.GEAR_CONFIGURATION_DOWN
r""" Gear drawn down"""
GEAR_CONFIGURATION_UP = _vsp_g.GEAR_CONFIGURATION_UP
r""" Gear drawn up"""
GEAR_CONFIGURATION_UP_AND_DOWN = _vsp_g.GEAR_CONFIGURATION_UP_AND_DOWN
r""" Gear drawn both up and down"""
GEAR_CONFIGURATION_INTERMEDIATE = _vsp_g.GEAR_CONFIGURATION_INTERMEDIATE
r""" Gear drawn somewhere beteween down and up"""
GEAR_CONFIGURATION_ALL = _vsp_g.GEAR_CONFIGURATION_ALL
r""" Gear drawn in all configurations"""
NUM_GEAR_CONFIGURATION_MODES = _vsp_g.NUM_GEAR_CONFIGURATION_MODES
r""" Number of gear configuration choices"""
GEAR_STOWED_POSITION = _vsp_g.GEAR_STOWED_POSITION
r""" Specified by stowed position"""
GEAR_MECHANISM = _vsp_g.GEAR_MECHANISM
r""" Specified by mechanism"""
NUM_GEAR_RETRACT_MODES = _vsp_g.NUM_GEAR_RETRACT_MODES
r""" Number of gear retract choices"""
GEAR_SUSPENSION_NOMINAL = _vsp_g.GEAR_SUSPENSION_NOMINAL
r""" Gear suspension at nominal extension"""
GEAR_SUSPENSION_COMPRESSED = _vsp_g.GEAR_SUSPENSION_COMPRESSED
r""" Gear suspension is compressed"""
GEAR_SUSPENSION_EXTENDED = _vsp_g.GEAR_SUSPENSION_EXTENDED
r""" Gear suspension is extended"""
NUM_GEAR_SUSPENSION_MODES = _vsp_g.NUM_GEAR_SUSPENSION_MODES
r""" Number of gear suspension choices"""
MALE = _vsp_g.MALE
r""" Male Human component"""
FEMALE = _vsp_g.FEMALE
r""" Female Human component"""
EXTERNAL_INTERFERENCE = _vsp_g.EXTERNAL_INTERFERENCE
r""" Interference between mutually external bodies"""
PACKAGING_INTERFERENCE = _vsp_g.PACKAGING_INTERFERENCE
r""" Interference when one body is internal to another"""
EXTERNAL_SELF_INTERFERENCE = _vsp_g.EXTERNAL_SELF_INTERFERENCE
r""" Interference between multiple surfaces of one Geom / Set"""
PLANE_STATIC_DISTANCE_INTERFERENCE = _vsp_g.PLANE_STATIC_DISTANCE_INTERFERENCE
r""" Interference between surfaces and a plane"""
PLANE_2PT_ANGLE_INTERFERENCE = _vsp_g.PLANE_2PT_ANGLE_INTERFERENCE
r""" Interference angle between surfaces and a plane"""
GEAR_CG_TIPBACK_ANALYSIS = _vsp_g.GEAR_CG_TIPBACK_ANALYSIS
r""" Calculate tipback angle"""
PLANE_1PT_ANGLE_INTERFERENCE = _vsp_g.PLANE_1PT_ANGLE_INTERFERENCE
r""" Interference roll angle between surfaces and a plane"""
GEAR_WEIGHT_DISTRIBUTION_ANALYSIS = _vsp_g.GEAR_WEIGHT_DISTRIBUTION_ANALYSIS
r""" Calculate distribution of weight across landing gear"""
GEAR_TIPOVER_ANALYSIS = _vsp_g.GEAR_TIPOVER_ANALYSIS
r""" Calculate tipover angle"""
GEAR_TURN_ANALYSIS = _vsp_g.GEAR_TURN_ANALYSIS
r""" Calculate ground manueveribility"""
VISIBLE_FROM_POINT_ANALYSIS = _vsp_g.VISIBLE_FROM_POINT_ANALYSIS
r""" Calculate az,el domain visible from a point"""
CCE_INTERFERENCE = _vsp_g.CCE_INTERFERENCE
r""" Interference with composite clearance envelope"""
LINEAR_SWEPT_VOLUME_ANALYSIS = _vsp_g.LINEAR_SWEPT_VOLUME_ANALYSIS
r""" Interference with linear swept volume"""
VISIBLE_AT_SURF_ANALYSIS = _vsp_g.VISIBLE_AT_SURF_ANALYSIS
r""" Calculate visibility of a surface from a direction"""
RISK_ANGLE = _vsp_g.RISK_ANGLE
r""" Calculate risk angle for thrown debris"""
COMP_GEOM = _vsp_g.COMP_GEOM
r""" Calculate wetted area and volume"""
PLANAR_SLICE = _vsp_g.PLANAR_SLICE
r""" Calculate planar slices and area distribution"""
PROJ_AREA = _vsp_g.PROJ_AREA
r""" Calculate projected area"""
MASS_PROP = _vsp_g.MASS_PROP
r""" Calculate mass properties"""
AERO_CENTER = _vsp_g.AERO_CENTER
r""" Calculate aero center of single lifting surface"""
NUM_INTERFERENCE_TYPES = _vsp_g.NUM_INTERFERENCE_TYPES
r""" Number of interference check types"""
POD_GEOM_SCREEN = _vsp_g.POD_GEOM_SCREEN
r""" Pod geom screen"""
FUSELAGE_GEOM_SCREEN = _vsp_g.FUSELAGE_GEOM_SCREEN
r""" Fuselage geom screen"""
MS_WING_GEOM_SCREEN = _vsp_g.MS_WING_GEOM_SCREEN
r""" Wing geom screen"""
BLANK_GEOM_SCREEN = _vsp_g.BLANK_GEOM_SCREEN
r""" Blank geom screen"""
MESH_GEOM_SCREEN = _vsp_g.MESH_GEOM_SCREEN
r""" Mesh geom screen"""
NGON_MESH_GEOM_SCREEN = _vsp_g.NGON_MESH_GEOM_SCREEN
r""" NGon Mesh geom screen"""
STACK_GEOM_SCREEN = _vsp_g.STACK_GEOM_SCREEN
r""" Stack geom screen"""
CUSTOM_GEOM_SCREEN = _vsp_g.CUSTOM_GEOM_SCREEN
r""" Custom geom screen"""
PT_CLOUD_GEOM_SCREEN = _vsp_g.PT_CLOUD_GEOM_SCREEN
r""" Point cloud geom screen"""
PROP_GEOM_SCREEN = _vsp_g.PROP_GEOM_SCREEN
r""" Propeller geom screen"""
HINGE_GEOM_SCREEN = _vsp_g.HINGE_GEOM_SCREEN
r""" Hinge geom screen"""
MULT_GEOM_SCREEN = _vsp_g.MULT_GEOM_SCREEN
r""" Multiple geom screen"""
CONFORMAL_SCREEN = _vsp_g.CONFORMAL_SCREEN
r""" Conformal geom screen"""
ELLIPSOID_GEOM_SCREEN = _vsp_g.ELLIPSOID_GEOM_SCREEN
r""" Ellipsoid geom screen"""
BOR_GEOM_SCREEN = _vsp_g.BOR_GEOM_SCREEN
r""" Body of revolution geom screen"""
WIRE_FRAME_GEOM_SCREEN = _vsp_g.WIRE_FRAME_GEOM_SCREEN
r""" Wireframe geom screen"""
HUMAN_GEOM_SCREEN = _vsp_g.HUMAN_GEOM_SCREEN
r""" Human geom screen"""
ROUTING_GEOM_SCREEN = _vsp_g.ROUTING_GEOM_SCREEN
r""" Routing geom screen"""
AUXILIARY_GEOM_SCREEN = _vsp_g.AUXILIARY_GEOM_SCREEN
r""" Auxiliary geom screen"""
GEAR_GEOM_SCREEN = _vsp_g.GEAR_GEOM_SCREEN
r""" Gear geom screen"""
COBRA_GEOM_SCREEN = _vsp_g.COBRA_GEOM_SCREEN
r""" Cobra body geom screen"""
NUM_GEOM_SCREENS = _vsp_g.NUM_GEOM_SCREENS
r""" Number of geom screens"""
ALL_GEOM_SCREENS = _vsp_g.ALL_GEOM_SCREENS
r""" All geom screens"""
VSP_ADV_LINK_SCREEN = _vsp_g.VSP_ADV_LINK_SCREEN
r""" Advanced linking screen"""
VSP_ADV_LINK_VAR_RENAME_SCREEN = _vsp_g.VSP_ADV_LINK_VAR_RENAME_SCREEN
r""" Advanced link variable rename screen"""
VSP_AERO_STRUCT_SCREEN = _vsp_g.VSP_AERO_STRUCT_SCREEN
r""" Aero / structural analysis screen"""
VSP_AIRFOIL_CURVES_EXPORT_SCREEN = _vsp_g.VSP_AIRFOIL_CURVES_EXPORT_SCREEN
r""" Airfoil curves export screen"""
VSP_AIRFOIL_POINTS_EXPORT_SCREEN = _vsp_g.VSP_AIRFOIL_POINTS_EXPORT_SCREEN
r""" Airfoil points screen"""
VSP_ATTRIBUTE_EXPLORER_SCREEN = _vsp_g.VSP_ATTRIBUTE_EXPLORER_SCREEN
r""" Attribute details screen"""
VSP_BACKGROUND_SCREEN = _vsp_g.VSP_BACKGROUND_SCREEN
r""" Background control screen"""
VSP_BACKGROUND3D_SCREEN = _vsp_g.VSP_BACKGROUND3D_SCREEN
r""" Background3D control screen"""
VSP_BACKGROUND3D_PREVIEW_SCREEN = _vsp_g.VSP_BACKGROUND3D_PREVIEW_SCREEN
r""" Background3D preview screen"""
VSP_BEM_OPTIONS_SCREEN = _vsp_g.VSP_BEM_OPTIONS_SCREEN
r""" Blade element method options screen"""
VSP_CFD_MESH_SCREEN = _vsp_g.VSP_CFD_MESH_SCREEN
r""" CFD Mesh screen"""
VSP_CLIPPING_SCREEN = _vsp_g.VSP_CLIPPING_SCREEN
r""" Clipping screen"""
VSP_COMP_GEOM_SCREEN = _vsp_g.VSP_COMP_GEOM_SCREEN
r""" CompGeom screen"""
VSP_COR_SCREEN = _vsp_g.VSP_COR_SCREEN
r""" Center of rotation screen"""
VSP_CURVE_EDIT_SCREEN = _vsp_g.VSP_CURVE_EDIT_SCREEN
r""" Curve edit screen"""
VSP_DEGEN_GEOM_SCREEN = _vsp_g.VSP_DEGEN_GEOM_SCREEN
r""" Degen geom screen"""
VSP_DESIGN_VAR_SCREEN = _vsp_g.VSP_DESIGN_VAR_SCREEN
r""" Design variables screen"""
VSP_DXF_OPTIONS_SCREEN = _vsp_g.VSP_DXF_OPTIONS_SCREEN
r""" DXF options screen"""
VSP_EXPORT_SCREEN = _vsp_g.VSP_EXPORT_SCREEN
r""" Export screen"""
VSP_FEA_PART_EDIT_SCREEN = _vsp_g.VSP_FEA_PART_EDIT_SCREEN
r""" FEA Part edit screen"""
VSP_FEA_XSEC_SCREEN = _vsp_g.VSP_FEA_XSEC_SCREEN
r""" FEA XSec screen"""
VSP_FIT_MODEL_SCREEN = _vsp_g.VSP_FIT_MODEL_SCREEN
r""" Fit model screen"""
VSP_IGES_OPTIONS_SCREEN = _vsp_g.VSP_IGES_OPTIONS_SCREEN
r""" IGES options screen"""
VSP_IGES_STRUCTURE_OPTIONS_SCREEN = _vsp_g.VSP_IGES_STRUCTURE_OPTIONS_SCREEN
r""" IGES structure options screen"""
VSP_EXPORT_CUSTOM_SCRIPT = _vsp_g.VSP_EXPORT_CUSTOM_SCRIPT
r""" Custom geom export screen"""
VSP_GEOMETRY_ANALYSIS_SCREEN = _vsp_g.VSP_GEOMETRY_ANALYSIS_SCREEN
r""" Geometry analysis screen"""
VSP_IMPORT_SCREEN = _vsp_g.VSP_IMPORT_SCREEN
r""" Import screen"""
VSP_LIGHTING_SCREEN = _vsp_g.VSP_LIGHTING_SCREEN
r""" Lighting screen"""
VSP_MANAGE_GEOM_SCREEN = _vsp_g.VSP_MANAGE_GEOM_SCREEN
r""" Manage geom screen"""
VSP_MANAGE_TEXTURE_SCREEN = _vsp_g.VSP_MANAGE_TEXTURE_SCREEN
r""" Texture mapping screen"""
VSP_MASS_PROP_SCREEN = _vsp_g.VSP_MASS_PROP_SCREEN
r""" Mass properties screen"""
VSP_MATERIAL_EDIT_SCREEN = _vsp_g.VSP_MATERIAL_EDIT_SCREEN
r""" Material edit screen"""
VSP_MEASURE_SCREEN = _vsp_g.VSP_MEASURE_SCREEN
r""" Measure screen"""
VSP_MODE_EDITOR_SCREEN = _vsp_g.VSP_MODE_EDITOR_SCREEN
r""" Mode editor screen"""
VSP_NERF_MANAGE_GEOM_SCREEN = _vsp_g.VSP_NERF_MANAGE_GEOM_SCREEN
r""" NERF'ed (limited to make safe) Manage geom screen"""
VSP_SNAP_TO_SCREEN = _vsp_g.VSP_SNAP_TO_SCREEN
r""" Snap to screen"""
VSP_PARASITE_DRAG_SCREEN = _vsp_g.VSP_PARASITE_DRAG_SCREEN
r""" Parasite drg screen"""
VSP_PARM_DEBUG_SCREEN = _vsp_g.VSP_PARM_DEBUG_SCREEN
r""" Parameter debug screen"""
VSP_PARM_LINK_SCREEN = _vsp_g.VSP_PARM_LINK_SCREEN
r""" Parameter linking screen"""
VSP_PARM_SCREEN = _vsp_g.VSP_PARM_SCREEN
r""" Parameter screen"""
VSP_PICK_SET_SCREEN = _vsp_g.VSP_PICK_SET_SCREEN
r""" Pick set screen"""
VSP_PREFERENCES_SCREEN = _vsp_g.VSP_PREFERENCES_SCREEN
r""" Preferences screen"""
VSP_PROJECTION_SCREEN = _vsp_g.VSP_PROJECTION_SCREEN
r""" Projected area screen"""
VSP_PSLICE_SCREEN = _vsp_g.VSP_PSLICE_SCREEN
r""" Planar slicing screen"""
VSP_RESULTS_VIEWER_SCREEN = _vsp_g.VSP_RESULTS_VIEWER_SCREEN
r""" Results viewing screen"""
VSP_SCREENSHOT_SCREEN = _vsp_g.VSP_SCREENSHOT_SCREEN
r""" Screenshot screen"""
VSP_SELECT_FILE_SCREEN = _vsp_g.VSP_SELECT_FILE_SCREEN
r""" Select file screen"""
VSP_SET_EDITOR_SCREEN = _vsp_g.VSP_SET_EDITOR_SCREEN
r""" Set editor screen"""
VSP_STEP_OPTIONS_SCREEN = _vsp_g.VSP_STEP_OPTIONS_SCREEN
r""" STEP options screen"""
VSP_STEP_STRUCTURE_OPTIONS_SCREEN = _vsp_g.VSP_STEP_STRUCTURE_OPTIONS_SCREEN
r""" STEP structure options screen"""
VSP_STL_OPTIONS_SCREEN = _vsp_g.VSP_STL_OPTIONS_SCREEN
r""" STL options screen"""
VSP_STRUCT_SCREEN = _vsp_g.VSP_STRUCT_SCREEN
r""" Structure definition screen"""
VSP_STRUCT_ASSEMBLY_SCREEN = _vsp_g.VSP_STRUCT_ASSEMBLY_SCREEN
r""" Structure assembly screen"""
VSP_SURFACE_INTERSECTION_SCREEN = _vsp_g.VSP_SURFACE_INTERSECTION_SCREEN
r""" Surface intersection screen"""
VSP_SVG_OPTIONS_SCREEN = _vsp_g.VSP_SVG_OPTIONS_SCREEN
r""" SVG options screen"""
VSP_USER_PARM_SCREEN = _vsp_g.VSP_USER_PARM_SCREEN
r""" User parameter screen"""
VSP_VAR_PRESET_SCREEN = _vsp_g.VSP_VAR_PRESET_SCREEN
r""" Variable presets editor screen"""
VSP_VEH_NOTES_SCREEN = _vsp_g.VSP_VEH_NOTES_SCREEN
r""" Vehicle notes screen"""
VSP_VEH_SCREEN = _vsp_g.VSP_VEH_SCREEN
r""" Veh geom screen"""
VSP_VIEW_SCREEN = _vsp_g.VSP_VIEW_SCREEN
r""" Adjust viewpoint screen"""
VSP_VSPAERO_PLOT_SCREEN = _vsp_g.VSP_VSPAERO_PLOT_SCREEN
r""" VSPAERO results manager screen"""
VSP_VSPAERO_SCREEN = _vsp_g.VSP_VSPAERO_SCREEN
r""" VSPAERO screen"""
VSP_XSEC_SCREEN = _vsp_g.VSP_XSEC_SCREEN
r""" XSec screen"""
VSP_WAVEDRAG_SCREEN = _vsp_g.VSP_WAVEDRAG_SCREEN
r""" Wave drag screen"""
VSP_MAIN_SCREEN = _vsp_g.VSP_MAIN_SCREEN
r""" Main screen"""
VSP_NUM_SCREENS = _vsp_g.VSP_NUM_SCREENS
r""" Number of screens"""
VSP_ALL_SCREENS = _vsp_g.VSP_ALL_SCREENS
r""" Flag for all screens"""
EDIT_XSEC_CIRCLE = _vsp_g.EDIT_XSEC_CIRCLE
r""" Circle initialized as cubic Bezier type"""
EDIT_XSEC_ELLIPSE = _vsp_g.EDIT_XSEC_ELLIPSE
r""" Ellipse initialized as PCHIP type"""
EDIT_XSEC_RECTANGLE = _vsp_g.EDIT_XSEC_RECTANGLE
r""" Rectangle initialized as linear type"""
NUM_INIT_EDIT_XSEC_TYPES = _vsp_g.NUM_INIT_EDIT_XSEC_TYPES
r""" Number of initializable edit curve types"""
IMPORT_STL = _vsp_g.IMPORT_STL
r""" Stereolith (\*.stl) import"""
IMPORT_NASCART = _vsp_g.IMPORT_NASCART
r""" NASCART (\*.dat) import"""
IMPORT_CART3D_TRI = _vsp_g.IMPORT_CART3D_TRI
r""" Cart3D (\*.try) import"""
IMPORT_XSEC_MESH = _vsp_g.IMPORT_XSEC_MESH
r""" XSec as Tri Mesh (\*.hrm) import"""
IMPORT_PTS = _vsp_g.IMPORT_PTS
r""" Point Cloud (\*.pts) import"""
IMPORT_V2 = _vsp_g.IMPORT_V2
r""" OpenVSP v2 (\*.vsp) import"""
IMPORT_BEM = _vsp_g.IMPORT_BEM
r""" Blade Element (\*.bem) import"""
IMPORT_XSEC_WIRE = _vsp_g.IMPORT_XSEC_WIRE
r""" XSec as Wireframe (\*.hrm) import"""
IMPORT_P3D_WIRE = _vsp_g.IMPORT_P3D_WIRE
r""" Plot3D as Wireframe (\*.p3d) import"""
INTERSECT_SRF_FILE_NAME = _vsp_g.INTERSECT_SRF_FILE_NAME
r""" SRF intersection file type"""
INTERSECT_CURV_FILE_NAME = _vsp_g.INTERSECT_CURV_FILE_NAME
r""" CURV intersection file type"""
INTERSECT_PLOT3D_FILE_NAME = _vsp_g.INTERSECT_PLOT3D_FILE_NAME
r""" PLOT3D intersection file type"""
INTERSECT_IGES_FILE_NAME = _vsp_g.INTERSECT_IGES_FILE_NAME
r""" IGES intersection file type"""
INTERSECT_STEP_FILE_NAME = _vsp_g.INTERSECT_STEP_FILE_NAME
r""" STEP intersection file type"""
INTERSECT_NUM_FILE_NAMES = _vsp_g.INTERSECT_NUM_FILE_NAMES
r""" Number of surface intersection file types"""
LEN_MM = _vsp_g.LEN_MM
r""" Millimeter"""
LEN_CM = _vsp_g.LEN_CM
r""" Centimeter"""
LEN_M = _vsp_g.LEN_M
r""" Meter"""
LEN_IN = _vsp_g.LEN_IN
r""" Inch"""
LEN_FT = _vsp_g.LEN_FT
r""" Feet"""
LEN_YD = _vsp_g.LEN_YD
r""" Yard"""
LEN_UNITLESS = _vsp_g.LEN_UNITLESS
r""" Unitless"""
NUM_LEN_UNIT = _vsp_g.NUM_LEN_UNIT
r""" Number of length unit types"""
MASS_UNIT_G = _vsp_g.MASS_UNIT_G
r""" Gram"""
MASS_UNIT_KG = _vsp_g.MASS_UNIT_KG
r""" Kilogram"""
MASS_UNIT_TONNE = _vsp_g.MASS_UNIT_TONNE
r""" Tonne"""
MASS_UNIT_LBM = _vsp_g.MASS_UNIT_LBM
r""" Pound-mass"""
MASS_UNIT_SLUG = _vsp_g.MASS_UNIT_SLUG
r""" Slug"""
MASS_LBFSEC2IN = _vsp_g.MASS_LBFSEC2IN
r""" lbf*sec^2/in"""
NUM_MASS_UNIT = _vsp_g.NUM_MASS_UNIT
r""" Number of mass unit types"""
NO_REASON = _vsp_g.NO_REASON
r""" No reason determined."""
MAX_LEN_CONSTRAINT = _vsp_g.MAX_LEN_CONSTRAINT
r""" Maximum edge length."""
CURV_GAP = _vsp_g.CURV_GAP
r""" Maximum gap curvature based criteria."""
CURV_NCIRCSEG = _vsp_g.CURV_NCIRCSEG
r""" Minimum number of segments to define a circle curvature based criteria."""
SOURCES = _vsp_g.SOURCES
r""" Mesh sources."""
MIN_LEN_CONSTRAINT = _vsp_g.MIN_LEN_CONSTRAINT
r""" Minimum edge length."""
MIN_LEN_CONSTRAINT_CURV_GAP = _vsp_g.MIN_LEN_CONSTRAINT_CURV_GAP
r""" Maximum gap constrained by minimum length."""
MIN_LEN_CONSTRAINT_CURV_NCIRCSEG = _vsp_g.MIN_LEN_CONSTRAINT_CURV_NCIRCSEG
r""" Number of segments to define a circle constrained by minimum length."""
MIN_LEN_CONSTRAINT_SOURCES = _vsp_g.MIN_LEN_CONSTRAINT_SOURCES
r""" Mesh sources constrained by minimum length (not applied)."""
GROW_LIMIT_MAX_LEN_CONSTRAINT = _vsp_g.GROW_LIMIT_MAX_LEN_CONSTRAINT
r""" Maximum growth limit from maximum edge length (not used, growth limited small to large)."""
GROW_LIMIT_CURV_GAP = _vsp_g.GROW_LIMIT_CURV_GAP
r""" Maximum growth limit from maximum gap."""
GROW_LIMIT_CURV_NCIRCSEG = _vsp_g.GROW_LIMIT_CURV_NCIRCSEG
r""" Maximum growth limit from number of segments to define a circle."""
GROW_LIMIT_SOURCES = _vsp_g.GROW_LIMIT_SOURCES
r""" Maximum growth limit from mesh sources."""
GROW_LIMIT_MIN_LEN_CONSTRAINT = _vsp_g.GROW_LIMIT_MIN_LEN_CONSTRAINT
r""" Maximum growth limit from minimum length constraint."""
GROW_LIMIT_MIN_LEN_CONSTRAINT_CURV_GAP = _vsp_g.GROW_LIMIT_MIN_LEN_CONSTRAINT_CURV_GAP
r""" Maximum growth limit from maximum gap constrained by minimum length."""
GROW_LIMIT_MIN_LEN_CONSTRAINT_CURV_NCIRCSEG = _vsp_g.GROW_LIMIT_MIN_LEN_CONSTRAINT_CURV_NCIRCSEG
r""" Maximum growth limit from number of segments to define a circle constrained by minimum length."""
GROW_LIMIT_MIN_LEN_CONSTRAINT_SOURCES = _vsp_g.GROW_LIMIT_MIN_LEN_CONSTRAINT_SOURCES
r""" Maximum growth limit from sources constrained by minimum length."""
NUM_MESH_REASON = _vsp_g.NUM_MESH_REASON
r""" Number of reasons that can set the mesh local minimum edge length."""
MIN_LEN_INCREMENT = _vsp_g.MIN_LEN_INCREMENT
r""" Reason increment when adding minimum length constraint."""
GROW_LIMIT_INCREMENT = _vsp_g.GROW_LIMIT_INCREMENT
r""" Reason increment when adding growth limit constraint."""
MIN_GROW_LIMIT = _vsp_g.MIN_GROW_LIMIT
r""" Reason marker for minimum reason to apply growth limit."""
TRI_MESH_TYPE = _vsp_g.TRI_MESH_TYPE
r""" Triangle mesh"""
QUAD_MESH_TYPE = _vsp_g.QUAD_MESH_TYPE
r""" Quadrilateral mesh"""
NGON_MESH_TYPE = _vsp_g.NGON_MESH_TYPE
r""" N-gon mesh"""
NUM_MESH_TYPE = _vsp_g.NUM_MESH_TYPE
r""" Number of mesh types"""
EXTENT_FORWARD_INF = _vsp_g.EXTENT_FORWARD_INF
r""" Forward beyond extent of model."""
EXTENT_REVERSE_INF = _vsp_g.EXTENT_REVERSE_INF
r""" Reverse beyond extent of model."""
EXTENT_FORWARD_FINITE = _vsp_g.EXTENT_FORWARD_FINITE
r""" Forward displacement."""
EXTENT_REVERSE_FINITE = _vsp_g.EXTENT_REVERSE_FINITE
r""" Reverse displacement."""
EXTENT_SLIDER_FULL = _vsp_g.EXTENT_SLIDER_FULL
r""" Full range of slider motion."""
EXTENT_SLIDER_BEFORE = _vsp_g.EXTENT_SLIDER_BEFORE
r""" Slider motion from start to current position."""
EXTENT_SLIDER_AFTER = _vsp_g.EXTENT_SLIDER_AFTER
r""" Slider motion from current position to end."""
MOTION_NUM_EXTENT_TYPES = _vsp_g.MOTION_NUM_EXTENT_TYPES
r""" Number of swept volume extent types."""
ID_LENGTH_PRESET_GROUP = _vsp_g.ID_LENGTH_PRESET_GROUP
r""" ID for Var Preset Groups are length 5"""
ID_LENGTH_PRESET_SETTING = _vsp_g.ID_LENGTH_PRESET_SETTING
r""" ID for Var Preset Settings are length 6"""
ID_LENGTH_ATTR = _vsp_g.ID_LENGTH_ATTR
r""" ID for Attributes are length 8"""
ID_LENGTH_ATTRCOLL = _vsp_g.ID_LENGTH_ATTRCOLL
r""" ID for Attribute Collections are length 9"""
ID_LENGTH_PARMCONTAINER = _vsp_g.ID_LENGTH_PARMCONTAINER
r""" ID for Parm Containers are length 10"""
ID_LENGTH_PARM = _vsp_g.ID_LENGTH_PARM
r""" ID for Parms are length 11"""
PARM_DOUBLE_TYPE = _vsp_g.PARM_DOUBLE_TYPE
r""" Double Parm type (Parm)"""
PARM_INT_TYPE = _vsp_g.PARM_INT_TYPE
r""" Integer Parm type (IntParm)"""
PARM_BOOL_TYPE = _vsp_g.PARM_BOOL_TYPE
r""" Bool Parm type (BoolParm)"""
PARM_FRACTION_TYPE = _vsp_g.PARM_FRACTION_TYPE
r""" Fraction Parm type (FractionParm)"""
PARM_LIMITED_INT_TYPE = _vsp_g.PARM_LIMITED_INT_TYPE
r""" Limited integer Parm type (LimIntParm)"""
PARM_NOTEQ_TYPE = _vsp_g.PARM_NOTEQ_TYPE
r""" Not equal Parm type (NotEqParm)"""
PARM_POWER_INT_TYPE = _vsp_g.PARM_POWER_INT_TYPE
r""" Power integer Parm type (PowIntParm)"""
PATCH_NONE = _vsp_g.PATCH_NONE
r""" No patch"""
PATCH_POINT = _vsp_g.PATCH_POINT
r""" Point patch type"""
PATCH_LINE = _vsp_g.PATCH_LINE
r""" Line patch type"""
PATCH_COPY = _vsp_g.PATCH_COPY
r""" Copy patch type"""
PATCH_HALFWAY = _vsp_g.PATCH_HALFWAY
r""" Halfway patch type"""
PATCH_NUM_TYPES = _vsp_g.PATCH_NUM_TYPES
r""" Number of patch types"""
LINEAR = _vsp_g.LINEAR
r""" Linear curve type"""
PCHIP = _vsp_g.PCHIP
r""" Piecewise Cubic Hermite Interpolating Polynomial curve type"""
CEDIT = _vsp_g.CEDIT
r""" Cubic Bezier curve type"""
APPROX_CEDIT = _vsp_g.APPROX_CEDIT
r""" Approximate curve as Cubic Bezier"""
NUM_PCURV_TYPE = _vsp_g.NUM_PCURV_TYPE
r""" Number of curve types"""
PRES_UNIT_PSF = _vsp_g.PRES_UNIT_PSF
r""" Pounds per square foot"""
PRES_UNIT_PSI = _vsp_g.PRES_UNIT_PSI
r""" Pounds per square inch"""
PRES_UNIT_BA = _vsp_g.PRES_UNIT_BA
r""" Barye"""
PRES_UNIT_PA = _vsp_g.PRES_UNIT_PA
r""" Pascal"""
PRES_UNIT_KPA = _vsp_g.PRES_UNIT_KPA
r""" Kilopascal"""
PRES_UNIT_MPA = _vsp_g.PRES_UNIT_MPA
r""" Megapascal"""
PRES_UNIT_INCHHG = _vsp_g.PRES_UNIT_INCHHG
r""" Inch of mercury"""
PRES_UNIT_MMHG = _vsp_g.PRES_UNIT_MMHG
r""" Millimeter of mercury"""
PRES_UNIT_MMH20 = _vsp_g.PRES_UNIT_MMH20
r""" Millimeter of water"""
PRES_UNIT_MB = _vsp_g.PRES_UNIT_MB
r""" Millibar"""
PRES_UNIT_ATM = _vsp_g.PRES_UNIT_ATM
r""" Atmosphere"""
NUM_PRES_UNIT = _vsp_g.NUM_PRES_UNIT
r""" Number of pressure unit choices"""
NO_BOUNDARY = _vsp_g.NO_BOUNDARY
r""" No boundary"""
SET_BOUNDARY = _vsp_g.SET_BOUNDARY
r""" Set boundary"""
GEOM_BOUNDARY = _vsp_g.GEOM_BOUNDARY
r""" Geom boundary"""
NUM_PROJ_BNDY_OPTIONS = _vsp_g.NUM_PROJ_BNDY_OPTIONS
r""" Number of projected area boundary options"""
X_PROJ = _vsp_g.X_PROJ
r""" Project in X axis direction"""
Y_PROJ = _vsp_g.Y_PROJ
r""" Project in Y axis direction"""
Z_PROJ = _vsp_g.Z_PROJ
r""" Project in Z axis direction"""
GEOM_PROJ = _vsp_g.GEOM_PROJ
r""" Project toward a Geom"""
VEC_PROJ = _vsp_g.VEC_PROJ
r""" Project along a 3D vector"""
NUM_PROJ_DIR_OPTIONS = _vsp_g.NUM_PROJ_DIR_OPTIONS
r""" Number of Projected Area direction types"""
SET_TARGET = _vsp_g.SET_TARGET
r""" Set target type"""
GEOM_TARGET = _vsp_g.GEOM_TARGET
r""" Geom target type"""
MODE_TARGET = _vsp_g.MODE_TARGET
r""" Mode target type"""
Z_TARGET = _vsp_g.Z_TARGET
r""" Z plane target type"""
XYZ_TARGET = _vsp_g.XYZ_TARGET
r""" XYZ point target type"""
NUM_PROJ_TGT_OPTIONS = _vsp_g.NUM_PROJ_TGT_OPTIONS
r""" Number of Projected Area target types"""
PROP_AZI_UNIFORM = _vsp_g.PROP_AZI_UNIFORM
r""" Propeller blades are uniformly spaced"""
PROP_AZI_FREE = _vsp_g.PROP_AZI_FREE
r""" Propeller blades are free to spaced arbitrarially"""
PROP_AZI_BALANCED = _vsp_g.PROP_AZI_BALANCED
r""" Propeller blade balance is enforced"""
NUM_PROP_AZI = _vsp_g.NUM_PROP_AZI
r""" Number of propeller blade azimuth modes"""
PROP_BLADE_TRADITIONAL = _vsp_g.PROP_BLADE_TRADITIONAL
r""" Traditional straight blades"""
PROP_BLADE_NONTRADITIONAL = _vsp_g.PROP_BLADE_NONTRADITIONAL
r""" Non-traditional blades"""
NUM_PROP_BLADE_MODES = _vsp_g.NUM_PROP_BLADE_MODES
r""" Number of propeller blade modes"""
RPM_PROP_DRIVER = _vsp_g.RPM_PROP_DRIVER
r""" RPM driver"""
CT_PROP_DRIVER = _vsp_g.CT_PROP_DRIVER
r""" Thrust coefficient driver"""
CP_PROP_DRIVER = _vsp_g.CP_PROP_DRIVER
r""" Power coefficient driver"""
T_PROP_DRIVER = _vsp_g.T_PROP_DRIVER
r""" Thrust driver"""
ETA_PROP_DRIVER = _vsp_g.ETA_PROP_DRIVER
r""" Prop efficiency driver"""
J_PROP_DRIVER = _vsp_g.J_PROP_DRIVER
r""" Advance ratio driver"""
P_PROP_DRIVER = _vsp_g.P_PROP_DRIVER
r""" Power driver"""
CQ_PROP_DRIVER = _vsp_g.CQ_PROP_DRIVER
r""" Torque coefficient driver"""
Q_PROP_DRIVER = _vsp_g.Q_PROP_DRIVER
r""" Torque driver"""
NUM_PROP_DRIVER = _vsp_g.NUM_PROP_DRIVER
r""" Number of actuator disk drivers"""
PROP_BLADES = _vsp_g.PROP_BLADES
r""" Propeller Geom is defined by individual propeller blades"""
PROP_BOTH = _vsp_g.PROP_BOTH
r""" Propeller Geom is defined by blades and a disk together"""
PROP_DISK = _vsp_g.PROP_DISK
r""" Propeller Geom is defined by a flat circular disk"""
PROP_CHORD = _vsp_g.PROP_CHORD
r""" Chord parameterization"""
PROP_TWIST = _vsp_g.PROP_TWIST
r""" Twist parameterization"""
PROP_RAKE = _vsp_g.PROP_RAKE
r""" Rake parameterization"""
PROP_SKEW = _vsp_g.PROP_SKEW
r""" Skew parameterization"""
PROP_SWEEP = _vsp_g.PROP_SWEEP
r""" Sweep parameterization"""
PROP_THICK = _vsp_g.PROP_THICK
r""" Thickness parameterization"""
PROP_CLI = _vsp_g.PROP_CLI
r""" Induced lift coefficient parameterization"""
PROP_AXIAL = _vsp_g.PROP_AXIAL
r""" Axial parameterization"""
PROP_TANGENTIAL = _vsp_g.PROP_TANGENTIAL
r""" Tangential parameterization"""
NUM_PROP_PCURVE = _vsp_g.NUM_PROP_PCURVE
r""" Number of propeller blade curve parameterization options"""
REORDER_MOVE_UP = _vsp_g.REORDER_MOVE_UP
r""" Move up one position"""
REORDER_MOVE_DOWN = _vsp_g.REORDER_MOVE_DOWN
r""" Move down one position"""
REORDER_MOVE_TOP = _vsp_g.REORDER_MOVE_TOP
r""" Move to top"""
REORDER_MOVE_BOTTOM = _vsp_g.REORDER_MOVE_BOTTOM
r""" Move to bottom"""
NUM_REORDER_TYPES = _vsp_g.NUM_REORDER_TYPES
r""" Number reordering instructions"""
MANUAL_REF = _vsp_g.MANUAL_REF
r""" Manually specify the reference areas and lengths"""
COMPONENT_REF = _vsp_g.COMPONENT_REF
r""" Use a particular wing to calculate the reference area and lengths"""
NUM_REF_TYPES = _vsp_g.NUM_REF_TYPES
r""" Number of wing reference types"""
INVALID_TYPE = _vsp_g.INVALID_TYPE
r""" Invalid data type"""
BOOL_DATA = _vsp_g.BOOL_DATA
r""" Bool data type"""
INT_DATA = _vsp_g.INT_DATA
r""" Integer data type"""
DOUBLE_DATA = _vsp_g.DOUBLE_DATA
r""" Double data type"""
STRING_DATA = _vsp_g.STRING_DATA
r""" String data type"""
VEC3D_DATA = _vsp_g.VEC3D_DATA
r""" Vec3d data type"""
INT_MATRIX_DATA = _vsp_g.INT_MATRIX_DATA
r""" Int matrix data type"""
DOUBLE_MATRIX_DATA = _vsp_g.DOUBLE_MATRIX_DATA
r""" Double matrix data type"""
ATTR_COLLECTION_DATA = _vsp_g.ATTR_COLLECTION_DATA
r""" Attribute collection data type"""
PARM_REFERENCE_DATA = _vsp_g.PARM_REFERENCE_DATA
r""" Parm reference data type"""
MESH_INDEXED_TRI = _vsp_g.MESH_INDEXED_TRI
r""" Indexed triangulated mesh Geom type"""
MESH_SLICE_TRI = _vsp_g.MESH_SLICE_TRI
r""" Sliced Triangulated mesh Geom type"""
GEOM_XSECS = _vsp_g.GEOM_XSECS
r""" GeomXSec Geom type"""
MESH_INDEX_AND_SLICE_TRI = _vsp_g.MESH_INDEX_AND_SLICE_TRI
r""" Both indexed and sliced triangulated mesh Geom type"""
RHO_UNIT_SLUG_FT3 = _vsp_g.RHO_UNIT_SLUG_FT3
r""" Slug per cubic foot"""
RHO_UNIT_G_CM3 = _vsp_g.RHO_UNIT_G_CM3
r""" Gram per cubic centimeter"""
RHO_UNIT_KG_M3 = _vsp_g.RHO_UNIT_KG_M3
r""" Kilogram per cubic meter"""
RHO_UNIT_TONNE_MM3 = _vsp_g.RHO_UNIT_TONNE_MM3
r""" Tonne per cubic millimeter"""
RHO_UNIT_LBM_FT3 = _vsp_g.RHO_UNIT_LBM_FT3
r""" Pound-mass per cubic foot"""
RHO_UNIT_LBFSEC2_IN4 = _vsp_g.RHO_UNIT_LBFSEC2_IN4
r""" Pound-force-second squared per inch to the fourth"""
RHO_UNIT_LBM_IN3 = _vsp_g.RHO_UNIT_LBM_IN3
r""" Pound-mass per cubic inch"""
NUM_RHO_UNIT = _vsp_g.NUM_RHO_UNIT
r""" Number of density unit options"""
ROUTE_PT_COMP = _vsp_g.ROUTE_PT_COMP
r""" Routing point relative to parent body axes"""
ROUTE_PT_UV = _vsp_g.ROUTE_PT_UV
r""" Routing point relative to parent surface coordinate frame"""
ROUTE_PT_RST = _vsp_g.ROUTE_PT_RST
r""" Routing point relative to parent per-section volume coordinate frame"""
ROUTE_PT_LMN = _vsp_g.ROUTE_PT_LMN
r""" Routing point relative to parent uniform volume coordinate frame"""
ROUTE_PT_EtaMN = _vsp_g.ROUTE_PT_EtaMN
r""" Routing point relative to wing parent uniform eta volume coordinate frame"""
ROUTE_PT_NUM_TYPES = _vsp_g.ROUTE_PT_NUM_TYPES
r""" Number of routing point coordinate types"""
ROUTE_PT_DELTA_XYZ = _vsp_g.ROUTE_PT_DELTA_XYZ
r""" Routing point ofset in global axes"""
ROUTE_PT_DELTA_COMP = _vsp_g.ROUTE_PT_DELTA_COMP
r""" Routing point offset in parent body frame"""
ROUTE_PT_DELTA_UVN = _vsp_g.ROUTE_PT_DELTA_UVN
r""" Routing point offset in parent surface coordinate frame"""
ROUTE_PT_DELTA_NUM_TYPES = _vsp_g.ROUTE_PT_DELTA_NUM_TYPES
r""" Number of routing point offset coordinate types"""
SCALE_WIDTH = _vsp_g.SCALE_WIDTH
r""" Scale image to match desired width with 1:1 AR"""
SCALE_HEIGHT = _vsp_g.SCALE_HEIGHT
r""" Scale image to match desired height with 1:1 AR"""
SCALE_WIDTH_HEIGHT = _vsp_g.SCALE_WIDTH_HEIGHT
r""" Scale image to match desired width and height"""
SCALE_RESOLUTION = _vsp_g.SCALE_RESOLUTION
r""" Scale image to specified resolution"""
SCALE_WIDTH_AR = _vsp_g.SCALE_WIDTH_AR
r""" Scale image to match desired width with specified AR"""
SCALE_HEIGHT_AR = _vsp_g.SCALE_HEIGHT_AR
r""" Scale image to match desired height with specified AR"""
NUM_SCALE_TYPES = _vsp_g.NUM_SCALE_TYPES
r""" Number of ways to scale 3D background image."""
SET_NONE = _vsp_g.SET_NONE
r""" None set"""
SET_ALL = _vsp_g.SET_ALL
r""" All set"""
SET_SHOWN = _vsp_g.SET_SHOWN
r""" Shown set"""
SET_NOT_SHOWN = _vsp_g.SET_NOT_SHOWN
r""" Not shown set"""
SET_FIRST_USER = _vsp_g.SET_FIRST_USER
r""" First user-defined set"""
MIN_NUM_USER = _vsp_g.MIN_NUM_USER
r""" Minimum number of user sets"""
MAX_NUM_SETS = _vsp_g.MAX_NUM_SETS
r""" Maximum possible number of sets"""
STACK_PRESET_DEFAULT = _vsp_g.STACK_PRESET_DEFAULT
r""" Standard init type"""
STACK_PRESET_CYLINDER_ENDPTS = _vsp_g.STACK_PRESET_CYLINDER_ENDPTS
r""" Cylinder with points as first/last XSec"""
STACK_PRESET_CYLINDER_ENDCAPS = _vsp_g.STACK_PRESET_CYLINDER_ENDCAPS
r""" Cylinder with end caps instead of points"""
STACK_PRESET_FLOWTHRU_OUTLIP_ORIG = _vsp_g.STACK_PRESET_FLOWTHRU_OUTLIP_ORIG
r""" Flowthru nacelle starting/ending with outlet lip"""
STACK_PRESET_FLOWTHRU_INLIP_ORIG = _vsp_g.STACK_PRESET_FLOWTHRU_INLIP_ORIG
r""" Flowthru nacelle starting/ending with inlet lip"""
STACK_PRESET_FLOWTHRU_MID_ORIG = _vsp_g.STACK_PRESET_FLOWTHRU_MID_ORIG
r""" Flowthru nacelle starting/ending with outlet face"""
STACK_PRESET_BOTHFACEFACE = _vsp_g.STACK_PRESET_BOTHFACEFACE
r""" Nacelle from the inlet face around the outside to the outlet face"""
STACK_PRESET_BOTHLIPFACE = _vsp_g.STACK_PRESET_BOTHLIPFACE
r""" Nacelle from the inlet lip around the outside to the outlet face"""
STACK_PRESET_BOTHFACELIP = _vsp_g.STACK_PRESET_BOTHFACELIP
r""" Nacelle from the inlet face around the outside to the outlet lip"""
STACK_PRESET_BOTHLIPLIP = _vsp_g.STACK_PRESET_BOTHLIPLIP
r""" Nacelle from the inlet lip around the outside to the outlet lip"""
STACK_PRESET_OUTFACE = _vsp_g.STACK_PRESET_OUTFACE
r""" Nacelle with no inlet, around the outside to the outlet face"""
STACK_PRESET_OUTLIP = _vsp_g.STACK_PRESET_OUTLIP
r""" Nacelle with no inlet, around the outside to the outlet lip"""
STACK_PRESET_INFACE = _vsp_g.STACK_PRESET_INFACE
r""" Nacelle from the inlet face, then closed out with no outlet"""
STACK_PRESET_INLIP = _vsp_g.STACK_PRESET_INLIP
r""" Nacelle from the inlet lip, then closed out with no outlet"""
STACK_PRESET_FLOWPATH_BOTH = _vsp_g.STACK_PRESET_FLOWPATH_BOTH
r""" Nacelle flowpath only, from inlet to outlet"""
STACK_PRESET_FLOWPATH_IN = _vsp_g.STACK_PRESET_FLOWPATH_IN
r""" Nacelle flowpath only, inlet lip to face"""
STACK_PRESET_FLOWPATH_OUT = _vsp_g.STACK_PRESET_FLOWPATH_OUT
r""" Nacelle flowpath only, outlet face to lip"""
STEP_SHELL = _vsp_g.STEP_SHELL
r""" Manifold shell surface STEP file representation"""
STEP_BREP = _vsp_g.STEP_BREP
r""" Manifold solid BREP STEP file representation"""
SS_INC_TREAT_AS_PARENT = _vsp_g.SS_INC_TREAT_AS_PARENT
r""" Treat the sub-surface the same as the parent"""
SS_INC_SEPARATE_TREATMENT = _vsp_g.SS_INC_SEPARATE_TREATMENT
r""" Treat the sub-surface separately from the parent"""
SS_INC_ZERO_DRAG = _vsp_g.SS_INC_ZERO_DRAG
r""" No drag contribution for the sub-surface"""
INSIDE = _vsp_g.INSIDE
r""" The interior of the sub-surface is its surface"""
OUTSIDE = _vsp_g.OUTSIDE
r""" The exterior of the sub-surface is its surface"""
NONE = _vsp_g.NONE
r""" No part of the parent surface belongs to the sub-surface"""
CONST_U = _vsp_g.CONST_U
r""" Constant U sub-surface"""
CONST_W = _vsp_g.CONST_W
r""" Constant W sub-surface"""
SS_LINE = _vsp_g.SS_LINE
r""" Line sub-surface type"""
SS_RECTANGLE = _vsp_g.SS_RECTANGLE
r""" Rectangle sub-surface type"""
SS_ELLIPSE = _vsp_g.SS_ELLIPSE
r""" Ellipse sub-surface type"""
SS_CONTROL = _vsp_g.SS_CONTROL
r""" Control sub-surface type"""
SS_LINE_ARRAY = _vsp_g.SS_LINE_ARRAY
r""" Line array sub-surface type"""
SS_FINITE_LINE = _vsp_g.SS_FINITE_LINE
r""" Finite line sub-surface type"""
SS_XSEC_CURVE = _vsp_g.SS_XSEC_CURVE
r""" XSecCurve based sub-surface type"""
SS_INTERSECT = _vsp_g.SS_INTERSECT
r""" Intersection derived sub-surface type"""
SS_NUM_TYPES = _vsp_g.SS_NUM_TYPES
r""" Number of sub-surface types"""
SYM_XY = _vsp_g.SYM_XY
r""" XY planar symmetry."""
SYM_XZ = _vsp_g.SYM_XZ
r""" XZ planar symmetry."""
SYM_YZ = _vsp_g.SYM_YZ
r""" YZ planar symmetry."""
SYM_ROT_X = _vsp_g.SYM_ROT_X
r""" X rotational symmetry."""
SYM_ROT_Y = _vsp_g.SYM_ROT_Y
r""" Y rotational symmetry."""
SYM_ROT_Z = _vsp_g.SYM_ROT_Z
r""" Z rotational symmetry."""
SYM_PLANAR_TYPES = _vsp_g.SYM_PLANAR_TYPES
r""" Number of planar symmetry types."""
SYM_NUM_TYPES = _vsp_g.SYM_NUM_TYPES
r""" Number of symmetry types."""
SYM_NONE = _vsp_g.SYM_NONE
r""" No cross section symmetry."""
SYM_RL = _vsp_g.SYM_RL
r""" Right/left cross section symmetry."""
SYM_TB = _vsp_g.SYM_TB
r""" Top/bottom cross section symmetry."""
SYM_ALL = _vsp_g.SYM_ALL
r""" All cross section symmetry."""
TEMP_UNIT_K = _vsp_g.TEMP_UNIT_K
r""" Kelvin"""
TEMP_UNIT_C = _vsp_g.TEMP_UNIT_C
r""" Celsius"""
TEMP_UNIT_F = _vsp_g.TEMP_UNIT_F
r""" Fahrenheit"""
TEMP_UNIT_R = _vsp_g.TEMP_UNIT_R
r""" Rankine"""
NUM_TEMP_UNIT = _vsp_g.NUM_TEMP_UNIT
r""" Number of temperature unit choices"""
TIRE_NOMINAL_CLEARANCE = _vsp_g.TIRE_NOMINAL_CLEARANCE
r""" Tire nominal shape"""
TIRE_GROWTH_CLEARANCE = _vsp_g.TIRE_GROWTH_CLEARANCE
r""" Tire growth (spinning) clearance"""
TIRE_CLEARANCE = _vsp_g.TIRE_CLEARANCE
r""" TRA clearance envelope"""
NUM_TIRE_CLEARANCE_MODES = _vsp_g.NUM_TIRE_CLEARANCE_MODES
r""" Number of tire clearance modes"""
TIRE_STATIC_LODED_CONTACT = _vsp_g.TIRE_STATIC_LODED_CONTACT
r""" Tire static loaded radius"""
TIRE_NOMINAL_CONTACT = _vsp_g.TIRE_NOMINAL_CONTACT
r""" Tire nominal radius"""
TIRE_GROWTH_CONTACT = _vsp_g.TIRE_GROWTH_CONTACT
r""" Tire growth (spinning) radius"""
TIRE_FLAT_CONTACT = _vsp_g.TIRE_FLAT_CONTACT
r""" Tire flat tire radius"""
NUM_TIRE_CONTACT_MODES = _vsp_g.NUM_TIRE_CONTACT_MODES
r""" Number of tire radius modes"""
TIRE_DIM_IN = _vsp_g.TIRE_DIM_IN
r""" Tire dimensions in inches"""
TIRE_DIM_MODEL = _vsp_g.TIRE_DIM_MODEL
r""" Tire dimensions in model units"""
TIRE_DIM_FRAC = _vsp_g.TIRE_DIM_FRAC
r""" Tire dimensions as fractions"""
NUM_TIRE_DIM_MODES = _vsp_g.NUM_TIRE_DIM_MODES
r""" Number of tire dimension choices"""
TIRE_TRA = _vsp_g.TIRE_TRA
r""" Full TRA model"""
TIRE_FAIR_FLANGE = _vsp_g.TIRE_FAIR_FLANGE
r""" TRA with faired flange / flank"""
TIRE_FAIR_WHEEL = _vsp_g.TIRE_FAIR_WHEEL
r""" TRA with faired wheel"""
TIRE_BALLOON = _vsp_g.TIRE_BALLOON
r""" Balloon tire"""
TIRE_BALLOON_WHEEL = _vsp_g.TIRE_BALLOON_WHEEL
r""" Balloon tire with wheel"""
TIRE_BALLOON_FAIR_WHEEL = _vsp_g.TIRE_BALLOON_FAIR_WHEEL
r""" Balloon tire with faired wheel"""
NUM_TIRE_MODES = _vsp_g.NUM_TIRE_MODES
r""" Number of tire choices"""
V_UNIT_FT_S = _vsp_g.V_UNIT_FT_S
r""" Feet per second"""
V_UNIT_M_S = _vsp_g.V_UNIT_M_S
r""" Meter per second"""
V_UNIT_MPH = _vsp_g.V_UNIT_MPH
r""" Mile per hour"""
V_UNIT_KM_HR = _vsp_g.V_UNIT_KM_HR
r""" Kilometer per hour"""
V_UNIT_KEAS = _vsp_g.V_UNIT_KEAS
r""" Knots equivalent airspeed"""
V_UNIT_KTAS = _vsp_g.V_UNIT_KTAS
r""" Knots true airspeed"""
V_UNIT_MACH = _vsp_g.V_UNIT_MACH
r""" Mach"""
VIEW_1 = _vsp_g.VIEW_1
r""" One 2D view"""
VIEW_2HOR = _vsp_g.VIEW_2HOR
r""" Two horizontal 2D views"""
VIEW_2VER = _vsp_g.VIEW_2VER
r""" Two vertical 2D views"""
VIEW_4 = _vsp_g.VIEW_4
r""" Four 2D views"""
ROT_0 = _vsp_g.ROT_0
r""" No rotation"""
ROT_90 = _vsp_g.ROT_90
r""" 90 degree rotation"""
ROT_180 = _vsp_g.ROT_180
r""" 180 degree rotation"""
ROT_270 = _vsp_g.ROT_270
r""" 270 degree rotation"""
VIEW_LEFT = _vsp_g.VIEW_LEFT
r""" Left 2D view type"""
VIEW_RIGHT = _vsp_g.VIEW_RIGHT
r""" Right 2D view type"""
VIEW_TOP = _vsp_g.VIEW_TOP
r""" Top 2D view type"""
VIEW_BOTTOM = _vsp_g.VIEW_BOTTOM
r""" Bottom 2D view type"""
VIEW_FRONT = _vsp_g.VIEW_FRONT
r""" Front 2D view type"""
VIEW_REAR = _vsp_g.VIEW_REAR
r""" Rear 2D view type"""
VIEW_NONE = _vsp_g.VIEW_NONE
r""" No 2D view type"""
VIEW_NUM_TYPES = _vsp_g.VIEW_NUM_TYPES
r""" Number of 2D view types"""
NOISE_FLYBY = _vsp_g.NOISE_FLYBY
r""" Set up fly by noise analysis in VSPAERO for PSU-WOPWOP"""
NOISE_FOOTPRINT = _vsp_g.NOISE_FOOTPRINT
r""" Set up footprint noise analysis in VSPAERO for PSU-WOPWOP"""
NOISE_STEADY = _vsp_g.NOISE_STEADY
r""" Set up steady state noise analysis in VSPAERO for PSU-WOPWOP"""
NOISE_SI = _vsp_g.NOISE_SI
r""" Assume geometry and VSPAERO inputs in SI (m N kg s) for PSU-WOPWOP"""
NOISE_ENGLISH = _vsp_g.NOISE_ENGLISH
r""" Assume geometry and VSPAERO inputs in english (ft lbf slug s) units, will convert to SI (m N kg s) for PSU-WOPWOP"""
VSPAERO_PROP_STATIC = _vsp_g.VSPAERO_PROP_STATIC
r""" Model propellers as static, non-rotating blades -- i.e. used as a wing."""
VSPAERO_PROP_UNSTEADY = _vsp_g.VSPAERO_PROP_UNSTEADY
r""" Model propellers as unsteady rotating blades"""
VSPAERO_PROP_PSEUDO_STEADY = _vsp_g.VSPAERO_PROP_PSEUDO_STEADY
r""" Model propellers with pseudo steady model"""
VSPAERO_PROP_NUM_MODES = _vsp_g.VSPAERO_PROP_NUM_MODES
r""" Number of ways to model propeller blades in VSPAERO"""
STABILITY_OFF = _vsp_g.STABILITY_OFF
r""" No stability analysis (off)"""
STABILITY_DEFAULT = _vsp_g.STABILITY_DEFAULT
r""" Steady 6DOF stability analysis"""
STABILITY_P_ANALYSIS = _vsp_g.STABILITY_P_ANALYSIS
r""" Unsteady roll stability analysis"""
STABILITY_Q_ANALYSIS = _vsp_g.STABILITY_Q_ANALYSIS
r""" Unsteady pitch stability analysis"""
STABILITY_R_ANALYSIS = _vsp_g.STABILITY_R_ANALYSIS
r""" Unsteady yaw stability analysis"""
STABILITY_PITCH = _vsp_g.STABILITY_PITCH
r""" Simplified pitch stability analysis"""
STABILITY_ADJOINT = _vsp_g.STABILITY_ADJOINT
r""" Steady 6DOF stability analysis using adjoint"""
STABILITY_NUM_TYPES = _vsp_g.STABILITY_NUM_TYPES
r""" Number of stability analysis types"""
STALL_OFF = _vsp_g.STALL_OFF
r""" Stall modeling off"""
STALL_ON = _vsp_g.STALL_ON
r""" Stall modeling on"""
CFD_NORMAL = _vsp_g.CFD_NORMAL
r""" Normal CFD Mesh surface"""
CFD_NEGATIVE = _vsp_g.CFD_NEGATIVE
r""" Negative volume CFD Mesh surface"""
CFD_TRANSPARENT = _vsp_g.CFD_TRANSPARENT
r""" Transparent CFD Mesh surface"""
CFD_STRUCTURE = _vsp_g.CFD_STRUCTURE
r""" FEA structure CFD Mesh surface"""
CFD_STIFFENER = _vsp_g.CFD_STIFFENER
r""" FEA stiffener CFD Mesh surface"""
CFD_MEASURE_DUCT = _vsp_g.CFD_MEASURE_DUCT
r""" Measure duct cross sectional area surface"""
CFD_NUM_TYPES = _vsp_g.CFD_NUM_TYPES
r""" Number of CFD Mesh surface types"""
NORMAL_SURF = _vsp_g.NORMAL_SURF
r""" Normal VSP surface"""
WING_SURF = _vsp_g.WING_SURF
r""" Wing VSP surface"""
DISK_SURF = _vsp_g.DISK_SURF
r""" Disk VSP surface"""
NUM_SURF_TYPES = _vsp_g.NUM_SURF_TYPES
r""" Number of VSP surface types"""
WHEEL_TIRE_1LG = _vsp_g.WHEEL_TIRE_1LG
r""" Large tire debris"""
WHEEL_TIRE_1SM = _vsp_g.WHEEL_TIRE_1SM
r""" Small tire debris"""
WHEEL_TIRE_2 = _vsp_g.WHEEL_TIRE_2
r""" Wheel flange debris"""
WHEEL_TIRE_3E = _vsp_g.WHEEL_TIRE_3E
r""" Flailing tire strip extended"""
WHEEL_TIRE_3R = _vsp_g.WHEEL_TIRE_3R
r""" Flailing tire strip retracted"""
WHEEL_TIRE_4 = _vsp_g.WHEEL_TIRE_4
r""" Tire burst pressure (Not implemented)"""
NUM_WHEEL_TIRE_FAILURE_MODES = _vsp_g.NUM_WHEEL_TIRE_FAILURE_MODES
r""" Number of wheel and tire failure modes"""
W_RIGHT_0 = _vsp_g.W_RIGHT_0
r""" Chevron start/ends at right (W = 0) of cross section"""
W_BOTTOM = _vsp_g.W_BOTTOM
r""" Chevron start/ends at bottom of cross section"""
W_LEFT = _vsp_g.W_LEFT
r""" Chevron start/ends at left of cross section"""
W_TOP = _vsp_g.W_TOP
r""" Chevron start/ends at top of cross section"""
W_RIGHT_1 = _vsp_g.W_RIGHT_1
r""" Chevron start/ends at right (W = 1) of cross section"""
W_FREE = _vsp_g.W_FREE
r""" Chevron start/ends at user specified point on cross section"""
BLEND_FREE = _vsp_g.BLEND_FREE
r""" Free blending"""
BLEND_ANGLES = _vsp_g.BLEND_ANGLES
r""" Blend based on angles (sweep & dihedral)"""
BLEND_MATCH_IN_LE_TRAP = _vsp_g.BLEND_MATCH_IN_LE_TRAP
r""" Match inboard leading edge trapezoid"""
BLEND_MATCH_IN_TE_TRAP = _vsp_g.BLEND_MATCH_IN_TE_TRAP
r""" Match inboard trailing edge trapezoid"""
BLEND_MATCH_OUT_LE_TRAP = _vsp_g.BLEND_MATCH_OUT_LE_TRAP
r""" Match outboard leading edge trapezoid"""
BLEND_MATCH_OUT_TE_TRAP = _vsp_g.BLEND_MATCH_OUT_TE_TRAP
r""" Match outboard trailing edge trapezoid"""
BLEND_MATCH_IN_ANGLES = _vsp_g.BLEND_MATCH_IN_ANGLES
r""" Match inboard angles"""
BLEND_MATCH_LE_ANGLES = _vsp_g.BLEND_MATCH_LE_ANGLES
r""" Match leading edge angles"""
BLEND_NUM_TYPES = _vsp_g.BLEND_NUM_TYPES
r""" Number of blending types"""
AR_WSECT_DRIVER = _vsp_g.AR_WSECT_DRIVER
r""" Aspect ratio driver"""
SPAN_WSECT_DRIVER = _vsp_g.SPAN_WSECT_DRIVER
r""" Span driver"""
AREA_WSECT_DRIVER = _vsp_g.AREA_WSECT_DRIVER
r""" Area driver"""
TAPER_WSECT_DRIVER = _vsp_g.TAPER_WSECT_DRIVER
r""" Taper driver"""
AVEC_WSECT_DRIVER = _vsp_g.AVEC_WSECT_DRIVER
r""" Average chord driver"""
ROOTC_WSECT_DRIVER = _vsp_g.ROOTC_WSECT_DRIVER
r""" Root chord driver"""
TIPC_WSECT_DRIVER = _vsp_g.TIPC_WSECT_DRIVER
r""" Tip chord driver"""
SECSWEEP_WSECT_DRIVER = _vsp_g.SECSWEEP_WSECT_DRIVER
r""" Section sweep driver"""
NUM_WSECT_DRIVER = _vsp_g.NUM_WSECT_DRIVER
r""" Number of wing section drivers"""
SWEEP_WSECT_DRIVER = _vsp_g.SWEEP_WSECT_DRIVER

SWEEPLOC_WSECT_DRIVER = _vsp_g.SWEEPLOC_WSECT_DRIVER

SECSWEEPLOC_WSECT_DRIVER = _vsp_g.SECSWEEPLOC_WSECT_DRIVER

XDDM_VAR = _vsp_g.XDDM_VAR
r""" Variable XDDM type"""
XDDM_CONST = _vsp_g.XDDM_CONST
r""" Constant XDDM type"""
CLOSE_NONE = _vsp_g.CLOSE_NONE
r""" No closure"""
CLOSE_SKEWLOW = _vsp_g.CLOSE_SKEWLOW
r""" Skew lower closure"""
CLOSE_SKEWUP = _vsp_g.CLOSE_SKEWUP
r""" Skew upper closure"""
CLOSE_SKEWBOTH = _vsp_g.CLOSE_SKEWBOTH
r""" Skew both closure"""
CLOSE_EXTRAP = _vsp_g.CLOSE_EXTRAP
r""" Extrapolate closure"""
CLOSE_NUM_TYPES = _vsp_g.CLOSE_NUM_TYPES
r""" Number of XSec closure types"""
XS_UNDEFINED = _vsp_g.XS_UNDEFINED

XS_POINT = _vsp_g.XS_POINT
r""" Point XSec"""
XS_CIRCLE = _vsp_g.XS_CIRCLE
r""" Circle XSec"""
XS_ELLIPSE = _vsp_g.XS_ELLIPSE
r""" Ellipse XSec"""
XS_SUPER_ELLIPSE = _vsp_g.XS_SUPER_ELLIPSE
r""" Super ellipse XSec"""
XS_ROUNDED_RECTANGLE = _vsp_g.XS_ROUNDED_RECTANGLE
r""" Rounded rectangle XSec"""
XS_GENERAL_FUSE = _vsp_g.XS_GENERAL_FUSE
r""" General fuselage XSec"""
XS_FILE_FUSE = _vsp_g.XS_FILE_FUSE
r""" Fuselage file XSec"""
XS_FOUR_SERIES = _vsp_g.XS_FOUR_SERIES
r""" Four series XSec"""
XS_SIX_SERIES = _vsp_g.XS_SIX_SERIES
r""" Six series XSec"""
XS_BICONVEX = _vsp_g.XS_BICONVEX
r""" Biconvex XSec"""
XS_WEDGE = _vsp_g.XS_WEDGE
r""" Wedge XSec"""
XS_EDIT_CURVE = _vsp_g.XS_EDIT_CURVE
r""" Generic Edit Curve XSec"""
XS_FILE_AIRFOIL = _vsp_g.XS_FILE_AIRFOIL
r""" Airfoil file XSec"""
XS_CST_AIRFOIL = _vsp_g.XS_CST_AIRFOIL
r""" CST airfoil XSec"""
XS_VKT_AIRFOIL = _vsp_g.XS_VKT_AIRFOIL
r""" VKT airfoil XSec"""
XS_FOUR_DIGIT_MOD = _vsp_g.XS_FOUR_DIGIT_MOD
r""" Four digit modified XSec"""
XS_FIVE_DIGIT = _vsp_g.XS_FIVE_DIGIT
r""" Five digit XSec"""
XS_FIVE_DIGIT_MOD = _vsp_g.XS_FIVE_DIGIT_MOD
r""" Five digit modified XSec"""
XS_ONE_SIX_SERIES = _vsp_g.XS_ONE_SIX_SERIES
r""" One six series XSec"""
XS_AC25_773 = _vsp_g.XS_AC25_773
r""" FAA AC 25.773 pilot view requirement"""
XS_NUM_TYPES = _vsp_g.XS_NUM_TYPES
r""" Number of XSec types"""
WIDTH_XSEC_DRIVER = _vsp_g.WIDTH_XSEC_DRIVER
r""" Width driver"""
AREA_XSEC_DRIVER = _vsp_g.AREA_XSEC_DRIVER
r""" Area driver"""
HEIGHT_XSEC_DRIVER = _vsp_g.HEIGHT_XSEC_DRIVER
r""" Height driver"""
HWRATIO_XSEC_DRIVER = _vsp_g.HWRATIO_XSEC_DRIVER
r""" Height/width ratio driver"""
NUM_XSEC_DRIVER = _vsp_g.NUM_XSEC_DRIVER
r""" Number of XSec drivers"""
CIRCLE_NUM_XSEC_DRIVER = _vsp_g.CIRCLE_NUM_XSEC_DRIVER

FLAP_NONE = _vsp_g.FLAP_NONE
r""" No flap"""
FLAP_PLAIN = _vsp_g.FLAP_PLAIN
r""" Plain flap"""
FLAP_NUM_TYPES = _vsp_g.FLAP_NUM_TYPES
r""" Number of flap types"""
XSEC_BOTH_SIDES = _vsp_g.XSEC_BOTH_SIDES
r""" Both sides"""
XSEC_LEFT_SIDE = _vsp_g.XSEC_LEFT_SIDE
r""" Left side"""
XSEC_RIGHT_SIDE = _vsp_g.XSEC_RIGHT_SIDE
r""" Right side"""
TRIM_NONE = _vsp_g.TRIM_NONE
r""" No trimming"""
TRIM_X = _vsp_g.TRIM_X
r""" Trim XSec by X"""
TRIM_THICK = _vsp_g.TRIM_THICK
r""" Trim XSec by thickness"""
TRIM_NUM_TYPES = _vsp_g.TRIM_NUM_TYPES
r""" Number of trimming types"""
XSEC_FUSE = _vsp_g.XSEC_FUSE
r""" Fuselage XSec Geom"""
XSEC_STACK = _vsp_g.XSEC_STACK
r""" Stack XSec Geom"""
XSEC_WING = _vsp_g.XSEC_WING
r""" Wing XSec Geom"""
XSEC_CUSTOM = _vsp_g.XSEC_CUSTOM
r""" Custom XSec Geom"""
XSEC_PROP = _vsp_g.XSEC_PROP
r""" Propeller XSec Geom"""
XSEC_NUM_TYPES = _vsp_g.XSEC_NUM_TYPES
r""" Number of XSec types"""
XS_SHIFT_LE = _vsp_g.XS_SHIFT_LE
r""" Shift leading edge"""
XS_SHIFT_MID = _vsp_g.XS_SHIFT_MID

XS_SHIFT_TE = _vsp_g.XS_SHIFT_TE

class ErrorObj(object):
    r"""Proxy of C++ vsp::ErrorObj class."""

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

    def __init__(self, *args):
        r"""
        __init__(ErrorObj self) -> ErrorObj
        __init__(ErrorObj self, vsp::ERROR_CODE err_code, string const & err_str) -> ErrorObj
        __init__(ErrorObj self, ErrorObj _from) -> ErrorObj
        """
        _vsp_g.ErrorObj_swiginit(self, _vsp_g.new_ErrorObj(*args))
    __swig_destroy__ = _vsp_g.delete_ErrorObj

    def GetErrorCode(self):
        r"""GetErrorCode(ErrorObj self) -> vsp::ERROR_CODE"""
        return _vsp_g.ErrorObj_GetErrorCode(self)

    def GetErrorString(self):
        r"""GetErrorString(ErrorObj self) -> string"""
        return _vsp_g.ErrorObj_GetErrorString(self)
    m_ErrorCode = property(_vsp_g.ErrorObj_m_ErrorCode_get, _vsp_g.ErrorObj_m_ErrorCode_set, doc=r"""m_ErrorCode : vsp::ERROR_CODE""")
    m_ErrorString = property(_vsp_g.ErrorObj_m_ErrorString_get, _vsp_g.ErrorObj_m_ErrorString_set, doc=r"""m_ErrorString : string""")

    def NoError(self):
        r"""NoError(ErrorObj self)"""
        return _vsp_g.ErrorObj_NoError(self)

# Register ErrorObj in _vsp_g:
_vsp_g.ErrorObj_swigregister(ErrorObj)

class ErrorMgrSingleton(object):
    r"""Proxy of C++ vsp::ErrorMgrSingleton class."""

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

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

    def GetErrorLastCallFlag(self):
        r"""GetErrorLastCallFlag(ErrorMgrSingleton self) -> bool"""
        return _vsp_g.ErrorMgrSingleton_GetErrorLastCallFlag(self)

    def GetNumTotalErrors(self):
        r"""GetNumTotalErrors(ErrorMgrSingleton self) -> int"""
        return _vsp_g.ErrorMgrSingleton_GetNumTotalErrors(self)

    def PopLastError(self):
        r"""PopLastError(ErrorMgrSingleton self) -> ErrorObj"""
        return _vsp_g.ErrorMgrSingleton_PopLastError(self)

    def GetLastError(self):
        r"""GetLastError(ErrorMgrSingleton self) -> ErrorObj"""
        return _vsp_g.ErrorMgrSingleton_GetLastError(self)

    def PopErrorAndPrint(self, stream):
        r"""PopErrorAndPrint(ErrorMgrSingleton self, FILE * stream) -> bool"""
        return _vsp_g.ErrorMgrSingleton_PopErrorAndPrint(self, stream)

    def SilenceErrors(self):
        r"""SilenceErrors(ErrorMgrSingleton self)"""
        return _vsp_g.ErrorMgrSingleton_SilenceErrors(self)

    def PrintOnErrors(self):
        r"""PrintOnErrors(ErrorMgrSingleton self)"""
        return _vsp_g.ErrorMgrSingleton_PrintOnErrors(self)

    def AddError(self, code, desc):
        r"""AddError(ErrorMgrSingleton self, vsp::ERROR_CODE code, string const & desc)"""
        return _vsp_g.ErrorMgrSingleton_AddError(self, code, desc)

    def NoError(self):
        r"""NoError(ErrorMgrSingleton self)"""
        return _vsp_g.ErrorMgrSingleton_NoError(self)

    def MessageCallback(self, _from, data):
        r"""MessageCallback(ErrorMgrSingleton self, MessageBase const * _from, MessageData const & data)"""
        return _vsp_g.ErrorMgrSingleton_MessageCallback(self, _from, data)

    @staticmethod
    def getInstance():
        r"""getInstance() -> ErrorMgrSingleton"""
        return _vsp_g.ErrorMgrSingleton_getInstance()

# Register ErrorMgrSingleton in _vsp_g:
_vsp_g.ErrorMgrSingleton_swigregister(ErrorMgrSingleton)

def ErrorMgrSingleton_getInstance():
    r"""ErrorMgrSingleton_getInstance() -> ErrorMgrSingleton"""
    return _vsp_g.ErrorMgrSingleton_getInstance()


def VSPCheckSetup():
    r"""VSPCheckSetup()"""
    return _vsp_g.VSPCheckSetup()

def VSPRenew():
    r"""VSPRenew()"""
    return _vsp_g.VSPRenew()

def Update(update_managers=True):
    r"""Update(bool update_managers=True)"""
    return _vsp_g.Update(update_managers)

def VSPExit(error_code):
    r"""VSPExit(int error_code)"""
    return _vsp_g.VSPExit(error_code)

def VSPCrash(crash_type):
    r"""VSPCrash(int crash_type)"""
    return _vsp_g.VSPCrash(crash_type)

def GetAndResetUpdateCount():
    r"""GetAndResetUpdateCount() -> int"""
    return _vsp_g.GetAndResetUpdateCount()

def GetVSPVersion():
    r"""GetVSPVersion() -> std::string"""
    return _vsp_g.GetVSPVersion()

def GetVSPVersionMajor():
    r"""GetVSPVersionMajor() -> int"""
    return _vsp_g.GetVSPVersionMajor()

def GetVSPVersionMinor():
    r"""GetVSPVersionMinor() -> int"""
    return _vsp_g.GetVSPVersionMinor()

def GetVSPVersionChange():
    r"""GetVSPVersionChange() -> int"""
    return _vsp_g.GetVSPVersionChange()

def GetVSPExePath():
    r"""GetVSPExePath() -> std::string"""
    return _vsp_g.GetVSPExePath()

def SetVSPAEROPath(path):
    r"""SetVSPAEROPath(std::string const & path) -> bool"""
    return _vsp_g.SetVSPAEROPath(path)

def GetVSPAEROPath():
    r"""GetVSPAEROPath() -> std::string"""
    return _vsp_g.GetVSPAEROPath()

def CheckForVSPAERO(path):
    r"""CheckForVSPAERO(std::string const & path) -> bool"""
    return _vsp_g.CheckForVSPAERO(path)

def SetVSPHelpPath(path):
    r"""SetVSPHelpPath(std::string const & path) -> bool"""
    return _vsp_g.SetVSPHelpPath(path)

def GetVSPHelpPath():
    r"""GetVSPHelpPath() -> std::string"""
    return _vsp_g.GetVSPHelpPath()

def CheckForVSPHelp(path):
    r"""CheckForVSPHelp(std::string const & path) -> bool"""
    return _vsp_g.CheckForVSPHelp(path)

def RegisterCFDMeshAnalyses():
    r"""RegisterCFDMeshAnalyses()"""
    return _vsp_g.RegisterCFDMeshAnalyses()

def LimitedIntersectSurfaces(geomvec, ptchains, uwchains):
    r"""LimitedIntersectSurfaces(StringVector geomvec, std::vector< std::vector< vec3d,std::allocator< vec3d > >,std::allocator< std::vector< vec3d,std::allocator< vec3d > > > > & ptchains, std::vector< std::vector< vec3d,std::allocator< vec3d > >,std::allocator< std::vector< vec3d,std::allocator< vec3d > > > > & uwchains)"""
    return _vsp_g.LimitedIntersectSurfaces(geomvec, ptchains, uwchains)

def ReadVSPFile(file_name):
    r"""ReadVSPFile(std::string const & file_name)"""
    return _vsp_g.ReadVSPFile(file_name)

def WriteVSPFile(*args):
    r"""WriteVSPFile(std::string const & file_name, int set=SET_ALL)"""
    return _vsp_g.WriteVSPFile(*args)

def SetVSP3FileName(file_name):
    r"""SetVSP3FileName(std::string const & file_name)"""
    return _vsp_g.SetVSP3FileName(file_name)

def GetVSPFileName():
    r"""GetVSPFileName() -> std::string"""
    return _vsp_g.GetVSPFileName()

def ClearVSPModel():
    r"""ClearVSPModel()"""
    return _vsp_g.ClearVSPModel()

def InsertVSPFile(file_name, parent_geom_id):
    r"""InsertVSPFile(std::string const & file_name, std::string const & parent_geom_id)"""
    return _vsp_g.InsertVSPFile(file_name, parent_geom_id)

def ExportFile(*args):
    r"""ExportFile(std::string const & file_name, int thick_set, int file_type, int subsFlag=1, int thin_set=SET_NONE, bool useMode=False, std::string const & modeID="") -> std::string"""
    return _vsp_g.ExportFile(*args)

def ImportFile(file_name, file_type, parent):
    r"""ImportFile(std::string const & file_name, int file_type, std::string const & parent) -> std::string"""
    return _vsp_g.ImportFile(file_name, file_type, parent)

def GetBEMPropID():
    r"""GetBEMPropID() -> std::string"""
    return _vsp_g.GetBEMPropID()

def SetBEMPropID(prop_id):
    r"""SetBEMPropID(std::string const & prop_id)"""
    return _vsp_g.SetBEMPropID(prop_id)

def ReadApplyDESFile(file_name):
    r"""ReadApplyDESFile(std::string const & file_name)"""
    return _vsp_g.ReadApplyDESFile(file_name)

def WriteDESFile(file_name):
    r"""WriteDESFile(std::string const & file_name)"""
    return _vsp_g.WriteDESFile(file_name)

def ReadApplyXDDMFile(file_name):
    r"""ReadApplyXDDMFile(std::string const & file_name)"""
    return _vsp_g.ReadApplyXDDMFile(file_name)

def WriteXDDMFile(file_name):
    r"""WriteXDDMFile(std::string const & file_name)"""
    return _vsp_g.WriteXDDMFile(file_name)

def GetNumDesignVars():
    r"""GetNumDesignVars() -> int"""
    return _vsp_g.GetNumDesignVars()

def AddDesignVar(parm_id, type):
    r"""AddDesignVar(std::string const & parm_id, int type)"""
    return _vsp_g.AddDesignVar(parm_id, type)

def DeleteAllDesignVars():
    r"""DeleteAllDesignVars()"""
    return _vsp_g.DeleteAllDesignVars()

def GetDesignVar(index):
    r"""GetDesignVar(int index) -> std::string"""
    return _vsp_g.GetDesignVar(index)

def GetDesignVarType(index):
    r"""GetDesignVarType(int index) -> int"""
    return _vsp_g.GetDesignVarType(index)

def GetComputationFileName(file_type):
    r"""GetComputationFileName(int file_type) -> std::string"""
    return _vsp_g.GetComputationFileName(file_type)

def SetComputationFileName(file_type, file_name):
    r"""SetComputationFileName(int file_type, std::string const & file_name)"""
    return _vsp_g.SetComputationFileName(file_type, file_name)

def ComputeMassProps(set, num_slices, idir):
    r"""ComputeMassProps(int set, int num_slices, int idir) -> std::string"""
    return _vsp_g.ComputeMassProps(set, num_slices, idir)

def ComputeCompGeom(set, half_mesh, file_export_types):
    r"""ComputeCompGeom(int set, bool half_mesh, int file_export_types) -> std::string"""
    return _vsp_g.ComputeCompGeom(set, half_mesh, file_export_types)

def ComputePlaneSlice(set, num_slices, norm, auto_bnd, start_bnd=0, end_bnd=0, measureduct=False):
    r"""ComputePlaneSlice(int set, int num_slices, vec3d norm, bool auto_bnd, double start_bnd=0, double end_bnd=0, bool measureduct=False) -> std::string"""
    return _vsp_g.ComputePlaneSlice(set, num_slices, norm, auto_bnd, start_bnd, end_bnd, measureduct)

def ComputeDegenGeom(set, file_export_types):
    r"""ComputeDegenGeom(int set, int file_export_types)"""
    return _vsp_g.ComputeDegenGeom(set, file_export_types)

def ComputeCFDMesh(set, degenset, file_export_types):
    r"""ComputeCFDMesh(int set, int degenset, int file_export_types)"""
    return _vsp_g.ComputeCFDMesh(set, degenset, file_export_types)

def GetCFDMeshVal(type):
    r"""GetCFDMeshVal(int type) -> double"""
    return _vsp_g.GetCFDMeshVal(type)

def SetCFDMeshVal(type, val):
    r"""SetCFDMeshVal(int type, double val)"""
    return _vsp_g.SetCFDMeshVal(type, val)

def GetCFDWakeFlag(geom_id):
    r"""GetCFDWakeFlag(std::string const & geom_id) -> bool"""
    return _vsp_g.GetCFDWakeFlag(geom_id)

def SetCFDWakeFlag(geom_id, flag):
    r"""SetCFDWakeFlag(std::string const & geom_id, bool flag)"""
    return _vsp_g.SetCFDWakeFlag(geom_id, flag)

def GetNumCFDSources(geom_id):
    r"""GetNumCFDSources(std::string const & geom_id) -> int"""
    return _vsp_g.GetNumCFDSources(geom_id)

def GetCFDSourceName(geom_id, source_index):
    r"""GetCFDSourceName(std::string const & geom_id, int source_index) -> std::string"""
    return _vsp_g.GetCFDSourceName(geom_id, source_index)

def SetCFDSourceName(geom_id, source_index, name):
    r"""SetCFDSourceName(std::string const & geom_id, int source_index, std::string const & name)"""
    return _vsp_g.SetCFDSourceName(geom_id, source_index, name)

def GetCFDSourceType(geom_id, source_index):
    r"""GetCFDSourceType(std::string const & geom_id, int source_index) -> int"""
    return _vsp_g.GetCFDSourceType(geom_id, source_index)

def DeleteCFDSource(geom_id, source_index):
    r"""DeleteCFDSource(std::string const & geom_id, int source_index)"""
    return _vsp_g.DeleteCFDSource(geom_id, source_index)

def DeleteAllCFDSources():
    r"""DeleteAllCFDSources()"""
    return _vsp_g.DeleteAllCFDSources()

def GetCFDSourceID(geom_id, source_index):
    r"""GetCFDSourceID(std::string const & geom_id, int source_index) -> std::string"""
    return _vsp_g.GetCFDSourceID(geom_id, source_index)

def AdjustAllCFDSourceLen(mult):
    r"""AdjustAllCFDSourceLen(double mult)"""
    return _vsp_g.AdjustAllCFDSourceLen(mult)

def AdjustAllCFDSourceRad(mult):
    r"""AdjustAllCFDSourceRad(double mult)"""
    return _vsp_g.AdjustAllCFDSourceRad(mult)

def AddDefaultSources():
    r"""AddDefaultSources()"""
    return _vsp_g.AddDefaultSources()

def AddCFDSource(type, geom_id, surf_index, l1, r1, u1, w1, l2=0, r2=0, u2=0, w2=0):
    r"""AddCFDSource(int type, std::string const & geom_id, int surf_index, double l1, double r1, double u1, double w1, double l2=0, double r2=0, double u2=0, double w2=0)"""
    return _vsp_g.AddCFDSource(type, geom_id, surf_index, l1, r1, u1, w1, l2, r2, u2, w2)

def GetVSPAERORefWingID():
    r"""GetVSPAERORefWingID() -> std::string"""
    return _vsp_g.GetVSPAERORefWingID()

def SetVSPAERORefWingID(geom_id):
    r"""SetVSPAERORefWingID(std::string const & geom_id) -> std::string"""
    return _vsp_g.SetVSPAERORefWingID(geom_id)

def GetNumAnalysis():
    r"""GetNumAnalysis() -> int"""
    return _vsp_g.GetNumAnalysis()

def ListAnalysis():
    r"""ListAnalysis() -> StringVector"""
    return _vsp_g.ListAnalysis()

def GetAnalysisInputNames(analysis):
    r"""GetAnalysisInputNames(std::string const & analysis) -> StringVector"""
    return _vsp_g.GetAnalysisInputNames(analysis)

def GetAnalysisDoc(analysis):
    r"""GetAnalysisDoc(std::string const & analysis) -> std::string"""
    return _vsp_g.GetAnalysisDoc(analysis)

def GetAnalysisInputDoc(analysis, name):
    r"""GetAnalysisInputDoc(std::string const & analysis, std::string const & name) -> std::string"""
    return _vsp_g.GetAnalysisInputDoc(analysis, name)

def ExecAnalysis(analysis):
    r"""ExecAnalysis(std::string const & analysis) -> std::string"""
    return _vsp_g.ExecAnalysis(analysis)

def GetNumAnalysisInputData(analysis, name):
    r"""GetNumAnalysisInputData(std::string const & analysis, std::string const & name) -> int"""
    return _vsp_g.GetNumAnalysisInputData(analysis, name)

def GetAnalysisInputType(analysis, name):
    r"""GetAnalysisInputType(std::string const & analysis, std::string const & name) -> int"""
    return _vsp_g.GetAnalysisInputType(analysis, name)

def GetIntAnalysisInput(analysis, name, index=0):
    r"""GetIntAnalysisInput(std::string const & analysis, std::string const & name, int index=0) -> IntVector"""
    return _vsp_g.GetIntAnalysisInput(analysis, name, index)

def GetDoubleAnalysisInput(analysis, name, index=0):
    r"""GetDoubleAnalysisInput(std::string const & analysis, std::string const & name, int index=0) -> DoubleVector"""
    return _vsp_g.GetDoubleAnalysisInput(analysis, name, index)

def GetStringAnalysisInput(analysis, name, index=0):
    r"""GetStringAnalysisInput(std::string const & analysis, std::string const & name, int index=0) -> StringVector"""
    return _vsp_g.GetStringAnalysisInput(analysis, name, index)

def GetVec3dAnalysisInput(analysis, name, index=0):
    r"""GetVec3dAnalysisInput(std::string const & analysis, std::string const & name, int index=0) -> Vec3dVec"""
    return _vsp_g.GetVec3dAnalysisInput(analysis, name, index)

def SetAnalysisInputDefaults(analysis):
    r"""SetAnalysisInputDefaults(std::string const & analysis)"""
    return _vsp_g.SetAnalysisInputDefaults(analysis)

def SetIntAnalysisInput(analysis, name, indata, index=0):
    r"""SetIntAnalysisInput(std::string const & analysis, std::string const & name, IntVector indata, int index=0)"""
    return _vsp_g.SetIntAnalysisInput(analysis, name, indata, index)

def SetDoubleAnalysisInput(analysis, name, indata, index=0):
    r"""SetDoubleAnalysisInput(std::string const & analysis, std::string const & name, DoubleVector indata, int index=0)"""
    return _vsp_g.SetDoubleAnalysisInput(analysis, name, indata, index)

def SetStringAnalysisInput(analysis, name, indata, index=0):
    r"""SetStringAnalysisInput(std::string const & analysis, std::string const & name, StringVector indata, int index=0)"""
    return _vsp_g.SetStringAnalysisInput(analysis, name, indata, index)

def SetVec3dAnalysisInput(analysis, name, indata, index=0):
    r"""SetVec3dAnalysisInput(std::string const & analysis, std::string const & name, Vec3dVec indata, int index=0)"""
    return _vsp_g.SetVec3dAnalysisInput(analysis, name, indata, index)

def PrintAnalysisInputs(analysis_name):
    r"""PrintAnalysisInputs(std::string const & analysis_name)"""
    return _vsp_g.PrintAnalysisInputs(analysis_name)

def PrintAnalysisDocs(analysis_name):
    r"""PrintAnalysisDocs(std::string const & analysis_name)"""
    return _vsp_g.PrintAnalysisDocs(analysis_name)

def AddGeometryAnalysis():
    r"""AddGeometryAnalysis() -> std::string"""
    return _vsp_g.AddGeometryAnalysis()

def AddGeometryAnalysisAzEl(geom_analysis_id, azimuth, elevation):
    r"""AddGeometryAnalysisAzEl(std::string const & geom_analysis_id, double azimuth, double elevation)"""
    return _vsp_g.AddGeometryAnalysisAzEl(geom_analysis_id, azimuth, elevation)

def DeleteGeometryAnalysisAzEl(geom_analysis_id, index):
    r"""DeleteGeometryAnalysisAzEl(std::string const & geom_analysis_id, int index)"""
    return _vsp_g.DeleteGeometryAnalysisAzEl(geom_analysis_id, index)

def DeleteAllGeometryAnalysisAzEl(geom_analysis_id):
    r"""DeleteAllGeometryAnalysisAzEl(std::string const & geom_analysis_id)"""
    return _vsp_g.DeleteAllGeometryAnalysisAzEl(geom_analysis_id)

def GetNumGeometryAnalysisAzEl(geom_analysis_id):
    r"""GetNumGeometryAnalysisAzEl(std::string const & geom_analysis_id) -> int"""
    return _vsp_g.GetNumGeometryAnalysisAzEl(geom_analysis_id)

def GetGeometryAnalysisAzimuthParm(geom_analysis_id, index):
    r"""GetGeometryAnalysisAzimuthParm(std::string const & geom_analysis_id, int index) -> std::string"""
    return _vsp_g.GetGeometryAnalysisAzimuthParm(geom_analysis_id, index)

def GetGeometryAnalysisElevationParm(geom_analysis_id, index):
    r"""GetGeometryAnalysisElevationParm(std::string const & geom_analysis_id, int index) -> std::string"""
    return _vsp_g.GetGeometryAnalysisElevationParm(geom_analysis_id, index)

def DeleteGeometryAnalysis(id):
    r"""DeleteGeometryAnalysis(std::string const & id)"""
    return _vsp_g.DeleteGeometryAnalysis(id)

def DeleteAllGeometryAnalyses():
    r"""DeleteAllGeometryAnalyses()"""
    return _vsp_g.DeleteAllGeometryAnalyses()

def GetAllGeometryAnalysesIDVec():
    r"""GetAllGeometryAnalysesIDVec() -> StringVector"""
    return _vsp_g.GetAllGeometryAnalysesIDVec()

def SetActiveGeometryAnalysis(id):
    r"""SetActiveGeometryAnalysis(std::string const & id)"""
    return _vsp_g.SetActiveGeometryAnalysis(id)

def GetActiveGeometryAnalysis():
    r"""GetActiveGeometryAnalysis() -> std::string"""
    return _vsp_g.GetActiveGeometryAnalysis()

def MakeMeshGeom(ga_id):
    r"""MakeMeshGeom(std::string const & ga_id) -> std::string"""
    return _vsp_g.MakeMeshGeom(ga_id)

def SummarizeAttributes():
    r"""SummarizeAttributes() -> std::string"""
    return _vsp_g.SummarizeAttributes()

def SummarizeAttributesAsTree():
    r"""SummarizeAttributesAsTree() -> std::string"""
    return _vsp_g.SummarizeAttributesAsTree()

def FindAllAttributes():
    r"""FindAllAttributes() -> StringVector"""
    return _vsp_g.FindAllAttributes()

def FindAttributesByName(search_str):
    r"""FindAttributesByName(std::string const & search_str) -> StringVector"""
    return _vsp_g.FindAttributesByName(search_str)

def FindAttributeByName(search_str, index):
    r"""FindAttributeByName(std::string const & search_str, int index) -> std::string"""
    return _vsp_g.FindAttributeByName(search_str, index)

def FindAttributeInCollection(obj_id, search_str, index):
    r"""FindAttributeInCollection(std::string const & obj_id, std::string const & search_str, int index) -> std::string"""
    return _vsp_g.FindAttributeInCollection(obj_id, search_str, index)

def FindAttributeNamesInCollection(collID):
    r"""FindAttributeNamesInCollection(std::string const & collID) -> StringVector"""
    return _vsp_g.FindAttributeNamesInCollection(collID)

def FindAttributesInCollection(collID):
    r"""FindAttributesInCollection(std::string const & collID) -> StringVector"""
    return _vsp_g.FindAttributesInCollection(collID)

def FindAttributedObjects():
    r"""FindAttributedObjects() -> StringVector"""
    return _vsp_g.FindAttributedObjects()

def GetObjectType(attachID):
    r"""GetObjectType(std::string const & attachID) -> int"""
    return _vsp_g.GetObjectType(attachID)

def GetObjectTypeName(attachID):
    r"""GetObjectTypeName(std::string const & attachID) -> std::string"""
    return _vsp_g.GetObjectTypeName(attachID)

def GetObjectName(attachID):
    r"""GetObjectName(std::string const & attachID) -> std::string"""
    return _vsp_g.GetObjectName(attachID)

def GetObjectParent(id):
    r"""GetObjectParent(std::string const & id) -> std::string"""
    return _vsp_g.GetObjectParent(id)

def GetChildCollection(attachID):
    r"""GetChildCollection(std::string const & attachID) -> std::string"""
    return _vsp_g.GetChildCollection(attachID)

def GetGeomSetCollection(index):
    r"""GetGeomSetCollection(int const & index) -> std::string"""
    return _vsp_g.GetGeomSetCollection(index)

def GetAttributeName(attrID):
    r"""GetAttributeName(std::string const & attrID) -> std::string"""
    return _vsp_g.GetAttributeName(attrID)

def GetAttributeID(collID, attributeName, index):
    r"""GetAttributeID(std::string const & collID, std::string const & attributeName, int index) -> std::string"""
    return _vsp_g.GetAttributeID(collID, attributeName, index)

def GetAttributeDoc(attrID):
    r"""GetAttributeDoc(std::string const & attrID) -> std::string"""
    return _vsp_g.GetAttributeDoc(attrID)

def GetAttributeType(attrID):
    r"""GetAttributeType(std::string const & attrID) -> int"""
    return _vsp_g.GetAttributeType(attrID)

def GetAttributeTypeName(attrID):
    r"""GetAttributeTypeName(std::string const & attrID) -> std::string"""
    return _vsp_g.GetAttributeTypeName(attrID)

def GetAttributeBoolVal(attrID):
    r"""GetAttributeBoolVal(std::string const & attrID) -> IntVector"""
    return _vsp_g.GetAttributeBoolVal(attrID)

def GetAttributeIntVal(attrID):
    r"""GetAttributeIntVal(std::string const & attrID) -> IntVector"""
    return _vsp_g.GetAttributeIntVal(attrID)

def GetAttributeDoubleVal(attrID):
    r"""GetAttributeDoubleVal(std::string const & attrID) -> DoubleVector"""
    return _vsp_g.GetAttributeDoubleVal(attrID)

def GetAttributeStringVal(attrID):
    r"""GetAttributeStringVal(std::string const & attrID) -> StringVector"""
    return _vsp_g.GetAttributeStringVal(attrID)

def GetAttributeParmID(attrID):
    r"""GetAttributeParmID(std::string const & attrID) -> StringVector"""
    return _vsp_g.GetAttributeParmID(attrID)

def GetAttributeParmVal(attrID):
    r"""GetAttributeParmVal(std::string const & attrID) -> DoubleVector"""
    return _vsp_g.GetAttributeParmVal(attrID)

def GetAttributeParmName(attrID):
    r"""GetAttributeParmName(std::string const & attrID) -> StringVector"""
    return _vsp_g.GetAttributeParmName(attrID)

def GetAttributeVec3dVal(attrID):
    r"""GetAttributeVec3dVal(std::string const & attrID) -> Vec3dVec"""
    return _vsp_g.GetAttributeVec3dVal(attrID)

def GetAttributeIntMatrixVal(attrID):
    r"""GetAttributeIntMatrixVal(std::string const & attrID) -> IntVecVec"""
    return _vsp_g.GetAttributeIntMatrixVal(attrID)

def GetAttributeDoubleMatrixVal(attrID):
    r"""GetAttributeDoubleMatrixVal(std::string const & attrID) -> DoubleVecVec"""
    return _vsp_g.GetAttributeDoubleMatrixVal(attrID)

def SetAttributeName(attrID, name):
    r"""SetAttributeName(std::string const & attrID, std::string const & name)"""
    return _vsp_g.SetAttributeName(attrID, name)

def SetAttributeDoc(attrID, doc):
    r"""SetAttributeDoc(std::string const & attrID, std::string const & doc)"""
    return _vsp_g.SetAttributeDoc(attrID, doc)

def SetAttributeBool(attrID, value):
    r"""SetAttributeBool(std::string const & attrID, bool value)"""
    return _vsp_g.SetAttributeBool(attrID, value)

def SetAttributeInt(attrID, value):
    r"""SetAttributeInt(std::string const & attrID, int value)"""
    return _vsp_g.SetAttributeInt(attrID, value)

def SetAttributeDouble(attrID, value):
    r"""SetAttributeDouble(std::string const & attrID, double value)"""
    return _vsp_g.SetAttributeDouble(attrID, value)

def SetAttributeString(attrID, value):
    r"""SetAttributeString(std::string const & attrID, std::string const & value)"""
    return _vsp_g.SetAttributeString(attrID, value)

def SetAttributeParmID(attrID, value):
    r"""SetAttributeParmID(std::string const & attrID, std::string const & value)"""
    return _vsp_g.SetAttributeParmID(attrID, value)

def SetAttributeVec3d(attrID, value):
    r"""SetAttributeVec3d(std::string const & attrID, Vec3dVec value)"""
    return _vsp_g.SetAttributeVec3d(attrID, value)

def SetAttributeIntMatrix(attrID, value):
    r"""SetAttributeIntMatrix(std::string const & attrID, IntVecVec value)"""
    return _vsp_g.SetAttributeIntMatrix(attrID, value)

def SetAttributeDoubleMatrix(attrID, value):
    r"""SetAttributeDoubleMatrix(std::string const & attrID, DoubleVecVec value)"""
    return _vsp_g.SetAttributeDoubleMatrix(attrID, value)

def DeleteAttribute(attrID):
    r"""DeleteAttribute(std::string const & attrID)"""
    return _vsp_g.DeleteAttribute(attrID)

def AddAttributeBool(collID, attributeName, value):
    r"""AddAttributeBool(std::string const & collID, std::string const & attributeName, bool value) -> std::string"""
    return _vsp_g.AddAttributeBool(collID, attributeName, value)

def AddAttributeInt(collID, attributeName, value):
    r"""AddAttributeInt(std::string const & collID, std::string const & attributeName, int value) -> std::string"""
    return _vsp_g.AddAttributeInt(collID, attributeName, value)

def AddAttributeDouble(collID, attributeName, value):
    r"""AddAttributeDouble(std::string const & collID, std::string const & attributeName, double value) -> std::string"""
    return _vsp_g.AddAttributeDouble(collID, attributeName, value)

def AddAttributeString(collID, attributeName, value):
    r"""AddAttributeString(std::string const & collID, std::string const & attributeName, std::string const & value) -> std::string"""
    return _vsp_g.AddAttributeString(collID, attributeName, value)

def AddAttributeParm(collID, attributeName, parmID):
    r"""AddAttributeParm(std::string const & collID, std::string const & attributeName, std::string const & parmID) -> std::string"""
    return _vsp_g.AddAttributeParm(collID, attributeName, parmID)

def AddAttributeVec3d(collID, attributeName, value):
    r"""AddAttributeVec3d(std::string const & collID, std::string const & attributeName, Vec3dVec value) -> std::string"""
    return _vsp_g.AddAttributeVec3d(collID, attributeName, value)

def AddAttributeIntMatrix(collID, attributeName, value):
    r"""AddAttributeIntMatrix(std::string const & collID, std::string const & attributeName, IntVecVec value) -> std::string"""
    return _vsp_g.AddAttributeIntMatrix(collID, attributeName, value)

def AddAttributeDoubleMatrix(collID, attributeName, value):
    r"""AddAttributeDoubleMatrix(std::string const & collID, std::string const & attributeName, DoubleVecVec value) -> std::string"""
    return _vsp_g.AddAttributeDoubleMatrix(collID, attributeName, value)

def AddAttributeGroup(collID, attributeName):
    r"""AddAttributeGroup(std::string const & collID, std::string const & attributeName) -> std::string"""
    return _vsp_g.AddAttributeGroup(collID, attributeName)

def CopyAttribute(attrID):
    r"""CopyAttribute(std::string const & attrID) -> int"""
    return _vsp_g.CopyAttribute(attrID)

def CutAttribute(attrID):
    r"""CutAttribute(std::string const & attrID)"""
    return _vsp_g.CutAttribute(attrID)

def PasteAttribute(coll_id):
    r"""PasteAttribute(std::string const & coll_id) -> StringVector"""
    return _vsp_g.PasteAttribute(coll_id)

def GetAllResultsNames():
    r"""GetAllResultsNames() -> StringVector"""
    return _vsp_g.GetAllResultsNames()

def GetAllDataNames(results_id):
    r"""GetAllDataNames(std::string const & results_id) -> StringVector"""
    return _vsp_g.GetAllDataNames(results_id)

def GetNumResults(name):
    r"""GetNumResults(std::string const & name) -> int"""
    return _vsp_g.GetNumResults(name)

def GetResultsName(results_id):
    r"""GetResultsName(std::string const & results_id) -> std::string"""
    return _vsp_g.GetResultsName(results_id)

def GetResultsSetDoc(results_id):
    r"""GetResultsSetDoc(std::string const & results_id) -> std::string"""
    return _vsp_g.GetResultsSetDoc(results_id)

def GetResultsEntryDoc(results_id, data_name):
    r"""GetResultsEntryDoc(std::string const & results_id, std::string const & data_name) -> std::string"""
    return _vsp_g.GetResultsEntryDoc(results_id, data_name)

def FindResultsID(name, index=0):
    r"""FindResultsID(std::string const & name, int index=0) -> std::string"""
    return _vsp_g.FindResultsID(name, index)

def FindLatestResultsID(name):
    r"""FindLatestResultsID(std::string const & name) -> std::string"""
    return _vsp_g.FindLatestResultsID(name)

def GetNumData(results_id, data_name):
    r"""GetNumData(std::string const & results_id, std::string const & data_name) -> int"""
    return _vsp_g.GetNumData(results_id, data_name)

def GetResultsType(results_id, data_name):
    r"""GetResultsType(std::string const & results_id, std::string const & data_name) -> int"""
    return _vsp_g.GetResultsType(results_id, data_name)

def GetIntResults(id, name, index=0):
    r"""GetIntResults(std::string const & id, std::string const & name, int index=0) -> IntVector"""
    return _vsp_g.GetIntResults(id, name, index)

def GetDoubleResults(id, name, index=0):
    r"""GetDoubleResults(std::string const & id, std::string const & name, int index=0) -> DoubleVector"""
    return _vsp_g.GetDoubleResults(id, name, index)

def GetDoubleMatResults(id, name, index=0):
    r"""GetDoubleMatResults(std::string const & id, std::string const & name, int index=0) -> DoubleVecVec"""
    return _vsp_g.GetDoubleMatResults(id, name, index)

def GetStringResults(id, name, index=0):
    r"""GetStringResults(std::string const & id, std::string const & name, int index=0) -> StringVector"""
    return _vsp_g.GetStringResults(id, name, index)

def GetVec3dResults(id, name, index=0):
    r"""GetVec3dResults(std::string const & id, std::string const & name, int index=0) -> Vec3dVec"""
    return _vsp_g.GetVec3dResults(id, name, index)

def CreateGeomResults(geom_id, name):
    r"""CreateGeomResults(std::string const & geom_id, std::string const & name) -> std::string"""
    return _vsp_g.CreateGeomResults(geom_id, name)

def DeleteAllResults():
    r"""DeleteAllResults()"""
    return _vsp_g.DeleteAllResults()

def DeleteResult(id):
    r"""DeleteResult(std::string const & id)"""
    return _vsp_g.DeleteResult(id)

def WriteResultsCSVFile(id, file_name):
    r"""WriteResultsCSVFile(std::string const & id, std::string const & file_name)"""
    return _vsp_g.WriteResultsCSVFile(id, file_name)

def PrintResults(results_id):
    r"""PrintResults(std::string const & results_id)"""
    return _vsp_g.PrintResults(results_id)

def PrintResultsDocs(results_id):
    r"""PrintResultsDocs(std::string const & results_id)"""
    return _vsp_g.PrintResultsDocs(results_id)

def WriteTestResults():
    r"""WriteTestResults()"""
    return _vsp_g.WriteTestResults()

def InitGUI():
    r"""InitGUI()"""
    return _vsp_g.InitGUI()

def StartGUI():
    r"""StartGUI()"""
    return _vsp_g.StartGUI()

def EnableStopGUIMenuItem():
    r"""EnableStopGUIMenuItem()"""
    return _vsp_g.EnableStopGUIMenuItem()

def DisableStopGUIMenuItem():
    r"""DisableStopGUIMenuItem()"""
    return _vsp_g.DisableStopGUIMenuItem()

def StopGUI():
    r"""StopGUI()"""
    return _vsp_g.StopGUI()

def PopupMsg(msg):
    r"""PopupMsg(std::string const & msg)"""
    return _vsp_g.PopupMsg(msg)

def UpdateGUI():
    r"""UpdateGUI()"""
    return _vsp_g.UpdateGUI()

def IsGUIBuild():
    r"""IsGUIBuild() -> bool"""
    return _vsp_g.IsGUIBuild()

def Lock():
    r"""Lock()"""
    return _vsp_g.Lock()

def Unlock():
    r"""Unlock()"""
    return _vsp_g.Unlock()

def IsEventLoopRunning():
    r"""IsEventLoopRunning() -> bool"""
    return _vsp_g.IsEventLoopRunning()

def ScreenGrab(fname, w, h, transparentBG, autocrop=False):
    r"""ScreenGrab(std::string const & fname, int w, int h, bool transparentBG, bool autocrop=False)"""
    return _vsp_g.ScreenGrab(fname, w, h, transparentBG, autocrop)

def SetViewAxis(vaxis):
    r"""SetViewAxis(bool vaxis)"""
    return _vsp_g.SetViewAxis(vaxis)

def SetShowBorders(brdr):
    r"""SetShowBorders(bool brdr)"""
    return _vsp_g.SetShowBorders(brdr)

def SetGeomDrawType(geom_id, type):
    r"""SetGeomDrawType(std::string const & geom_id, int type)"""
    return _vsp_g.SetGeomDrawType(geom_id, type)

def SetGeomWireColor(geom_id, r, g, b):
    r"""SetGeomWireColor(std::string const & geom_id, int r, int g, int b)"""
    return _vsp_g.SetGeomWireColor(geom_id, r, g, b)

def SetGeomDisplayType(geom_id, type):
    r"""SetGeomDisplayType(std::string const & geom_id, int type)"""
    return _vsp_g.SetGeomDisplayType(geom_id, type)

def GetGeomDrawType(geom_id):
    r"""GetGeomDrawType(std::string const & geom_id) -> int"""
    return _vsp_g.GetGeomDrawType(geom_id)

def GetGeomDisplayType(geom_id):
    r"""GetGeomDisplayType(std::string const & geom_id) -> int"""
    return _vsp_g.GetGeomDisplayType(geom_id)

def GetGeomWireColor(geom_id):
    r"""GetGeomWireColor(std::string const & geom_id) -> vec3d"""
    return _vsp_g.GetGeomWireColor(geom_id)

def GetGeomMaterialName(geom_id):
    r"""GetGeomMaterialName(std::string const & geom_id) -> std::string"""
    return _vsp_g.GetGeomMaterialName(geom_id)

def SetGeomMaterialName(geom_id, name):
    r"""SetGeomMaterialName(std::string const & geom_id, std::string const & name)"""
    return _vsp_g.SetGeomMaterialName(geom_id, name)

def AddMaterial(name, ambient, diffuse, specular, emissive, alpha, shininess):
    r"""AddMaterial(std::string const & name, vec3d ambient, vec3d diffuse, vec3d specular, vec3d emissive, double const & alpha, double const & shininess)"""
    return _vsp_g.AddMaterial(name, ambient, diffuse, specular, emissive, alpha, shininess)

def GetMaterialNames():
    r"""GetMaterialNames() -> StringVector"""
    return _vsp_g.GetMaterialNames()

def SetBackground(r, g, b):
    r"""SetBackground(double r, double g, double b)"""
    return _vsp_g.SetBackground(r, g, b)

def SetAllViews(view):
    r"""SetAllViews(int view)"""
    return _vsp_g.SetAllViews(view)

def SetView(viewport, view):
    r"""SetView(int viewport, int view)"""
    return _vsp_g.SetView(viewport, view)

def FitAllViews():
    r"""FitAllViews()"""
    return _vsp_g.FitAllViews()

def ResetViews():
    r"""ResetViews()"""
    return _vsp_g.ResetViews()

def SetWindowLayout(r, c):
    r"""SetWindowLayout(int r, int c)"""
    return _vsp_g.SetWindowLayout(r, c)

def SetGUIElementDisable(e, state):
    r"""SetGUIElementDisable(int e, bool state)"""
    return _vsp_g.SetGUIElementDisable(e, state)

def SetGUIScreenDisable(s, state):
    r"""SetGUIScreenDisable(int s, bool state)"""
    return _vsp_g.SetGUIScreenDisable(s, state)

def SetGeomScreenDisable(s, state):
    r"""SetGeomScreenDisable(int s, bool state)"""
    return _vsp_g.SetGeomScreenDisable(s, state)

def HideScreen(s):
    r"""HideScreen(int s)"""
    return _vsp_g.HideScreen(s)

def ShowScreen(s):
    r"""ShowScreen(int s)"""
    return _vsp_g.ShowScreen(s)

def GetGeomTypes():
    r"""GetGeomTypes() -> StringVector"""
    return _vsp_g.GetGeomTypes()

def AddGeom(*args):
    r"""AddGeom(std::string const & type, std::string const & parent=std::string()) -> std::string"""
    return _vsp_g.AddGeom(*args)

def UpdateGeom(geom_id):
    r"""UpdateGeom(std::string const & geom_id)"""
    return _vsp_g.UpdateGeom(geom_id)

def DeleteGeom(geom_id):
    r"""DeleteGeom(std::string const & geom_id)"""
    return _vsp_g.DeleteGeom(geom_id)

def DeleteGeomVec(del_vec):
    r"""DeleteGeomVec(StringVector del_vec)"""
    return _vsp_g.DeleteGeomVec(del_vec)

def CutGeomToClipboard(geom_id):
    r"""CutGeomToClipboard(std::string const & geom_id)"""
    return _vsp_g.CutGeomToClipboard(geom_id)

def CopyGeomToClipboard(geom_id):
    r"""CopyGeomToClipboard(std::string const & geom_id)"""
    return _vsp_g.CopyGeomToClipboard(geom_id)

def PasteGeomClipboard(*args):
    r"""PasteGeomClipboard(std::string const & parent=std::string()) -> StringVector"""
    return _vsp_g.PasteGeomClipboard(*args)

def FindGeoms():
    r"""FindGeoms() -> StringVector"""
    return _vsp_g.FindGeoms()

def FindGeomsWithName(name):
    r"""FindGeomsWithName(std::string const & name) -> StringVector"""
    return _vsp_g.FindGeomsWithName(name)

def FindGeom(name, index):
    r"""FindGeom(std::string const & name, int index) -> std::string"""
    return _vsp_g.FindGeom(name, index)

def SetGeomName(geom_id, name):
    r"""SetGeomName(std::string const & geom_id, std::string const & name)"""
    return _vsp_g.SetGeomName(geom_id, name)

def GetGeomName(geom_id):
    r"""GetGeomName(std::string const & geom_id) -> std::string"""
    return _vsp_g.GetGeomName(geom_id)

def GetGeomParmIDs(geom_id):
    r"""GetGeomParmIDs(std::string const & geom_id) -> StringVector"""
    return _vsp_g.GetGeomParmIDs(geom_id)

def GetGeomTypeName(geom_id):
    r"""GetGeomTypeName(std::string const & geom_id) -> std::string"""
    return _vsp_g.GetGeomTypeName(geom_id)

def GetParm(geom_id, name, group):
    r"""GetParm(std::string const & geom_id, std::string const & name, std::string const & group) -> std::string"""
    return _vsp_g.GetParm(geom_id, name, group)

def SetGeomParent(geom_id, parent_id):
    r"""SetGeomParent(std::string const & geom_id, std::string const & parent_id)"""
    return _vsp_g.SetGeomParent(geom_id, parent_id)

def ReorderGeom(geom_id, reorder_type):
    r"""ReorderGeom(std::string const & geom_id, int reorder_type)"""
    return _vsp_g.ReorderGeom(geom_id, reorder_type)

def AttachGeomTexture(geom_id, file_name):
    r"""AttachGeomTexture(std::string const & geom_id, std::string const & file_name) -> std::string"""
    return _vsp_g.AttachGeomTexture(geom_id, file_name)

def RemoveGeomTexture(geom_id, texture_id):
    r"""RemoveGeomTexture(std::string const & geom_id, std::string const & texture_id)"""
    return _vsp_g.RemoveGeomTexture(geom_id, texture_id)

def GetGeomTextureIDVec(geom_id):
    r"""GetGeomTextureIDVec(std::string const & geom_id) -> StringVector"""
    return _vsp_g.GetGeomTextureIDVec(geom_id)

def GetGeomTextureFileName(geom_id, texture_id):
    r"""GetGeomTextureFileName(std::string const & geom_id, std::string const & texture_id) -> std::string"""
    return _vsp_g.GetGeomTextureFileName(geom_id, texture_id)

def GetGeomParent(geom_id):
    r"""GetGeomParent(std::string const & geom_id) -> std::string"""
    return _vsp_g.GetGeomParent(geom_id)

def GetGeomChildren(geom_id):
    r"""GetGeomChildren(std::string const & geom_id) -> StringVector"""
    return _vsp_g.GetGeomChildren(geom_id)

def GetNumXSecSurfs(geom_id):
    r"""GetNumXSecSurfs(std::string const & geom_id) -> int"""
    return _vsp_g.GetNumXSecSurfs(geom_id)

def GetNumMainSurfs(geom_id):
    r"""GetNumMainSurfs(std::string const & geom_id) -> int"""
    return _vsp_g.GetNumMainSurfs(geom_id)

def GetTotalNumSurfs(geom_id):
    r"""GetTotalNumSurfs(std::string const & geom_id) -> int"""
    return _vsp_g.GetTotalNumSurfs(geom_id)

def GetGeomVSPSurfType(geom_id, main_surf_ind=0):
    r"""GetGeomVSPSurfType(std::string const & geom_id, int main_surf_ind=0) -> int"""
    return _vsp_g.GetGeomVSPSurfType(geom_id, main_surf_ind)

def GetGeomVSPSurfCfdType(geom_id, main_surf_ind=0):
    r"""GetGeomVSPSurfCfdType(std::string const & geom_id, int main_surf_ind=0) -> int"""
    return _vsp_g.GetGeomVSPSurfCfdType(geom_id, main_surf_ind)

def GetGeomBBoxMax(geom_id, main_surf_ind=0, ref_frame_is_absolute=True):
    r"""GetGeomBBoxMax(std::string const & geom_id, int main_surf_ind=0, bool ref_frame_is_absolute=True) -> vec3d"""
    return _vsp_g.GetGeomBBoxMax(geom_id, main_surf_ind, ref_frame_is_absolute)

def GetGeomBBoxMin(geom_id, main_surf_ind=0, ref_frame_is_absolute=True):
    r"""GetGeomBBoxMin(std::string const & geom_id, int main_surf_ind=0, bool ref_frame_is_absolute=True) -> vec3d"""
    return _vsp_g.GetGeomBBoxMin(geom_id, main_surf_ind, ref_frame_is_absolute)

def AddSubSurf(geom_id, type, surfindex=0):
    r"""AddSubSurf(std::string const & geom_id, int type, int surfindex=0) -> std::string"""
    return _vsp_g.AddSubSurf(geom_id, type, surfindex)

def GetSubSurf(*args):
    r"""
    GetSubSurf(std::string const & geom_id, int index) -> std::string
    GetSubSurf(std::string const & geom_id, std::string const & name) -> StringVector
    """
    return _vsp_g.GetSubSurf(*args)

def ReorderSubSurf(geom_id, sub_id, reorder_type):
    r"""ReorderSubSurf(std::string const & geom_id, std::string const & sub_id, int reorder_type)"""
    return _vsp_g.ReorderSubSurf(geom_id, sub_id, reorder_type)

def DeleteSubSurf(*args):
    r"""
    DeleteSubSurf(std::string const & geom_id, std::string const & sub_id)
    DeleteSubSurf(std::string const & sub_id)
    """
    return _vsp_g.DeleteSubSurf(*args)

def SetSubSurfName(*args):
    r"""
    SetSubSurfName(std::string const & geom_id, std::string const & sub_id, std::string const & name)
    SetSubSurfName(std::string const & sub_id, std::string const & name)
    """
    return _vsp_g.SetSubSurfName(*args)

def GetSubSurfName(*args):
    r"""
    GetSubSurfName(std::string const & geom_id, std::string const & sub_id) -> std::string
    GetSubSurfName(std::string const & sub_id) -> std::string
    """
    return _vsp_g.GetSubSurfName(*args)

def GetSubSurfIndex(sub_id):
    r"""GetSubSurfIndex(std::string const & sub_id) -> int"""
    return _vsp_g.GetSubSurfIndex(sub_id)

def GetSubSurfIDVec(geom_id):
    r"""GetSubSurfIDVec(std::string const & geom_id) -> StringVector"""
    return _vsp_g.GetSubSurfIDVec(geom_id)

def GetAllSubSurfIDs():
    r"""GetAllSubSurfIDs() -> StringVector"""
    return _vsp_g.GetAllSubSurfIDs()

def GetNumSubSurf(geom_id):
    r"""GetNumSubSurf(std::string const & geom_id) -> int"""
    return _vsp_g.GetNumSubSurf(geom_id)

def GetSubSurfType(sub_id):
    r"""GetSubSurfType(std::string const & sub_id) -> int"""
    return _vsp_g.GetSubSurfType(sub_id)

def GetSubSurfParmIDs(sub_id):
    r"""GetSubSurfParmIDs(std::string const & sub_id) -> StringVector"""
    return _vsp_g.GetSubSurfParmIDs(sub_id)

def IntersectSubSurf(sub_id):
    r"""IntersectSubSurf(std::string const & sub_id)"""
    return _vsp_g.IntersectSubSurf(sub_id)

def GetIntersectSubSurfGeomID(sub_id):
    r"""GetIntersectSubSurfGeomID(std::string const & sub_id) -> std::string"""
    return _vsp_g.GetIntersectSubSurfGeomID(sub_id)

def SetIntersectSubSurfGeomID(sub_id, geom_id):
    r"""SetIntersectSubSurfGeomID(std::string const & sub_id, std::string const & geom_id)"""
    return _vsp_g.SetIntersectSubSurfGeomID(sub_id, geom_id)

def AddFeaStruct(geom_id, init_skin=True, surfindex=0):
    r"""AddFeaStruct(std::string const & geom_id, bool init_skin=True, int surfindex=0) -> int"""
    return _vsp_g.AddFeaStruct(geom_id, init_skin, surfindex)

def GetFeaMeshStructIndex():
    r"""GetFeaMeshStructIndex() -> int"""
    return _vsp_g.GetFeaMeshStructIndex()

def SetFeaMeshStructIndex(struct_index):
    r"""SetFeaMeshStructIndex(int struct_index)"""
    return _vsp_g.SetFeaMeshStructIndex(struct_index)

def DeleteFeaStruct(geom_id, fea_struct_ind):
    r"""DeleteFeaStruct(std::string const & geom_id, int fea_struct_ind)"""
    return _vsp_g.DeleteFeaStruct(geom_id, fea_struct_ind)

def GetFeaStructID(geom_id, fea_struct_ind):
    r"""GetFeaStructID(std::string const & geom_id, int fea_struct_ind) -> std::string"""
    return _vsp_g.GetFeaStructID(geom_id, fea_struct_ind)

def GetFeaStructIndex(struct_id):
    r"""GetFeaStructIndex(std::string const & struct_id) -> int"""
    return _vsp_g.GetFeaStructIndex(struct_id)

def GetFeaStructParentGeomID(struct_id):
    r"""GetFeaStructParentGeomID(std::string const & struct_id) -> std::string"""
    return _vsp_g.GetFeaStructParentGeomID(struct_id)

def GetFeaStructName(geom_id, fea_struct_ind):
    r"""GetFeaStructName(std::string const & geom_id, int fea_struct_ind) -> std::string"""
    return _vsp_g.GetFeaStructName(geom_id, fea_struct_ind)

def SetFeaStructName(geom_id, fea_struct_ind, name):
    r"""SetFeaStructName(std::string const & geom_id, int fea_struct_ind, std::string const & name)"""
    return _vsp_g.SetFeaStructName(geom_id, fea_struct_ind, name)

def GetFeaStructIDVec():
    r"""GetFeaStructIDVec() -> StringVector"""
    return _vsp_g.GetFeaStructIDVec()

def SetFeaPartName(part_id, name):
    r"""SetFeaPartName(std::string const & part_id, std::string const & name)"""
    return _vsp_g.SetFeaPartName(part_id, name)

def AddFeaPart(geom_id, fea_struct_ind, type):
    r"""AddFeaPart(std::string const & geom_id, int fea_struct_ind, int type) -> std::string"""
    return _vsp_g.AddFeaPart(geom_id, fea_struct_ind, type)

def DeleteFeaPart(geom_id, fea_struct_ind, part_id):
    r"""DeleteFeaPart(std::string const & geom_id, int fea_struct_ind, std::string const & part_id)"""
    return _vsp_g.DeleteFeaPart(geom_id, fea_struct_ind, part_id)

def ReorderFeaPart(geom_id, fea_struct_ind, part_id, reorder_type):
    r"""ReorderFeaPart(std::string const & geom_id, int fea_struct_ind, std::string const & part_id, int reorder_type)"""
    return _vsp_g.ReorderFeaPart(geom_id, fea_struct_ind, part_id, reorder_type)

def IndividualizeFeaPart(geom_id, fea_struct_ind, part_id):
    r"""IndividualizeFeaPart(std::string const & geom_id, int fea_struct_ind, std::string const & part_id)"""
    return _vsp_g.IndividualizeFeaPart(geom_id, fea_struct_ind, part_id)

def GetFeaPartID(fea_struct_id, fea_part_index):
    r"""GetFeaPartID(std::string const & fea_struct_id, int fea_part_index) -> std::string"""
    return _vsp_g.GetFeaPartID(fea_struct_id, fea_part_index)

def GetFeaPartName(part_id):
    r"""GetFeaPartName(std::string const & part_id) -> std::string"""
    return _vsp_g.GetFeaPartName(part_id)

def GetFeaPartType(part_id):
    r"""GetFeaPartType(std::string const & part_id) -> int"""
    return _vsp_g.GetFeaPartType(part_id)

def GetFeaPartIDVec(fea_struct_id):
    r"""GetFeaPartIDVec(std::string const & fea_struct_id) -> StringVector"""
    return _vsp_g.GetFeaPartIDVec(fea_struct_id)

def GetFeaSubSurfIDVec(fea_struct_id):
    r"""GetFeaSubSurfIDVec(std::string const & fea_struct_id) -> StringVector"""
    return _vsp_g.GetFeaSubSurfIDVec(fea_struct_id)

def SetFeaPartPerpendicularSparID(part_id, perpendicular_spar_id):
    r"""SetFeaPartPerpendicularSparID(std::string const & part_id, std::string const & perpendicular_spar_id)"""
    return _vsp_g.SetFeaPartPerpendicularSparID(part_id, perpendicular_spar_id)

def GetFeaPartPerpendicularSparID(part_id):
    r"""GetFeaPartPerpendicularSparID(std::string const & part_id) -> std::string"""
    return _vsp_g.GetFeaPartPerpendicularSparID(part_id)

def SetFeaSubSurfName(subsurf_id, name):
    r"""SetFeaSubSurfName(std::string const & subsurf_id, std::string const & name)"""
    return _vsp_g.SetFeaSubSurfName(subsurf_id, name)

def GetFeaSubSurfName(subsurf_id):
    r"""GetFeaSubSurfName(std::string const & subsurf_id) -> std::string"""
    return _vsp_g.GetFeaSubSurfName(subsurf_id)

def AddFeaSubSurf(geom_id, fea_struct_ind, type):
    r"""AddFeaSubSurf(std::string const & geom_id, int fea_struct_ind, int type) -> std::string"""
    return _vsp_g.AddFeaSubSurf(geom_id, fea_struct_ind, type)

def DeleteFeaSubSurf(geom_id, fea_struct_ind, ss_id):
    r"""DeleteFeaSubSurf(std::string const & geom_id, int fea_struct_ind, std::string const & ss_id)"""
    return _vsp_g.DeleteFeaSubSurf(geom_id, fea_struct_ind, ss_id)

def GetFeaSubSurfIndex(ss_id):
    r"""GetFeaSubSurfIndex(std::string const & ss_id) -> int"""
    return _vsp_g.GetFeaSubSurfIndex(ss_id)

def GetFeaPolySparNumPt(pspar_id):
    r"""GetFeaPolySparNumPt(std::string const & pspar_id) -> int"""
    return _vsp_g.GetFeaPolySparNumPt(pspar_id)

def AddFeaPolySparPt(pspar_id):
    r"""AddFeaPolySparPt(std::string const & pspar_id) -> std::string"""
    return _vsp_g.AddFeaPolySparPt(pspar_id)

def InsertFeaPolySparPt(pspar_id, index):
    r"""InsertFeaPolySparPt(std::string const & pspar_id, int index) -> std::string"""
    return _vsp_g.InsertFeaPolySparPt(pspar_id, index)

def DelFeaPolySparPt(pspar_id, index):
    r"""DelFeaPolySparPt(std::string const & pspar_id, int index)"""
    return _vsp_g.DelFeaPolySparPt(pspar_id, index)

def DelAllFeaPolySparPt(pspar_id):
    r"""DelAllFeaPolySparPt(std::string const & pspar_id)"""
    return _vsp_g.DelAllFeaPolySparPt(pspar_id)

def MoveFeaPolySparPt(pspar_id, index, reorder_type):
    r"""MoveFeaPolySparPt(std::string const & pspar_id, int index, int reorder_type) -> int"""
    return _vsp_g.MoveFeaPolySparPt(pspar_id, index, reorder_type)

def SetFeaPolySparPtName(pspar_id, index, name):
    r"""SetFeaPolySparPtName(std::string const & pspar_id, int index, std::string const & name)"""
    return _vsp_g.SetFeaPolySparPtName(pspar_id, index, name)

def GetFeaPolySparPtName(pspar_id, index):
    r"""GetFeaPolySparPtName(std::string const & pspar_id, int index) -> std::string"""
    return _vsp_g.GetFeaPolySparPtName(pspar_id, index)

def GetFeaPolySparPtID(pspar_id, index):
    r"""GetFeaPolySparPtID(std::string const & pspar_id, int index) -> std::string"""
    return _vsp_g.GetFeaPolySparPtID(pspar_id, index)

def GetAllFeaPolySparPtIDVec(pspar_id):
    r"""GetAllFeaPolySparPtIDVec(std::string const & pspar_id) -> StringVector"""
    return _vsp_g.GetAllFeaPolySparPtIDVec(pspar_id)

def AddFeaTrimPart(trim_id, part_id):
    r"""AddFeaTrimPart(std::string const & trim_id, std::string const & part_id)"""
    return _vsp_g.AddFeaTrimPart(trim_id, part_id)

def DeleteFeaTrimPart(trim_id, index):
    r"""DeleteFeaTrimPart(std::string const & trim_id, int index)"""
    return _vsp_g.DeleteFeaTrimPart(trim_id, index)

def GetFeaTrimPartIDVec(trim_id):
    r"""GetFeaTrimPartIDVec(std::string const & trim_id) -> StringVector"""
    return _vsp_g.GetFeaTrimPartIDVec(trim_id)

def AddFeaAssembly():
    r"""AddFeaAssembly() -> std::string"""
    return _vsp_g.AddFeaAssembly()

def DeleteFeaAssembly(assembly_id):
    r"""DeleteFeaAssembly(std::string const & assembly_id)"""
    return _vsp_g.DeleteFeaAssembly(assembly_id)

def NumFeaAssemblies():
    r"""NumFeaAssemblies() -> int"""
    return _vsp_g.NumFeaAssemblies()

def GetFeaAssemblyIDVec():
    r"""GetFeaAssemblyIDVec() -> StringVector"""
    return _vsp_g.GetFeaAssemblyIDVec()

def GetFeaAssemblyName(assembly_id):
    r"""GetFeaAssemblyName(std::string const & assembly_id) -> std::string"""
    return _vsp_g.GetFeaAssemblyName(assembly_id)

def SetFeaAssemblyName(assembly_id, name):
    r"""SetFeaAssemblyName(std::string const & assembly_id, std::string const & name)"""
    return _vsp_g.SetFeaAssemblyName(assembly_id, name)

def AddFeaStructureToAssembly(assembly_id, struct_id):
    r"""AddFeaStructureToAssembly(std::string const & assembly_id, std::string const & struct_id)"""
    return _vsp_g.AddFeaStructureToAssembly(assembly_id, struct_id)

def DeleteFeaStructureFromAssembly(assembly_id, struct_id):
    r"""DeleteFeaStructureFromAssembly(std::string const & assembly_id, std::string const & struct_id)"""
    return _vsp_g.DeleteFeaStructureFromAssembly(assembly_id, struct_id)

def GetFeaAssemblyStructureIDVec(assembly_id):
    r"""GetFeaAssemblyStructureIDVec(std::string const & assembly_id) -> StringVector"""
    return _vsp_g.GetFeaAssemblyStructureIDVec(assembly_id)

def AddFeaAssemblyConnection(assembly_id, start_fix_pt_id, start_struct_id, start_index, end_fix_pt_id, end_struct_id, end_index):
    r"""AddFeaAssemblyConnection(std::string const & assembly_id, std::string const & start_fix_pt_id, std::string const & start_struct_id, int start_index, std::string const & end_fix_pt_id, std::string const & end_struct_id, int end_index)"""
    return _vsp_g.AddFeaAssemblyConnection(assembly_id, start_fix_pt_id, start_struct_id, start_index, end_fix_pt_id, end_struct_id, end_index)

def DeleteFeaAssemblyConnection(assembly_id, connection_index):
    r"""DeleteFeaAssemblyConnection(std::string const & assembly_id, int connection_index)"""
    return _vsp_g.DeleteFeaAssemblyConnection(assembly_id, connection_index)

def NumFeaAssemblyConnections(assembly_id):
    r"""NumFeaAssemblyConnections(std::string const & assembly_id) -> int"""
    return _vsp_g.NumFeaAssemblyConnections(assembly_id)

def GetFeaAssemblyFileName(assembly_id, file_type):
    r"""GetFeaAssemblyFileName(std::string const & assembly_id, int file_type) -> std::string"""
    return _vsp_g.GetFeaAssemblyFileName(assembly_id, file_type)

def SetFeaAssemblyFileName(assembly_id, file_type, file_name):
    r"""SetFeaAssemblyFileName(std::string const & assembly_id, int file_type, std::string const & file_name)"""
    return _vsp_g.SetFeaAssemblyFileName(assembly_id, file_type, file_name)

def ComputeFeaAssemblyMesh(assembly_id):
    r"""ComputeFeaAssemblyMesh(std::string const & assembly_id)"""
    return _vsp_g.ComputeFeaAssemblyMesh(assembly_id)

def NumFeaStructures():
    r"""NumFeaStructures() -> int"""
    return _vsp_g.NumFeaStructures()

def NumFeaParts(fea_struct_id):
    r"""NumFeaParts(std::string const & fea_struct_id) -> int"""
    return _vsp_g.NumFeaParts(fea_struct_id)

def NumFeaSubSurfs(fea_struct_id):
    r"""NumFeaSubSurfs(std::string const & fea_struct_id) -> int"""
    return _vsp_g.NumFeaSubSurfs(fea_struct_id)

def AddFeaBC(fea_struct_id, type=-1):
    r"""AddFeaBC(std::string const & fea_struct_id, int type=-1) -> std::string"""
    return _vsp_g.AddFeaBC(fea_struct_id, type)

def DelFeaBC(fea_struct_id, bc_id):
    r"""DelFeaBC(std::string const & fea_struct_id, std::string const & bc_id)"""
    return _vsp_g.DelFeaBC(fea_struct_id, bc_id)

def GetFeaBCIDVec(fea_struct_id):
    r"""GetFeaBCIDVec(std::string const & fea_struct_id) -> StringVector"""
    return _vsp_g.GetFeaBCIDVec(fea_struct_id)

def NumFeaBCs(fea_struct_id):
    r"""NumFeaBCs(std::string const & fea_struct_id) -> int"""
    return _vsp_g.NumFeaBCs(fea_struct_id)

def AddFeaLayer(material_id):
    r"""AddFeaLayer(std::string const & material_id) -> std::string"""
    return _vsp_g.AddFeaLayer(material_id)

def DeleteFeaLayer(material_id, layer_id):
    r"""DeleteFeaLayer(std::string const & material_id, std::string const & layer_id)"""
    return _vsp_g.DeleteFeaLayer(material_id, layer_id)

def ReorderFeaLayer(material_id, layer_id, reorder_type):
    r"""ReorderFeaLayer(std::string const & material_id, std::string const & layer_id, int reorder_type)"""
    return _vsp_g.ReorderFeaLayer(material_id, layer_id, reorder_type)

def NumFeaLayers(material_id):
    r"""NumFeaLayers(std::string const & material_id) -> int"""
    return _vsp_g.NumFeaLayers(material_id)

def GetFeaLayerIDVec(material_id):
    r"""GetFeaLayerIDVec(std::string const & material_id) -> StringVector"""
    return _vsp_g.GetFeaLayerIDVec(material_id)

def GetFeaMaterialIDVec():
    r"""GetFeaMaterialIDVec() -> StringVector"""
    return _vsp_g.GetFeaMaterialIDVec()

def DeleteFeaMaterial(id):
    r"""DeleteFeaMaterial(std::string const & id)"""
    return _vsp_g.DeleteFeaMaterial(id)

def AddFeaMaterial():
    r"""AddFeaMaterial() -> std::string"""
    return _vsp_g.AddFeaMaterial()

def GetFeaPropertyIDVec():
    r"""GetFeaPropertyIDVec() -> StringVector"""
    return _vsp_g.GetFeaPropertyIDVec()

def DeleteFeaProperty(id):
    r"""DeleteFeaProperty(std::string const & id)"""
    return _vsp_g.DeleteFeaProperty(id)

def AddFeaProperty(property_type=0):
    r"""AddFeaProperty(int property_type=0) -> std::string"""
    return _vsp_g.AddFeaProperty(property_type)

def GetFeaMeshVal(geom_id, fea_struct_ind, type):
    r"""GetFeaMeshVal(std::string const & geom_id, int fea_struct_ind, int type) -> double"""
    return _vsp_g.GetFeaMeshVal(geom_id, fea_struct_ind, type)

def SetFeaMeshVal(geom_id, fea_struct_ind, type, val):
    r"""SetFeaMeshVal(std::string const & geom_id, int fea_struct_ind, int type, double val)"""
    return _vsp_g.SetFeaMeshVal(geom_id, fea_struct_ind, type, val)

def GetFeaMeshFileName(geom_id, fea_struct_ind, file_type):
    r"""GetFeaMeshFileName(std::string const & geom_id, int fea_struct_ind, int file_type) -> std::string"""
    return _vsp_g.GetFeaMeshFileName(geom_id, fea_struct_ind, file_type)

def SetFeaMeshFileName(geom_id, fea_struct_ind, file_type, file_name):
    r"""SetFeaMeshFileName(std::string const & geom_id, int fea_struct_ind, int file_type, std::string const & file_name)"""
    return _vsp_g.SetFeaMeshFileName(geom_id, fea_struct_ind, file_type, file_name)

def ComputeFeaMesh(*args):
    r"""
    ComputeFeaMesh(std::string const & geom_id, int fea_struct_ind, int file_type)
    ComputeFeaMesh(std::string const & struct_id, int file_type)
    """
    return _vsp_g.ComputeFeaMesh(*args)

def SetXSecAlias(id, alias):
    r"""SetXSecAlias(std::string const & id, std::string const & alias)"""
    return _vsp_g.SetXSecAlias(id, alias)

def GetXSecAlias(id):
    r"""GetXSecAlias(std::string const & id) -> std::string"""
    return _vsp_g.GetXSecAlias(id)

def SetXSecCurveAlias(id, alias):
    r"""SetXSecCurveAlias(std::string const & id, std::string const & alias)"""
    return _vsp_g.SetXSecCurveAlias(id, alias)

def GetXSecCurveAlias(id):
    r"""GetXSecCurveAlias(std::string const & id) -> std::string"""
    return _vsp_g.GetXSecCurveAlias(id)

def CutXSec(geom_id, index):
    r"""CutXSec(std::string const & geom_id, int index)"""
    return _vsp_g.CutXSec(geom_id, index)

def CopyXSec(geom_id, index):
    r"""CopyXSec(std::string const & geom_id, int index)"""
    return _vsp_g.CopyXSec(geom_id, index)

def PasteXSec(geom_id, index):
    r"""PasteXSec(std::string const & geom_id, int index)"""
    return _vsp_g.PasteXSec(geom_id, index)

def InsertXSec(geom_id, index, type):
    r"""InsertXSec(std::string const & geom_id, int index, int type)"""
    return _vsp_g.InsertXSec(geom_id, index, type)

def SplitWingXSec(wing_id, section_index):
    r"""SplitWingXSec(std::string const & wing_id, int section_index)"""
    return _vsp_g.SplitWingXSec(wing_id, section_index)

def GetDriverGroup(geom_id, section_index):
    r"""GetDriverGroup(std::string const & geom_id, int section_index) -> IntVector"""
    return _vsp_g.GetDriverGroup(geom_id, section_index)

def SetDriverGroup(geom_id, section_index, driver_0, driver_1=-1, driver_2=-1):
    r"""SetDriverGroup(std::string const & geom_id, int section_index, int driver_0, int driver_1=-1, int driver_2=-1)"""
    return _vsp_g.SetDriverGroup(geom_id, section_index, driver_0, driver_1, driver_2)

def GetXSecSurf(geom_id, index):
    r"""GetXSecSurf(std::string const & geom_id, int index) -> std::string"""
    return _vsp_g.GetXSecSurf(geom_id, index)

def GetNumXSec(xsec_surf_id):
    r"""GetNumXSec(std::string const & xsec_surf_id) -> int"""
    return _vsp_g.GetNumXSec(xsec_surf_id)

def GetXSec(xsec_surf_id, xsec_index):
    r"""GetXSec(std::string const & xsec_surf_id, int xsec_index) -> std::string"""
    return _vsp_g.GetXSec(xsec_surf_id, xsec_index)

def ChangeXSecShape(xsec_surf_id, xsec_index, type):
    r"""ChangeXSecShape(std::string const & xsec_surf_id, int xsec_index, int type)"""
    return _vsp_g.ChangeXSecShape(xsec_surf_id, xsec_index, type)

def FitCSTAirfoil(xsec_surf_id, xsec_index, deg):
    r"""FitCSTAirfoil(std::string const & xsec_surf_id, int xsec_index, int deg)"""
    return _vsp_g.FitCSTAirfoil(xsec_surf_id, xsec_index, deg)

def SetXSecSurfGlobalXForm(xsec_surf_id, mat):
    r"""SetXSecSurfGlobalXForm(std::string const & xsec_surf_id, Matrix4d mat)"""
    return _vsp_g.SetXSecSurfGlobalXForm(xsec_surf_id, mat)

def GetXSecSurfGlobalXForm(xsec_surf_id):
    r"""GetXSecSurfGlobalXForm(std::string const & xsec_surf_id) -> Matrix4d"""
    return _vsp_g.GetXSecSurfGlobalXForm(xsec_surf_id)

def GetXSecShape(xsec_id):
    r"""GetXSecShape(std::string const & xsec_id) -> int"""
    return _vsp_g.GetXSecShape(xsec_id)

def GetXSecWidth(xsec_id):
    r"""GetXSecWidth(std::string const & xsec_id) -> double"""
    return _vsp_g.GetXSecWidth(xsec_id)

def GetXSecHeight(xsec_id):
    r"""GetXSecHeight(std::string const & xsec_id) -> double"""
    return _vsp_g.GetXSecHeight(xsec_id)

def SetXSecWidthHeight(xsec_id, w, h):
    r"""SetXSecWidthHeight(std::string const & xsec_id, double w, double h)"""
    return _vsp_g.SetXSecWidthHeight(xsec_id, w, h)

def SetXSecWidth(xsec_id, w):
    r"""SetXSecWidth(std::string const & xsec_id, double w)"""
    return _vsp_g.SetXSecWidth(xsec_id, w)

def SetXSecHeight(xsec_id, h):
    r"""SetXSecHeight(std::string const & xsec_id, double h)"""
    return _vsp_g.SetXSecHeight(xsec_id, h)

def GetXSecParmIDs(xsec_id):
    r"""GetXSecParmIDs(std::string const & xsec_id) -> StringVector"""
    return _vsp_g.GetXSecParmIDs(xsec_id)

def GetXSecParm(xsec_id, name):
    r"""GetXSecParm(std::string const & xsec_id, std::string const & name) -> std::string"""
    return _vsp_g.GetXSecParm(xsec_id, name)

def ReadFileXSec(xsec_id, file_name):
    r"""ReadFileXSec(std::string const & xsec_id, std::string const & file_name) -> Vec3dVec"""
    return _vsp_g.ReadFileXSec(xsec_id, file_name)

def GetXSecPnts(xsec_id):
    r"""GetXSecPnts(std::string const & xsec_id) -> Vec3dVec"""
    return _vsp_g.GetXSecPnts(xsec_id)

def CopyXSecCurve(geom_id, index):
    r"""CopyXSecCurve(std::string const & geom_id, int index)"""
    return _vsp_g.CopyXSecCurve(geom_id, index)

def PasteXSecCurve(geom_id, index):
    r"""PasteXSecCurve(std::string const & geom_id, int index)"""
    return _vsp_g.PasteXSecCurve(geom_id, index)

def SetXSecPnts(xsec_id, pnt_vec):
    r"""SetXSecPnts(std::string const & xsec_id, Vec3dVec pnt_vec)"""
    return _vsp_g.SetXSecPnts(xsec_id, pnt_vec)

def ComputeXSecPnt(xsec_id, fract):
    r"""ComputeXSecPnt(std::string const & xsec_id, double fract) -> vec3d"""
    return _vsp_g.ComputeXSecPnt(xsec_id, fract)

def ComputeXSecTan(xsec_id, fract):
    r"""ComputeXSecTan(std::string const & xsec_id, double fract) -> vec3d"""
    return _vsp_g.ComputeXSecTan(xsec_id, fract)

def ResetXSecSkinParms(xsec_id):
    r"""ResetXSecSkinParms(std::string const & xsec_id)"""
    return _vsp_g.ResetXSecSkinParms(xsec_id)

def GetXSecContinuity(xsec_id):
    r"""GetXSecContinuity(std::string const & xsec_id) -> int"""
    return _vsp_g.GetXSecContinuity(xsec_id)

def SetXSecContinuity(xsec_id, cx):
    r"""SetXSecContinuity(std::string const & xsec_id, int cx)"""
    return _vsp_g.SetXSecContinuity(xsec_id, cx)

def GetXSecTanAngles(xsec_id, side):
    r"""GetXSecTanAngles(std::string const & xsec_id, int side) -> DoubleVector"""
    return _vsp_g.GetXSecTanAngles(xsec_id, side)

def SetXSecTanAngles(xsec_id, side, top, right, bottom, left):
    r"""SetXSecTanAngles(std::string const & xsec_id, int side, double top, double right, double bottom, double left)"""
    return _vsp_g.SetXSecTanAngles(xsec_id, side, top, right, bottom, left)

def GetXSecTanSlews(xsec_id, side):
    r"""GetXSecTanSlews(std::string const & xsec_id, int side) -> DoubleVector"""
    return _vsp_g.GetXSecTanSlews(xsec_id, side)

def SetXSecTanSlews(xsec_id, side, top, right, bottom, left):
    r"""SetXSecTanSlews(std::string const & xsec_id, int side, double top, double right, double bottom, double left)"""
    return _vsp_g.SetXSecTanSlews(xsec_id, side, top, right, bottom, left)

def GetXSecTanStrengths(xsec_id, side):
    r"""GetXSecTanStrengths(std::string const & xsec_id, int side) -> DoubleVector"""
    return _vsp_g.GetXSecTanStrengths(xsec_id, side)

def SetXSecTanStrengths(xsec_id, side, top, right, bottom, left):
    r"""SetXSecTanStrengths(std::string const & xsec_id, int side, double top, double right, double bottom, double left)"""
    return _vsp_g.SetXSecTanStrengths(xsec_id, side, top, right, bottom, left)

def GetXSecCurvatures(xsec_id, side):
    r"""GetXSecCurvatures(std::string const & xsec_id, int side) -> DoubleVector"""
    return _vsp_g.GetXSecCurvatures(xsec_id, side)

def SetXSecCurvatures(xsec_id, side, top, right, bottom, left):
    r"""SetXSecCurvatures(std::string const & xsec_id, int side, double top, double right, double bottom, double left)"""
    return _vsp_g.SetXSecCurvatures(xsec_id, side, top, right, bottom, left)

def ReadFileAirfoil(xsec_id, file_name):
    r"""ReadFileAirfoil(std::string const & xsec_id, std::string const & file_name)"""
    return _vsp_g.ReadFileAirfoil(xsec_id, file_name)

def SetAirfoilUpperPnts(xsec_id, up_pnt_vec):
    r"""SetAirfoilUpperPnts(std::string const & xsec_id, Vec3dVec up_pnt_vec)"""
    return _vsp_g.SetAirfoilUpperPnts(xsec_id, up_pnt_vec)

def SetAirfoilLowerPnts(xsec_id, low_pnt_vec):
    r"""SetAirfoilLowerPnts(std::string const & xsec_id, Vec3dVec low_pnt_vec)"""
    return _vsp_g.SetAirfoilLowerPnts(xsec_id, low_pnt_vec)

def SetAirfoilPnts(xsec_id, up_pnt_vec, low_pnt_vec):
    r"""SetAirfoilPnts(std::string const & xsec_id, Vec3dVec up_pnt_vec, Vec3dVec low_pnt_vec)"""
    return _vsp_g.SetAirfoilPnts(xsec_id, up_pnt_vec, low_pnt_vec)

def GetHersheyBarLiftDist(npts, alpha, Vinf, span, full_span_flag=False):
    r"""GetHersheyBarLiftDist(int const & npts, double const & alpha, double const & Vinf, double const & span, bool full_span_flag=False) -> Vec3dVec"""
    return _vsp_g.GetHersheyBarLiftDist(npts, alpha, Vinf, span, full_span_flag)

def GetHersheyBarDragDist(npts, alpha, Vinf, span, full_span_flag=False):
    r"""GetHersheyBarDragDist(int const & npts, double const & alpha, double const & Vinf, double const & span, bool full_span_flag=False) -> Vec3dVec"""
    return _vsp_g.GetHersheyBarDragDist(npts, alpha, Vinf, span, full_span_flag)

def GetVKTAirfoilPnts(npts, alpha, epsilon, kappa, tau):
    r"""GetVKTAirfoilPnts(int const & npts, double const & alpha, double const & epsilon, double const & kappa, double const & tau) -> Vec3dVec"""
    return _vsp_g.GetVKTAirfoilPnts(npts, alpha, epsilon, kappa, tau)

def GetVKTAirfoilCpDist(alpha, epsilon, kappa, tau, xyz_data):
    r"""GetVKTAirfoilCpDist(double const & alpha, double const & epsilon, double const & kappa, double const & tau, Vec3dVec xyz_data) -> DoubleVector"""
    return _vsp_g.GetVKTAirfoilCpDist(alpha, epsilon, kappa, tau, xyz_data)

def GetEllipsoidSurfPnts(center, abc_rad, u_npts=20, w_npts=20):
    r"""GetEllipsoidSurfPnts(vec3d center, vec3d abc_rad, int u_npts=20, int w_npts=20) -> Vec3dVec"""
    return _vsp_g.GetEllipsoidSurfPnts(center, abc_rad, u_npts, w_npts)

def GetFeatureLinePnts(geom_id):
    r"""GetFeatureLinePnts(std::string const & geom_id) -> Vec3dVec"""
    return _vsp_g.GetFeatureLinePnts(geom_id)

def GetEllipsoidCpDist(surf_pnt_vec, abc_rad, V_inf):
    r"""GetEllipsoidCpDist(Vec3dVec surf_pnt_vec, vec3d abc_rad, vec3d V_inf) -> DoubleVector"""
    return _vsp_g.GetEllipsoidCpDist(surf_pnt_vec, abc_rad, V_inf)

def IntegrateEllipsoidFlow(abc_rad, abc_index):
    r"""IntegrateEllipsoidFlow(vec3d abc_rad, int const & abc_index) -> double"""
    return _vsp_g.IntegrateEllipsoidFlow(abc_rad, abc_index)

def GetAirfoilUpperPnts(xsec_id):
    r"""GetAirfoilUpperPnts(std::string const & xsec_id) -> Vec3dVec"""
    return _vsp_g.GetAirfoilUpperPnts(xsec_id)

def GetAirfoilLowerPnts(xsec_id):
    r"""GetAirfoilLowerPnts(std::string const & xsec_id) -> Vec3dVec"""
    return _vsp_g.GetAirfoilLowerPnts(xsec_id)

def GetUpperCSTCoefs(xsec_id):
    r"""GetUpperCSTCoefs(std::string const & xsec_id) -> DoubleVector"""
    return _vsp_g.GetUpperCSTCoefs(xsec_id)

def GetLowerCSTCoefs(xsec_id):
    r"""GetLowerCSTCoefs(std::string const & xsec_id) -> DoubleVector"""
    return _vsp_g.GetLowerCSTCoefs(xsec_id)

def GetUpperCSTDegree(xsec_id):
    r"""GetUpperCSTDegree(std::string const & xsec_id) -> int"""
    return _vsp_g.GetUpperCSTDegree(xsec_id)

def GetLowerCSTDegree(xsec_id):
    r"""GetLowerCSTDegree(std::string const & xsec_id) -> int"""
    return _vsp_g.GetLowerCSTDegree(xsec_id)

def SetUpperCST(xsec_id, deg, coefs):
    r"""SetUpperCST(std::string const & xsec_id, int deg, DoubleVector coefs)"""
    return _vsp_g.SetUpperCST(xsec_id, deg, coefs)

def SetLowerCST(xsec_id, deg, coefs):
    r"""SetLowerCST(std::string const & xsec_id, int deg, DoubleVector coefs)"""
    return _vsp_g.SetLowerCST(xsec_id, deg, coefs)

def PromoteCSTUpper(xsec_id):
    r"""PromoteCSTUpper(std::string const & xsec_id)"""
    return _vsp_g.PromoteCSTUpper(xsec_id)

def PromoteCSTLower(xsec_id):
    r"""PromoteCSTLower(std::string const & xsec_id)"""
    return _vsp_g.PromoteCSTLower(xsec_id)

def DemoteCSTUpper(xsec_id):
    r"""DemoteCSTUpper(std::string const & xsec_id)"""
    return _vsp_g.DemoteCSTUpper(xsec_id)

def DemoteCSTLower(xsec_id):
    r"""DemoteCSTLower(std::string const & xsec_id)"""
    return _vsp_g.DemoteCSTLower(xsec_id)

def FitAfCST(xsec_surf_id, xsec_index, deg):
    r"""FitAfCST(std::string const & xsec_surf_id, int xsec_index, int deg)"""
    return _vsp_g.FitAfCST(xsec_surf_id, xsec_index, deg)

def AddBackground3D():
    r"""AddBackground3D() -> std::string"""
    return _vsp_g.AddBackground3D()

def GetNumBackground3Ds():
    r"""GetNumBackground3Ds() -> int"""
    return _vsp_g.GetNumBackground3Ds()

def GetAllBackground3Ds():
    r"""GetAllBackground3Ds() -> StringVector"""
    return _vsp_g.GetAllBackground3Ds()

def ShowAllBackground3Ds():
    r"""ShowAllBackground3Ds()"""
    return _vsp_g.ShowAllBackground3Ds()

def HideAllBackground3Ds():
    r"""HideAllBackground3Ds()"""
    return _vsp_g.HideAllBackground3Ds()

def DelAllBackground3Ds():
    r"""DelAllBackground3Ds()"""
    return _vsp_g.DelAllBackground3Ds()

def DelBackground3D(id):
    r"""DelBackground3D(std::string const & id)"""
    return _vsp_g.DelBackground3D(id)

def GetAllBackground3DRelativePaths():
    r"""GetAllBackground3DRelativePaths() -> StringVector"""
    return _vsp_g.GetAllBackground3DRelativePaths()

def GetAllBackground3DAbsolutePaths():
    r"""GetAllBackground3DAbsolutePaths() -> StringVector"""
    return _vsp_g.GetAllBackground3DAbsolutePaths()

def GetBackground3DRelativePath(id):
    r"""GetBackground3DRelativePath(std::string const & id) -> std::string"""
    return _vsp_g.GetBackground3DRelativePath(id)

def GetBackground3DAbsolutePath(id):
    r"""GetBackground3DAbsolutePath(std::string const & id) -> std::string"""
    return _vsp_g.GetBackground3DAbsolutePath(id)

def SetBackground3DRelativePath(id, fname):
    r"""SetBackground3DRelativePath(std::string const & id, std::string const & fname)"""
    return _vsp_g.SetBackground3DRelativePath(id, fname)

def SetBackground3DAbsolutePath(id, fname):
    r"""SetBackground3DAbsolutePath(std::string const & id, std::string const & fname)"""
    return _vsp_g.SetBackground3DAbsolutePath(id, fname)

def CreateAndAddBogie(gear_id):
    r"""CreateAndAddBogie(std::string const & gear_id) -> std::string"""
    return _vsp_g.CreateAndAddBogie(gear_id)

def GetNumBogies(gear_id):
    r"""GetNumBogies(std::string const & gear_id) -> int"""
    return _vsp_g.GetNumBogies(gear_id)

def GetAllBogies(gear_id):
    r"""GetAllBogies(std::string const & gear_id) -> StringVector"""
    return _vsp_g.GetAllBogies(gear_id)

def DelBogie(gear_id, bogie_id):
    r"""DelBogie(std::string const & gear_id, std::string const & bogie_id)"""
    return _vsp_g.DelBogie(gear_id, bogie_id)

def DelAllBogies(gear_id):
    r"""DelAllBogies(std::string const & gear_id)"""
    return _vsp_g.DelAllBogies(gear_id)

def SetAuxiliaryGeomContactPtID(geom_id, index, bogie_id):
    r"""SetAuxiliaryGeomContactPtID(std::string const & geom_id, int index, std::string const & bogie_id)"""
    return _vsp_g.SetAuxiliaryGeomContactPtID(geom_id, index, bogie_id)

def GetAuxiliaryGeomContactPtID(geom_id, index):
    r"""GetAuxiliaryGeomContactPtID(std::string const & geom_id, int index) -> std::string"""
    return _vsp_g.GetAuxiliaryGeomContactPtID(geom_id, index)

def ReadAuxiliaryGeomCCEFile(geom_id, file_name):
    r"""ReadAuxiliaryGeomCCEFile(std::string const & geom_id, std::string const & file_name)"""
    return _vsp_g.ReadAuxiliaryGeomCCEFile(geom_id, file_name)

def InitStackPreset(geom_id, preset):
    r"""InitStackPreset(std::string const & geom_id, int preset)"""
    return _vsp_g.InitStackPreset(geom_id, preset)

def GetNumRoutingPts(routing_id):
    r"""GetNumRoutingPts(std::string const & routing_id) -> int"""
    return _vsp_g.GetNumRoutingPts(routing_id)

def AddRoutingPt(routing_id, geom_id, surf_index):
    r"""AddRoutingPt(std::string const & routing_id, std::string const & geom_id, int surf_index) -> std::string"""
    return _vsp_g.AddRoutingPt(routing_id, geom_id, surf_index)

def InsertRoutingPt(routing_id, index, geom_id, surf_index):
    r"""InsertRoutingPt(std::string const & routing_id, int index, std::string const & geom_id, int surf_index) -> std::string"""
    return _vsp_g.InsertRoutingPt(routing_id, index, geom_id, surf_index)

def DelRoutingPt(routing_id, index):
    r"""DelRoutingPt(std::string const & routing_id, int index)"""
    return _vsp_g.DelRoutingPt(routing_id, index)

def DelAllRoutingPt(routing_id):
    r"""DelAllRoutingPt(std::string const & routing_id)"""
    return _vsp_g.DelAllRoutingPt(routing_id)

def MoveRoutingPt(routing_id, index, reorder_type):
    r"""MoveRoutingPt(std::string const & routing_id, int index, int reorder_type) -> int"""
    return _vsp_g.MoveRoutingPt(routing_id, index, reorder_type)

def GetRoutingPtID(routing_id, index):
    r"""GetRoutingPtID(std::string const & routing_id, int index) -> std::string"""
    return _vsp_g.GetRoutingPtID(routing_id, index)

def GetAllRoutingPtIds(routing_id):
    r"""GetAllRoutingPtIds(std::string const & routing_id) -> StringVector"""
    return _vsp_g.GetAllRoutingPtIds(routing_id)

def GetRoutingPtParentID(pt_id):
    r"""GetRoutingPtParentID(std::string const & pt_id) -> std::string"""
    return _vsp_g.GetRoutingPtParentID(pt_id)

def SetRoutingPtParentID(pt_id, parent_id):
    r"""SetRoutingPtParentID(std::string const & pt_id, std::string const & parent_id)"""
    return _vsp_g.SetRoutingPtParentID(pt_id, parent_id)

def GetMainRoutingPtCoord(pt_id):
    r"""GetMainRoutingPtCoord(std::string const & pt_id) -> vec3d"""
    return _vsp_g.GetMainRoutingPtCoord(pt_id)

def GetRoutingPtCoord(routing_id, index, symm_index):
    r"""GetRoutingPtCoord(std::string const & routing_id, int index, int symm_index) -> vec3d"""
    return _vsp_g.GetRoutingPtCoord(routing_id, index, symm_index)

def GetAllRoutingPtCoords(routing_id, symm_index):
    r"""GetAllRoutingPtCoords(std::string const & routing_id, int symm_index) -> Vec3dVec"""
    return _vsp_g.GetAllRoutingPtCoords(routing_id, symm_index)

def GetRoutingCurve(routing_id, symm_index):
    r"""GetRoutingCurve(std::string const & routing_id, int symm_index) -> Vec3dVec"""
    return _vsp_g.GetRoutingCurve(routing_id, symm_index)

def ChangeBORXSecShape(bor_id, type):
    r"""ChangeBORXSecShape(std::string const & bor_id, int type)"""
    return _vsp_g.ChangeBORXSecShape(bor_id, type)

def GetBORXSecShape(bor_id):
    r"""GetBORXSecShape(std::string const & bor_id) -> int"""
    return _vsp_g.GetBORXSecShape(bor_id)

def ReadBORFileXSec(bor_id, file_name):
    r"""ReadBORFileXSec(std::string const & bor_id, std::string const & file_name) -> Vec3dVec"""
    return _vsp_g.ReadBORFileXSec(bor_id, file_name)

def GetBORXSecPnts(bor_id):
    r"""GetBORXSecPnts(std::string const & bor_id) -> Vec3dVec"""
    return _vsp_g.GetBORXSecPnts(bor_id)

def SetBORXSecPnts(bor_id, pnt_vec):
    r"""SetBORXSecPnts(std::string const & bor_id, Vec3dVec pnt_vec)"""
    return _vsp_g.SetBORXSecPnts(bor_id, pnt_vec)

def ComputeBORXSecPnt(bor_id, fract):
    r"""ComputeBORXSecPnt(std::string const & bor_id, double fract) -> vec3d"""
    return _vsp_g.ComputeBORXSecPnt(bor_id, fract)

def ComputeBORXSecTan(bor_id, fract):
    r"""ComputeBORXSecTan(std::string const & bor_id, double fract) -> vec3d"""
    return _vsp_g.ComputeBORXSecTan(bor_id, fract)

def ReadBORFileAirfoil(bor_id, file_name):
    r"""ReadBORFileAirfoil(std::string const & bor_id, std::string const & file_name)"""
    return _vsp_g.ReadBORFileAirfoil(bor_id, file_name)

def SetBORAirfoilUpperPnts(bor_id, up_pnt_vec):
    r"""SetBORAirfoilUpperPnts(std::string const & bor_id, Vec3dVec up_pnt_vec)"""
    return _vsp_g.SetBORAirfoilUpperPnts(bor_id, up_pnt_vec)

def SetBORAirfoilLowerPnts(bor_id, low_pnt_vec):
    r"""SetBORAirfoilLowerPnts(std::string const & bor_id, Vec3dVec low_pnt_vec)"""
    return _vsp_g.SetBORAirfoilLowerPnts(bor_id, low_pnt_vec)

def SetBORAirfoilPnts(bor_id, up_pnt_vec, low_pnt_vec):
    r"""SetBORAirfoilPnts(std::string const & bor_id, Vec3dVec up_pnt_vec, Vec3dVec low_pnt_vec)"""
    return _vsp_g.SetBORAirfoilPnts(bor_id, up_pnt_vec, low_pnt_vec)

def GetBORAirfoilUpperPnts(bor_id):
    r"""GetBORAirfoilUpperPnts(std::string const & bor_id) -> Vec3dVec"""
    return _vsp_g.GetBORAirfoilUpperPnts(bor_id)

def GetBORAirfoilLowerPnts(bor_id):
    r"""GetBORAirfoilLowerPnts(std::string const & bor_id) -> Vec3dVec"""
    return _vsp_g.GetBORAirfoilLowerPnts(bor_id)

def GetBORUpperCSTCoefs(bor_id):
    r"""GetBORUpperCSTCoefs(std::string const & bor_id) -> DoubleVector"""
    return _vsp_g.GetBORUpperCSTCoefs(bor_id)

def GetBORLowerCSTCoefs(bor_id):
    r"""GetBORLowerCSTCoefs(std::string const & bor_id) -> DoubleVector"""
    return _vsp_g.GetBORLowerCSTCoefs(bor_id)

def GetBORUpperCSTDegree(bor_id):
    r"""GetBORUpperCSTDegree(std::string const & bor_id) -> int"""
    return _vsp_g.GetBORUpperCSTDegree(bor_id)

def GetBORLowerCSTDegree(bor_id):
    r"""GetBORLowerCSTDegree(std::string const & bor_id) -> int"""
    return _vsp_g.GetBORLowerCSTDegree(bor_id)

def SetBORUpperCST(bor_id, deg, coefs):
    r"""SetBORUpperCST(std::string const & bor_id, int deg, DoubleVector coefs)"""
    return _vsp_g.SetBORUpperCST(bor_id, deg, coefs)

def SetBORLowerCST(bor_id, deg, coefs):
    r"""SetBORLowerCST(std::string const & bor_id, int deg, DoubleVector coefs)"""
    return _vsp_g.SetBORLowerCST(bor_id, deg, coefs)

def PromoteBORCSTUpper(bor_id):
    r"""PromoteBORCSTUpper(std::string const & bor_id)"""
    return _vsp_g.PromoteBORCSTUpper(bor_id)

def PromoteBORCSTLower(bor_id):
    r"""PromoteBORCSTLower(std::string const & bor_id)"""
    return _vsp_g.PromoteBORCSTLower(bor_id)

def DemoteBORCSTUpper(bor_id):
    r"""DemoteBORCSTUpper(std::string const & bor_id)"""
    return _vsp_g.DemoteBORCSTUpper(bor_id)

def DemoteBORCSTLower(bor_id):
    r"""DemoteBORCSTLower(std::string const & bor_id)"""
    return _vsp_g.DemoteBORCSTLower(bor_id)

def FitBORAfCST(bor_id, deg):
    r"""FitBORAfCST(std::string const & bor_id, int deg)"""
    return _vsp_g.FitBORAfCST(bor_id, deg)

def WriteBezierAirfoil(file_name, geom_id, foilsurf_u):
    r"""WriteBezierAirfoil(std::string const & file_name, std::string const & geom_id, double const & foilsurf_u)"""
    return _vsp_g.WriteBezierAirfoil(file_name, geom_id, foilsurf_u)

def WriteSeligAirfoil(file_name, geom_id, foilsurf_u):
    r"""WriteSeligAirfoil(std::string const & file_name, std::string const & geom_id, double const & foilsurf_u)"""
    return _vsp_g.WriteSeligAirfoil(file_name, geom_id, foilsurf_u)

def GetAirfoilCoordinates(geom_id, foilsurf_u):
    r"""GetAirfoilCoordinates(std::string const & geom_id, double const & foilsurf_u) -> Vec3dVec"""
    return _vsp_g.GetAirfoilCoordinates(geom_id, foilsurf_u)

def EditXSecInitShape(xsec_id):
    r"""EditXSecInitShape(std::string const & xsec_id)"""
    return _vsp_g.EditXSecInitShape(xsec_id)

def EditXSecConvertTo(xsec_id, newtype):
    r"""EditXSecConvertTo(std::string const & xsec_id, int const & newtype)"""
    return _vsp_g.EditXSecConvertTo(xsec_id, newtype)

def GetEditXSecUVec(xsec_id):
    r"""GetEditXSecUVec(std::string const & xsec_id) -> DoubleVector"""
    return _vsp_g.GetEditXSecUVec(xsec_id)

def GetEditXSecCtrlVec(xsec_id, non_dimensional=True):
    r"""GetEditXSecCtrlVec(std::string const & xsec_id, bool non_dimensional=True) -> Vec3dVec"""
    return _vsp_g.GetEditXSecCtrlVec(xsec_id, non_dimensional)

def SetEditXSecPnts(xsec_id, u_vec, control_pts, r_vec):
    r"""SetEditXSecPnts(std::string const & xsec_id, DoubleVector u_vec, Vec3dVec control_pts, DoubleVector r_vec)"""
    return _vsp_g.SetEditXSecPnts(xsec_id, u_vec, control_pts, r_vec)

def EditXSecDelPnt(xsec_id, indx):
    r"""EditXSecDelPnt(std::string const & xsec_id, int const & indx)"""
    return _vsp_g.EditXSecDelPnt(xsec_id, indx)

def EditXSecSplit01(xsec_id, u):
    r"""EditXSecSplit01(std::string const & xsec_id, double const & u) -> int"""
    return _vsp_g.EditXSecSplit01(xsec_id, u)

def MoveEditXSecPnt(xsec_id, indx, new_pnt):
    r"""MoveEditXSecPnt(std::string const & xsec_id, int const & indx, vec3d new_pnt)"""
    return _vsp_g.MoveEditXSecPnt(xsec_id, indx, new_pnt)

def ConvertXSecToEdit(geom_id, indx=0):
    r"""ConvertXSecToEdit(std::string const & geom_id, int const & indx=0)"""
    return _vsp_g.ConvertXSecToEdit(geom_id, indx)

def GetEditXSecFixedUVec(xsec_id):
    r"""GetEditXSecFixedUVec(std::string const & xsec_id) -> BoolVector"""
    return _vsp_g.GetEditXSecFixedUVec(xsec_id)

def SetEditXSecFixedUVec(xsec_id, fixed_u_vec):
    r"""SetEditXSecFixedUVec(std::string const & xsec_id, BoolVector fixed_u_vec)"""
    return _vsp_g.SetEditXSecFixedUVec(xsec_id, fixed_u_vec)

def ReparameterizeEditXSec(xsec_id):
    r"""ReparameterizeEditXSec(std::string const & xsec_id)"""
    return _vsp_g.ReparameterizeEditXSec(xsec_id)

def GetNumSets():
    r"""GetNumSets() -> int"""
    return _vsp_g.GetNumSets()

def SetSetName(index, name):
    r"""SetSetName(int index, std::string const & name)"""
    return _vsp_g.SetSetName(index, name)

def GetSetName(index):
    r"""GetSetName(int index) -> std::string"""
    return _vsp_g.GetSetName(index)

def GetGeomSetAtIndex(index):
    r"""GetGeomSetAtIndex(int index) -> StringVector"""
    return _vsp_g.GetGeomSetAtIndex(index)

def GetGeomSet(name):
    r"""GetGeomSet(std::string const & name) -> StringVector"""
    return _vsp_g.GetGeomSet(name)

def GetSetIndex(name):
    r"""GetSetIndex(std::string const & name) -> int"""
    return _vsp_g.GetSetIndex(name)

def GetSetFlag(geom_id, set_index):
    r"""GetSetFlag(std::string const & geom_id, int set_index) -> bool"""
    return _vsp_g.GetSetFlag(geom_id, set_index)

def SetSetFlag(geom_id, set_index, flag):
    r"""SetSetFlag(std::string const & geom_id, int set_index, bool flag)"""
    return _vsp_g.SetSetFlag(geom_id, set_index, flag)

def CopyPasteSet(copyIndex, pasteIndex):
    r"""CopyPasteSet(int copyIndex, int pasteIndex)"""
    return _vsp_g.CopyPasteSet(copyIndex, pasteIndex)

def GetBBoxSet(set):
    r"""GetBBoxSet(int set) -> bool"""
    return _vsp_g.GetBBoxSet(set)

def GetScaleIndependentBBoxSet(set):
    r"""GetScaleIndependentBBoxSet(int set) -> bool"""
    return _vsp_g.GetScaleIndependentBBoxSet(set)

def ScaleSet(set_index, scale):
    r"""ScaleSet(int set_index, double scale)"""
    return _vsp_g.ScaleSet(set_index, scale)

def RotateSet(set_index, x_rot_deg, y_rot_deg, z_rot_deg):
    r"""RotateSet(int set_index, double x_rot_deg, double y_rot_deg, double z_rot_deg)"""
    return _vsp_g.RotateSet(set_index, x_rot_deg, y_rot_deg, z_rot_deg)

def TranslateSet(set_index, translation_vec):
    r"""TranslateSet(int set_index, vec3d translation_vec)"""
    return _vsp_g.TranslateSet(set_index, translation_vec)

def TransformSet(set_index, translation_vec, x_rot_deg, y_rot_deg, z_rot_deg, scale, scale_translations_flag):
    r"""TransformSet(int set_index, vec3d translation_vec, double x_rot_deg, double y_rot_deg, double z_rot_deg, double scale, bool scale_translations_flag)"""
    return _vsp_g.TransformSet(set_index, translation_vec, x_rot_deg, y_rot_deg, z_rot_deg, scale, scale_translations_flag)

def ValidParm(id):
    r"""ValidParm(std::string const & id) -> bool"""
    return _vsp_g.ValidParm(id)

def SetParmVal(*args):
    r"""
    SetParmVal(std::string const & parm_id, double val) -> double
    SetParmVal(std::string const & geom_id, std::string const & name, std::string const & group, double val) -> double
    """
    return _vsp_g.SetParmVal(*args)

def SetParmValLimits(parm_id, val, lower_limit, upper_limit):
    r"""SetParmValLimits(std::string const & parm_id, double val, double lower_limit, double upper_limit) -> double"""
    return _vsp_g.SetParmValLimits(parm_id, val, lower_limit, upper_limit)

def SetParmValUpdate(*args):
    r"""
    SetParmValUpdate(std::string const & parm_id, double val) -> double
    SetParmValUpdate(std::string const & geom_id, std::string const & parm_name, std::string const & parm_group_name, double val) -> double
    """
    return _vsp_g.SetParmValUpdate(*args)

def GetParmVal(*args):
    r"""
    GetParmVal(std::string const & parm_id) -> double
    GetParmVal(std::string const & geom_id, std::string const & name, std::string const & group) -> double
    """
    return _vsp_g.GetParmVal(*args)

def GetIntParmVal(parm_id):
    r"""GetIntParmVal(std::string const & parm_id) -> int"""
    return _vsp_g.GetIntParmVal(parm_id)

def GetBoolParmVal(parm_id):
    r"""GetBoolParmVal(std::string const & parm_id) -> bool"""
    return _vsp_g.GetBoolParmVal(parm_id)

def SetParmUpperLimit(parm_id, val):
    r"""SetParmUpperLimit(std::string const & parm_id, double val)"""
    return _vsp_g.SetParmUpperLimit(parm_id, val)

def GetParmUpperLimit(parm_id):
    r"""GetParmUpperLimit(std::string const & parm_id) -> double"""
    return _vsp_g.GetParmUpperLimit(parm_id)

def SetParmLowerLimit(parm_id, val):
    r"""SetParmLowerLimit(std::string const & parm_id, double val)"""
    return _vsp_g.SetParmLowerLimit(parm_id, val)

def GetParmLowerLimit(parm_id):
    r"""GetParmLowerLimit(std::string const & parm_id) -> double"""
    return _vsp_g.GetParmLowerLimit(parm_id)

def GetParmType(parm_id):
    r"""GetParmType(std::string const & parm_id) -> int"""
    return _vsp_g.GetParmType(parm_id)

def GetParmName(parm_id):
    r"""GetParmName(std::string const & parm_id) -> std::string"""
    return _vsp_g.GetParmName(parm_id)

def GetParmGroupName(parm_id):
    r"""GetParmGroupName(std::string const & parm_id) -> std::string"""
    return _vsp_g.GetParmGroupName(parm_id)

def GetParmDisplayGroupName(parm_id):
    r"""GetParmDisplayGroupName(std::string const & parm_id) -> std::string"""
    return _vsp_g.GetParmDisplayGroupName(parm_id)

def GetParmContainer(parm_id):
    r"""GetParmContainer(std::string const & parm_id) -> std::string"""
    return _vsp_g.GetParmContainer(parm_id)

def SetParmDescript(parm_id, desc):
    r"""SetParmDescript(std::string const & parm_id, std::string const & desc)"""
    return _vsp_g.SetParmDescript(parm_id, desc)

def GetParmDescript(parm_id):
    r"""GetParmDescript(std::string const & parm_id) -> std::string"""
    return _vsp_g.GetParmDescript(parm_id)

def FindParm(parm_container_id, parm_name, group_name):
    r"""FindParm(std::string const & parm_container_id, std::string const & parm_name, std::string const & group_name) -> std::string"""
    return _vsp_g.FindParm(parm_container_id, parm_name, group_name)

def FindContainers():
    r"""FindContainers() -> StringVector"""
    return _vsp_g.FindContainers()

def FindContainersWithName(name):
    r"""FindContainersWithName(std::string const & name) -> StringVector"""
    return _vsp_g.FindContainersWithName(name)

def FindContainer(name, index):
    r"""FindContainer(std::string const & name, int index) -> std::string"""
    return _vsp_g.FindContainer(name, index)

def SetContainerName(parm_container_id, name):
    r"""SetContainerName(std::string const & parm_container_id, std::string const & name)"""
    return _vsp_g.SetContainerName(parm_container_id, name)

def GetContainerName(parm_container_id):
    r"""GetContainerName(std::string const & parm_container_id) -> std::string"""
    return _vsp_g.GetContainerName(parm_container_id)

def FindContainerGroupNames(parm_container_id):
    r"""FindContainerGroupNames(std::string const & parm_container_id) -> StringVector"""
    return _vsp_g.FindContainerGroupNames(parm_container_id)

def FindContainerParmIDs(parm_container_id):
    r"""FindContainerParmIDs(std::string const & parm_container_id) -> StringVector"""
    return _vsp_g.FindContainerParmIDs(parm_container_id)

def GetVehicleID():
    r"""GetVehicleID() -> std::string"""
    return _vsp_g.GetVehicleID()

def GetNumUserParms():
    r"""GetNumUserParms() -> int"""
    return _vsp_g.GetNumUserParms()

def GetNumPredefinedUserParms():
    r"""GetNumPredefinedUserParms() -> int"""
    return _vsp_g.GetNumPredefinedUserParms()

def GetAllUserParms():
    r"""GetAllUserParms() -> StringVector"""
    return _vsp_g.GetAllUserParms()

def GetUserParmContainer():
    r"""GetUserParmContainer() -> std::string"""
    return _vsp_g.GetUserParmContainer()

def AddUserParm(type, name, group):
    r"""AddUserParm(int type, std::string const & name, std::string const & group) -> std::string"""
    return _vsp_g.AddUserParm(type, name, group)

def DeleteUserParm(id):
    r"""DeleteUserParm(std::string const & id)"""
    return _vsp_g.DeleteUserParm(id)

def DeleteAllUserParm():
    r"""DeleteAllUserParm()"""
    return _vsp_g.DeleteAllUserParm()

def ComputeMinClearanceDistance(*args):
    r"""ComputeMinClearanceDistance(std::string const & geom_id, int set=SET_ALL, bool useMode=False, std::string const & modeID=std::string()) -> double"""
    return _vsp_g.ComputeMinClearanceDistance(*args)

def SnapParm(*args):
    r"""SnapParm(std::string const & parm_id, double target_min_dist, bool inc_flag, int set=SET_ALL, bool useMode=False, std::string const & modeID=std::string()) -> double"""
    return _vsp_g.SnapParm(*args)

def AddVarPresetGroup(group_name):
    r"""AddVarPresetGroup(std::string const & group_name) -> std::string"""
    return _vsp_g.AddVarPresetGroup(group_name)

def AddVarPresetSetting(group_id, setting_name):
    r"""AddVarPresetSetting(std::string const & group_id, std::string const & setting_name) -> std::string"""
    return _vsp_g.AddVarPresetSetting(group_id, setting_name)

def AddVarPresetParm(group_id, parm_id):
    r"""AddVarPresetParm(std::string const & group_id, std::string const & parm_id)"""
    return _vsp_g.AddVarPresetParm(group_id, parm_id)

def DeleteAllVarPresetGroups():
    r"""DeleteAllVarPresetGroups()"""
    return _vsp_g.DeleteAllVarPresetGroups()

def DeleteVarPresetGroup(group_id):
    r"""DeleteVarPresetGroup(std::string const & group_id)"""
    return _vsp_g.DeleteVarPresetGroup(group_id)

def DeleteAllVarPresetSettings(group_id):
    r"""DeleteAllVarPresetSettings(std::string const & group_id)"""
    return _vsp_g.DeleteAllVarPresetSettings(group_id)

def DeleteVarPresetSetting(group_id, setting_id):
    r"""DeleteVarPresetSetting(std::string const & group_id, std::string const & setting_id)"""
    return _vsp_g.DeleteVarPresetSetting(group_id, setting_id)

def DeleteVarPresetParm(group_id, parm_id):
    r"""DeleteVarPresetParm(std::string const & group_id, std::string const & parm_id)"""
    return _vsp_g.DeleteVarPresetParm(group_id, parm_id)

def SetVarPresetParmVal(group_id, setting_id, parm_id, parm_val):
    r"""SetVarPresetParmVal(std::string const & group_id, std::string const & setting_id, std::string const & parm_id, double parm_val)"""
    return _vsp_g.SetVarPresetParmVal(group_id, setting_id, parm_id, parm_val)

def GetVarPresetParmVal(group_id, setting_id, parm_id):
    r"""GetVarPresetParmVal(std::string const & group_id, std::string const & setting_id, std::string const & parm_id) -> double"""
    return _vsp_g.GetVarPresetParmVal(group_id, setting_id, parm_id)

def GetGroupName(group_id):
    r"""GetGroupName(std::string const & group_id) -> std::string"""
    return _vsp_g.GetGroupName(group_id)

def GetSettingName(setting_id):
    r"""GetSettingName(std::string const & setting_id) -> std::string"""
    return _vsp_g.GetSettingName(setting_id)

def SetGroupName(group_id, group_name):
    r"""SetGroupName(std::string const & group_id, std::string const & group_name)"""
    return _vsp_g.SetGroupName(group_id, group_name)

def SetSettingName(setting_id, setting_name):
    r"""SetSettingName(std::string const & setting_id, std::string const & setting_name)"""
    return _vsp_g.SetSettingName(setting_id, setting_name)

def GetVarPresetGroups():
    r"""GetVarPresetGroups() -> StringVector"""
    return _vsp_g.GetVarPresetGroups()

def GetVarPresetSettings(group_id):
    r"""GetVarPresetSettings(std::string const & group_id) -> StringVector"""
    return _vsp_g.GetVarPresetSettings(group_id)

def GetVarPresetParmIDs(group_id):
    r"""GetVarPresetParmIDs(std::string const & group_id) -> StringVector"""
    return _vsp_g.GetVarPresetParmIDs(group_id)

def GetVarPresetParmVals(setting_id):
    r"""GetVarPresetParmVals(std::string const & setting_id) -> DoubleVector"""
    return _vsp_g.GetVarPresetParmVals(setting_id)

def SetVarPresetParmVals(setting_id, parm_vals):
    r"""SetVarPresetParmVals(std::string const & setting_id, DoubleVector parm_vals)"""
    return _vsp_g.SetVarPresetParmVals(setting_id, parm_vals)

def SaveVarPresetParmVals(group_id, setting_id):
    r"""SaveVarPresetParmVals(std::string const & group_id, std::string const & setting_id)"""
    return _vsp_g.SaveVarPresetParmVals(group_id, setting_id)

def ApplyVarPresetSetting(group_id, setting_id):
    r"""ApplyVarPresetSetting(std::string const & group_id, std::string const & setting_id)"""
    return _vsp_g.ApplyVarPresetSetting(group_id, setting_id)

def CreateAndAddMode(name, normal_set, degen_set):
    r"""CreateAndAddMode(std::string const & name, int normal_set, int degen_set) -> std::string"""
    return _vsp_g.CreateAndAddMode(name, normal_set, degen_set)

def GetNumModes():
    r"""GetNumModes() -> int"""
    return _vsp_g.GetNumModes()

def GetAllModes():
    r"""GetAllModes() -> StringVector"""
    return _vsp_g.GetAllModes()

def DelMode(mid):
    r"""DelMode(std::string const & mid)"""
    return _vsp_g.DelMode(mid)

def DelAllModes():
    r"""DelAllModes()"""
    return _vsp_g.DelAllModes()

def GetModeName(mid):
    r"""GetModeName(std::string const & mid) -> std::string"""
    return _vsp_g.GetModeName(mid)

def SetModeName(mid, name):
    r"""SetModeName(std::string const & mid, std::string const & name)"""
    return _vsp_g.SetModeName(mid, name)

def ApplyModeSettings(mid):
    r"""ApplyModeSettings(std::string const & mid)"""
    return _vsp_g.ApplyModeSettings(mid)

def ShowOnlyMode(mid):
    r"""ShowOnlyMode(std::string const & mid)"""
    return _vsp_g.ShowOnlyMode(mid)

def ModeAddGroupSetting(mid, gid, sid):
    r"""ModeAddGroupSetting(std::string const & mid, std::string const & gid, std::string const & sid)"""
    return _vsp_g.ModeAddGroupSetting(mid, gid, sid)

def ModeGetGroup(mid, indx):
    r"""ModeGetGroup(std::string const & mid, int indx) -> std::string"""
    return _vsp_g.ModeGetGroup(mid, indx)

def ModeGetSetting(mid, indx):
    r"""ModeGetSetting(std::string const & mid, int indx) -> std::string"""
    return _vsp_g.ModeGetSetting(mid, indx)

def ModeGetAllGroups(mid):
    r"""ModeGetAllGroups(std::string const & mid) -> StringVector"""
    return _vsp_g.ModeGetAllGroups(mid)

def ModeGetAllSettings(mid):
    r"""ModeGetAllSettings(std::string const & mid) -> StringVector"""
    return _vsp_g.ModeGetAllSettings(mid)

def RemoveGroupSetting(mid, indx):
    r"""RemoveGroupSetting(std::string const & mid, int indx)"""
    return _vsp_g.RemoveGroupSetting(mid, indx)

def RemoveAllGroupSettings(mid):
    r"""RemoveAllGroupSettings(std::string const & mid)"""
    return _vsp_g.RemoveAllGroupSettings(mid)

def SetPCurve(geom_id, pcurveid, tvec, valvec, newtype):
    r"""SetPCurve(std::string const & geom_id, int const & pcurveid, DoubleVector tvec, DoubleVector valvec, int const & newtype)"""
    return _vsp_g.SetPCurve(geom_id, pcurveid, tvec, valvec, newtype)

def PCurveConvertTo(geom_id, pcurveid, newtype):
    r"""PCurveConvertTo(std::string const & geom_id, int const & pcurveid, int const & newtype)"""
    return _vsp_g.PCurveConvertTo(geom_id, pcurveid, newtype)

def PCurveGetType(geom_id, pcurveid):
    r"""PCurveGetType(std::string const & geom_id, int const & pcurveid) -> int"""
    return _vsp_g.PCurveGetType(geom_id, pcurveid)

def PCurveGetTVec(geom_id, pcurveid):
    r"""PCurveGetTVec(std::string const & geom_id, int const & pcurveid) -> DoubleVector"""
    return _vsp_g.PCurveGetTVec(geom_id, pcurveid)

def PCurveGetValVec(geom_id, pcurveid):
    r"""PCurveGetValVec(std::string const & geom_id, int const & pcurveid) -> DoubleVector"""
    return _vsp_g.PCurveGetValVec(geom_id, pcurveid)

def PCurveDeletePt(geom_id, pcurveid, indx):
    r"""PCurveDeletePt(std::string const & geom_id, int const & pcurveid, int const & indx)"""
    return _vsp_g.PCurveDeletePt(geom_id, pcurveid, indx)

def PCurveSplit(geom_id, pcurveid, tsplit):
    r"""PCurveSplit(std::string const & geom_id, int const & pcurveid, double const & tsplit) -> int"""
    return _vsp_g.PCurveSplit(geom_id, pcurveid, tsplit)

def ApproximateAllPropellerPCurves(geom_id):
    r"""ApproximateAllPropellerPCurves(std::string const & geom_id)"""
    return _vsp_g.ApproximateAllPropellerPCurves(geom_id)

def ResetPropellerThickness(geom_id):
    r"""ResetPropellerThickness(std::string const & geom_id)"""
    return _vsp_g.ResetPropellerThickness(geom_id)

def ResetPropellerThicknessCurve(geom_id):
    r"""ResetPropellerThicknessCurve(std::string const & geom_id)"""
    return _vsp_g.ResetPropellerThicknessCurve(geom_id)

def AutoGroupVSPAEROControlSurfaces():
    r"""AutoGroupVSPAEROControlSurfaces()"""
    return _vsp_g.AutoGroupVSPAEROControlSurfaces()

def AddCpSlice(cut_type, location):
    r"""AddCpSlice(int cut_type, double location) -> std::string"""
    return _vsp_g.AddCpSlice(cut_type, location)

def GetNumCpSlices():
    r"""GetNumCpSlices() -> int"""
    return _vsp_g.GetNumCpSlices()

def GetCpSliceID(slice_index):
    r"""GetCpSliceID(int slice_index) -> std::string"""
    return _vsp_g.GetCpSliceID(slice_index)

def DelCpSlice(slice_index):
    r"""DelCpSlice(int slice_index)"""
    return _vsp_g.DelCpSlice(slice_index)

def DeleteAllCpSlices():
    r"""DeleteAllCpSlices()"""
    return _vsp_g.DeleteAllCpSlices()

def DeleteVSPAEROControlSurfaceGroup(CSGroupIndex):
    r"""DeleteVSPAEROControlSurfaceGroup(int CSGroupIndex)"""
    return _vsp_g.DeleteVSPAEROControlSurfaceGroup(CSGroupIndex)

def CreateVSPAEROControlSurfaceGroup():
    r"""CreateVSPAEROControlSurfaceGroup() -> int"""
    return _vsp_g.CreateVSPAEROControlSurfaceGroup()

def AddAllToVSPAEROControlSurfaceGroup(CSGroupIndex):
    r"""AddAllToVSPAEROControlSurfaceGroup(int CSGroupIndex)"""
    return _vsp_g.AddAllToVSPAEROControlSurfaceGroup(CSGroupIndex)

def RemoveAllFromVSPAEROControlSurfaceGroup(CSGroupIndex):
    r"""RemoveAllFromVSPAEROControlSurfaceGroup(int CSGroupIndex)"""
    return _vsp_g.RemoveAllFromVSPAEROControlSurfaceGroup(CSGroupIndex)

def GetActiveCSNameVec(CSGroupIndex):
    r"""GetActiveCSNameVec(int CSGroupIndex) -> StringVector"""
    return _vsp_g.GetActiveCSNameVec(CSGroupIndex)

def GetCompleteCSNameVec():
    r"""GetCompleteCSNameVec() -> StringVector"""
    return _vsp_g.GetCompleteCSNameVec()

def GetAvailableCSNameVec(CSGroupIndex):
    r"""GetAvailableCSNameVec(int CSGroupIndex) -> StringVector"""
    return _vsp_g.GetAvailableCSNameVec(CSGroupIndex)

def SetVSPAEROControlGroupName(name, CSGroupIndex):
    r"""SetVSPAEROControlGroupName(std::string const & name, int CSGroupIndex)"""
    return _vsp_g.SetVSPAEROControlGroupName(name, CSGroupIndex)

def GetVSPAEROControlGroupName(CSGroupIndex):
    r"""GetVSPAEROControlGroupName(int CSGroupIndex) -> std::string"""
    return _vsp_g.GetVSPAEROControlGroupName(CSGroupIndex)

def AddSelectedToCSGroup(selected, CSGroupIndex):
    r"""AddSelectedToCSGroup(IntVector selected, int CSGroupIndex)"""
    return _vsp_g.AddSelectedToCSGroup(selected, CSGroupIndex)

def RemoveSelectedFromCSGroup(selected, CSGroupIndex):
    r"""RemoveSelectedFromCSGroup(IntVector selected, int CSGroupIndex)"""
    return _vsp_g.RemoveSelectedFromCSGroup(selected, CSGroupIndex)

def GetNumControlSurfaceGroups():
    r"""GetNumControlSurfaceGroups() -> int"""
    return _vsp_g.GetNumControlSurfaceGroups()

def FindActuatorDisk(disk_index):
    r"""FindActuatorDisk(int disk_index) -> std::string"""
    return _vsp_g.FindActuatorDisk(disk_index)

def GetNumActuatorDisks():
    r"""GetNumActuatorDisks() -> int"""
    return _vsp_g.GetNumActuatorDisks()

def FindUnsteadyGroup(group_index):
    r"""FindUnsteadyGroup(int group_index) -> std::string"""
    return _vsp_g.FindUnsteadyGroup(group_index)

def GetUnsteadyGroupName(group_index):
    r"""GetUnsteadyGroupName(int group_index) -> std::string"""
    return _vsp_g.GetUnsteadyGroupName(group_index)

def GetUnsteadyGroupCompIDs(group_index):
    r"""GetUnsteadyGroupCompIDs(int group_index) -> StringVector"""
    return _vsp_g.GetUnsteadyGroupCompIDs(group_index)

def GetUnsteadyGroupSurfIndexes(group_index):
    r"""GetUnsteadyGroupSurfIndexes(int group_index) -> IntVector"""
    return _vsp_g.GetUnsteadyGroupSurfIndexes(group_index)

def GetNumUnsteadyGroups():
    r"""GetNumUnsteadyGroups() -> int"""
    return _vsp_g.GetNumUnsteadyGroups()

def GetNumUnsteadyRotorGroups():
    r"""GetNumUnsteadyRotorGroups() -> int"""
    return _vsp_g.GetNumUnsteadyRotorGroups()

def AddExcrescence(excresName, excresType, excresVal):
    r"""AddExcrescence(std::string const & excresName, int const & excresType, double const & excresVal)"""
    return _vsp_g.AddExcrescence(excresName, excresType, excresVal)

def GetNumExcrescences():
    r"""GetNumExcrescences() -> int"""
    return _vsp_g.GetNumExcrescences()

def DeleteAllExcrescences():
    r"""DeleteAllExcrescences()"""
    return _vsp_g.DeleteAllExcrescences()

def DeleteExcrescence(index):
    r"""DeleteExcrescence(int const & index)"""
    return _vsp_g.DeleteExcrescence(index)

def UpdateParasiteDrag():
    r"""UpdateParasiteDrag()"""
    return _vsp_g.UpdateParasiteDrag()

def ExportParasiteDragToCSV(file_name):
    r"""ExportParasiteDragToCSV(std::string const & file_name) -> std::string"""
    return _vsp_g.ExportParasiteDragToCSV(file_name)

def WriteAtmosphereCSVFile(file_name, atmos_type):
    r"""WriteAtmosphereCSVFile(std::string const & file_name, int const & atmos_type)"""
    return _vsp_g.WriteAtmosphereCSVFile(file_name, atmos_type)

def CalcAtmosphere(alt, delta_temp, atmos_type):
    r"""CalcAtmosphere(double const & alt, double const & delta_temp, int const & atmos_type)"""
    return _vsp_g.CalcAtmosphere(alt, delta_temp, atmos_type)

def WriteBodyFFCSVFile(file_name):
    r"""WriteBodyFFCSVFile(std::string const & file_name)"""
    return _vsp_g.WriteBodyFFCSVFile(file_name)

def WriteWingFFCSVFile(file_name):
    r"""WriteWingFFCSVFile(std::string const & file_name)"""
    return _vsp_g.WriteWingFFCSVFile(file_name)

def WriteCfEqnCSVFile(file_name):
    r"""WriteCfEqnCSVFile(std::string const & file_name)"""
    return _vsp_g.WriteCfEqnCSVFile(file_name)

def WritePartialCfMethodCSVFile(file_name):
    r"""WritePartialCfMethodCSVFile(std::string const & file_name)"""
    return _vsp_g.WritePartialCfMethodCSVFile(file_name)

def CompPnt01(geom_id, surf_indx, u, w):
    r"""CompPnt01(std::string const & geom_id, int const & surf_indx, double const & u, double const & w) -> vec3d"""
    return _vsp_g.CompPnt01(geom_id, surf_indx, u, w)

def CompNorm01(geom_id, surf_indx, u, w):
    r"""CompNorm01(std::string const & geom_id, int const & surf_indx, double const & u, double const & w) -> vec3d"""
    return _vsp_g.CompNorm01(geom_id, surf_indx, u, w)

def CompTanU01(geom_id, surf_indx, u, w):
    r"""CompTanU01(std::string const & geom_id, int const & surf_indx, double const & u, double const & w) -> vec3d"""
    return _vsp_g.CompTanU01(geom_id, surf_indx, u, w)

def CompTanW01(geom_id, surf_indx, u, w):
    r"""CompTanW01(std::string const & geom_id, int const & surf_indx, double const & u, double const & w) -> vec3d"""
    return _vsp_g.CompTanW01(geom_id, surf_indx, u, w)

def CompCurvature01(geom_id, surf_indx, u, w):
    r"""CompCurvature01(std::string const & geom_id, int const & surf_indx, double const & u, double const & w)"""
    return _vsp_g.CompCurvature01(geom_id, surf_indx, u, w)

def ProjPnt01(geom_id, surf_indx, pt):
    r"""ProjPnt01(std::string const & geom_id, int const & surf_indx, vec3d pt) -> double"""
    return _vsp_g.ProjPnt01(geom_id, surf_indx, pt)

def ProjPnt01I(geom_id, pt):
    r"""ProjPnt01I(std::string const & geom_id, vec3d pt) -> double"""
    return _vsp_g.ProjPnt01I(geom_id, pt)

def ProjPnt01Guess(geom_id, surf_indx, pt, u0, w0):
    r"""ProjPnt01Guess(std::string const & geom_id, int const & surf_indx, vec3d pt, double const & u0, double const & w0) -> double"""
    return _vsp_g.ProjPnt01Guess(geom_id, surf_indx, pt, u0, w0)

def AxisProjPnt01(geom_id, surf_indx, iaxis, pt):
    r"""AxisProjPnt01(std::string const & geom_id, int const & surf_indx, int const & iaxis, vec3d pt) -> double"""
    return _vsp_g.AxisProjPnt01(geom_id, surf_indx, iaxis, pt)

def AxisProjPnt01I(geom_id, iaxis, pt):
    r"""AxisProjPnt01I(std::string const & geom_id, int const & iaxis, vec3d pt) -> double"""
    return _vsp_g.AxisProjPnt01I(geom_id, iaxis, pt)

def AxisProjPnt01Guess(geom_id, surf_indx, iaxis, pt, u0, w0):
    r"""AxisProjPnt01Guess(std::string const & geom_id, int const & surf_indx, int const & iaxis, vec3d pt, double const & u0, double const & w0) -> double"""
    return _vsp_g.AxisProjPnt01Guess(geom_id, surf_indx, iaxis, pt, u0, w0)

def InsideSurf(geom_id, surf_indx, pt):
    r"""InsideSurf(std::string const & geom_id, int const & surf_indx, vec3d pt) -> bool"""
    return _vsp_g.InsideSurf(geom_id, surf_indx, pt)

def CompPntRST(geom_id, surf_indx, r, s, t):
    r"""CompPntRST(std::string const & geom_id, int const & surf_indx, double const & r, double const & s, double const & t) -> vec3d"""
    return _vsp_g.CompPntRST(geom_id, surf_indx, r, s, t)

def FindRST(geom_id, surf_indx, pt):
    r"""FindRST(std::string const & geom_id, int const & surf_indx, vec3d pt) -> double"""
    return _vsp_g.FindRST(geom_id, surf_indx, pt)

def FindRSTGuess(geom_id, surf_indx, pt, r0, s0, t0):
    r"""FindRSTGuess(std::string const & geom_id, int const & surf_indx, vec3d pt, double const & r0, double const & s0, double const & t0) -> double"""
    return _vsp_g.FindRSTGuess(geom_id, surf_indx, pt, r0, s0, t0)

def ConvertRSTtoLMN(geom_id, surf_indx, r, s, t):
    r"""ConvertRSTtoLMN(std::string const & geom_id, int const & surf_indx, double const & r, double const & s, double const & t)"""
    return _vsp_g.ConvertRSTtoLMN(geom_id, surf_indx, r, s, t)

def ConvertRtoL(geom_id, surf_indx, r):
    r"""ConvertRtoL(std::string const & geom_id, int const & surf_indx, double const & r)"""
    return _vsp_g.ConvertRtoL(geom_id, surf_indx, r)

def ConvertLMNtoRST(geom_id, surf_indx, l, m, n):
    r"""ConvertLMNtoRST(std::string const & geom_id, int const & surf_indx, double const & l, double const & m, double const & n)"""
    return _vsp_g.ConvertLMNtoRST(geom_id, surf_indx, l, m, n)

def ConvertLtoR(geom_id, surf_indx, l):
    r"""ConvertLtoR(std::string const & geom_id, int const & surf_indx, double const & l)"""
    return _vsp_g.ConvertLtoR(geom_id, surf_indx, l)

def ConvertUtoEta(geom_id, u):
    r"""ConvertUtoEta(std::string const & geom_id, double const & u)"""
    return _vsp_g.ConvertUtoEta(geom_id, u)

def ConvertEtatoU(geom_id, eta):
    r"""ConvertEtatoU(std::string const & geom_id, double const & eta)"""
    return _vsp_g.ConvertEtatoU(geom_id, eta)

def CompVecPnt01(geom_id, surf_indx, u_in_vec, w_in_vec):
    r"""CompVecPnt01(std::string const & geom_id, int const & surf_indx, DoubleVector u_in_vec, DoubleVector w_in_vec) -> Vec3dVec"""
    return _vsp_g.CompVecPnt01(geom_id, surf_indx, u_in_vec, w_in_vec)

def CompVecDegenPnt01(geom_id, surf_indx, degen_type, u_in_vec, w_in_vec):
    r"""CompVecDegenPnt01(std::string const & geom_id, int const & surf_indx, int const & degen_type, DoubleVector u_in_vec, DoubleVector w_in_vec) -> Vec3dVec"""
    return _vsp_g.CompVecDegenPnt01(geom_id, surf_indx, degen_type, u_in_vec, w_in_vec)

def CompVecNorm01(geom_id, surf_indx, us, ws):
    r"""CompVecNorm01(std::string const & geom_id, int const & surf_indx, DoubleVector us, DoubleVector ws) -> Vec3dVec"""
    return _vsp_g.CompVecNorm01(geom_id, surf_indx, us, ws)

def CompVecCurvature01(geom_id, surf_indx, us, ws):
    r"""CompVecCurvature01(std::string const & geom_id, int const & surf_indx, DoubleVector us, DoubleVector ws)"""
    return _vsp_g.CompVecCurvature01(geom_id, surf_indx, us, ws)

def ProjVecPnt01(geom_id, surf_indx, pts):
    r"""ProjVecPnt01(std::string const & geom_id, int const & surf_indx, Vec3dVec pts)"""
    return _vsp_g.ProjVecPnt01(geom_id, surf_indx, pts)

def ProjVecPnt01Guess(geom_id, surf_indx, pts, u0s, w0s):
    r"""ProjVecPnt01Guess(std::string const & geom_id, int const & surf_indx, Vec3dVec pts, DoubleVector u0s, DoubleVector w0s)"""
    return _vsp_g.ProjVecPnt01Guess(geom_id, surf_indx, pts, u0s, w0s)

def AxisProjVecPnt01(geom_id, surf_indx, iaxis, pts):
    r"""AxisProjVecPnt01(std::string const & geom_id, int const & surf_indx, int const & iaxis, Vec3dVec pts)"""
    return _vsp_g.AxisProjVecPnt01(geom_id, surf_indx, iaxis, pts)

def AxisProjVecPnt01Guess(geom_id, surf_indx, iaxis, pts, u0s, w0s):
    r"""AxisProjVecPnt01Guess(std::string const & geom_id, int const & surf_indx, int const & iaxis, Vec3dVec pts, DoubleVector u0s, DoubleVector w0s)"""
    return _vsp_g.AxisProjVecPnt01Guess(geom_id, surf_indx, iaxis, pts, u0s, w0s)

def VecInsideSurf(geom_id, surf_indx, pts):
    r"""VecInsideSurf(std::string const & geom_id, int const & surf_indx, Vec3dVec pts) -> BoolVector"""
    return _vsp_g.VecInsideSurf(geom_id, surf_indx, pts)

def CompVecPntRST(geom_id, surf_indx, r_in_vec, s_in_vec, t_in_vec):
    r"""CompVecPntRST(std::string const & geom_id, int const & surf_indx, DoubleVector r_in_vec, DoubleVector s_in_vec, DoubleVector t_in_vec) -> Vec3dVec"""
    return _vsp_g.CompVecPntRST(geom_id, surf_indx, r_in_vec, s_in_vec, t_in_vec)

def FindRSTVec(geom_id, surf_indx, pts):
    r"""FindRSTVec(std::string const & geom_id, int const & surf_indx, Vec3dVec pts)"""
    return _vsp_g.FindRSTVec(geom_id, surf_indx, pts)

def FindRSTVecGuess(geom_id, surf_indx, pts, r0s, s0s, t0s):
    r"""FindRSTVecGuess(std::string const & geom_id, int const & surf_indx, Vec3dVec pts, DoubleVector r0s, DoubleVector s0s, DoubleVector t0s)"""
    return _vsp_g.FindRSTVecGuess(geom_id, surf_indx, pts, r0s, s0s, t0s)

def ConvertRSTtoLMNVec(geom_id, surf_indx, r_vec, s_vec, t_vec):
    r"""ConvertRSTtoLMNVec(std::string const & geom_id, int const & surf_indx, DoubleVector r_vec, DoubleVector s_vec, DoubleVector t_vec)"""
    return _vsp_g.ConvertRSTtoLMNVec(geom_id, surf_indx, r_vec, s_vec, t_vec)

def ConvertLMNtoRSTVec(geom_id, surf_indx, l_vec, m_vec, n_vec):
    r"""ConvertLMNtoRSTVec(std::string const & geom_id, int const & surf_indx, DoubleVector l_vec, DoubleVector m_vec, DoubleVector n_vec)"""
    return _vsp_g.ConvertLMNtoRSTVec(geom_id, surf_indx, l_vec, m_vec, n_vec)

def GetUWTess01(geom_id, surf_indx):
    r"""GetUWTess01(std::string const & geom_id, int const & surf_indx)"""
    return _vsp_g.GetUWTess01(geom_id, surf_indx)

def ShowAllRulers():
    r"""ShowAllRulers()"""
    return _vsp_g.ShowAllRulers()

def HideAllRulers():
    r"""HideAllRulers()"""
    return _vsp_g.HideAllRulers()

def ShowAllProbes():
    r"""ShowAllProbes()"""
    return _vsp_g.ShowAllProbes()

def HideAllProbes():
    r"""HideAllProbes()"""
    return _vsp_g.HideAllProbes()

def ShowAllProtractors():
    r"""ShowAllProtractors()"""
    return _vsp_g.ShowAllProtractors()

def HideAllProtractors():
    r"""HideAllProtractors()"""
    return _vsp_g.HideAllProtractors()

def ShowAllRSTProbes():
    r"""ShowAllRSTProbes()"""
    return _vsp_g.ShowAllRSTProbes()

def HideAllRSTProbes():
    r"""HideAllRSTProbes()"""
    return _vsp_g.HideAllRSTProbes()

def AddProtractor(startgeomid, startsurfindx, startu, startw, midgeomid, midsurfindx, midu, midw, endgeomid, endsurfindx, endu, endw, name):
    r"""AddProtractor(std::string const & startgeomid, int startsurfindx, double startu, double startw, std::string const & midgeomid, int midsurfindx, double midu, double midw, std::string const & endgeomid, int endsurfindx, double endu, double endw, std::string const & name) -> std::string"""
    return _vsp_g.AddProtractor(startgeomid, startsurfindx, startu, startw, midgeomid, midsurfindx, midu, midw, endgeomid, endsurfindx, endu, endw, name)

def GetAllProtractors():
    r"""GetAllProtractors() -> StringVector"""
    return _vsp_g.GetAllProtractors()

def DelProtractor(id):
    r"""DelProtractor(std::string const & id)"""
    return _vsp_g.DelProtractor(id)

def DeleteAllProtractors():
    r"""DeleteAllProtractors()"""
    return _vsp_g.DeleteAllProtractors()

def AddRSTProbe(geomid, surfindx, r, s, t, name):
    r"""AddRSTProbe(std::string const & geomid, int surfindx, double r, double s, double t, std::string const & name) -> std::string"""
    return _vsp_g.AddRSTProbe(geomid, surfindx, r, s, t, name)

def GetAllRSTProbes():
    r"""GetAllRSTProbes() -> StringVector"""
    return _vsp_g.GetAllRSTProbes()

def DelRSTProbe(id):
    r"""DelRSTProbe(std::string const & id)"""
    return _vsp_g.DelRSTProbe(id)

def DeleteAllRSTProbes():
    r"""DeleteAllRSTProbes()"""
    return _vsp_g.DeleteAllRSTProbes()

def AddRuler(startgeomid, startsurfindx, startu, startw, endgeomid, endsurfindx, endu, endw, name):
    r"""AddRuler(std::string const & startgeomid, int startsurfindx, double startu, double startw, std::string const & endgeomid, int endsurfindx, double endu, double endw, std::string const & name) -> std::string"""
    return _vsp_g.AddRuler(startgeomid, startsurfindx, startu, startw, endgeomid, endsurfindx, endu, endw, name)

def GetAllRulers():
    r"""GetAllRulers() -> StringVector"""
    return _vsp_g.GetAllRulers()

def DelRuler(id):
    r"""DelRuler(std::string const & id)"""
    return _vsp_g.DelRuler(id)

def DeleteAllRulers():
    r"""DeleteAllRulers()"""
    return _vsp_g.DeleteAllRulers()

def AddProbe(geomid, surfindx, u, w, name):
    r"""AddProbe(std::string const & geomid, int surfindx, double u, double w, std::string const & name) -> std::string"""
    return _vsp_g.AddProbe(geomid, surfindx, u, w, name)

def GetAllProbes():
    r"""GetAllProbes() -> StringVector"""
    return _vsp_g.GetAllProbes()

def DelProbe(id):
    r"""DelProbe(std::string const & id)"""
    return _vsp_g.DelProbe(id)

def DeleteAllProbes():
    r"""DeleteAllProbes()"""
    return _vsp_g.DeleteAllProbes()

def CopyAirfoil(geom_id, index):
    r"""CopyAirfoil(std::string const & geom_id, int index)"""
    return _vsp_g.CopyAirfoil(geom_id, index)

def PasteAirfoil(geom_id, index):
    r"""PasteAirfoil(std::string const & geom_id, int index)"""
    return _vsp_g.PasteAirfoil(geom_id, index)

def ClearSkinning(geom_id, index=-1):
    r"""ClearSkinning(std::string const & geom_id, int index=-1)"""
    return _vsp_g.ClearSkinning(geom_id, index)

def ResetGeomScale(geom_id):
    r"""ResetGeomScale(std::string const & geom_id)"""
    return _vsp_g.ResetGeomScale(geom_id)

def AcceptGeomScale(geom_id):
    r"""AcceptGeomScale(std::string const & geom_id)"""
    return _vsp_g.AcceptGeomScale(geom_id)

def GetPtCloudPnts(geom_id):
    r"""GetPtCloudPnts(std::string const & geom_id) -> Vec3dVec"""
    return _vsp_g.GetPtCloudPnts(geom_id)

def CreatePtCloudGeom(geom_id):
    r"""CreatePtCloudGeom(std::string const & geom_id) -> std::string"""
    return _vsp_g.CreatePtCloudGeom(geom_id)

def CreateNGonMeshGeom(geom_id):
    r"""CreateNGonMeshGeom(std::string const & geom_id) -> std::string"""
    return _vsp_g.CreateNGonMeshGeom(geom_id)

def CreateConvexHull(geom_id):
    r"""CreateConvexHull(std::string const & geom_id) -> std::string"""
    return _vsp_g.CreateConvexHull(geom_id)

def ProjectPtCloudPts(geom_id, target_geom_id, surf_index, dir_index):
    r"""ProjectPtCloudPts(std::string const & geom_id, std::string const & target_geom_id, int surf_index, int dir_index)"""
    return _vsp_g.ProjectPtCloudPts(geom_id, target_geom_id, surf_index, dir_index)

def ShowSet(set_index):
    r"""ShowSet(int set_index)"""
    return _vsp_g.ShowSet(set_index)

def NoShowSet(set_index):
    r"""NoShowSet(int set_index)"""
    return _vsp_g.NoShowSet(set_index)

def ShowOnlySet(set_index):
    r"""ShowOnlySet(int set_index)"""
    return _vsp_g.ShowOnlySet(set_index)

def AddParmLink(parm_a_id, parm_b_id):
    r"""AddParmLink(std::string const & parm_a_id, std::string const & parm_b_id) -> std::string"""
    return _vsp_g.AddParmLink(parm_a_id, parm_b_id)

def GetNumParmLinks():
    r"""GetNumParmLinks() -> int"""
    return _vsp_g.GetNumParmLinks()

def GetParmLinkID(index):
    r"""GetParmLinkID(int index) -> std::string"""
    return _vsp_g.GetParmLinkID(index)

def GetParmLinkAParm(link_id):
    r"""GetParmLinkAParm(std::string const & link_id) -> std::string"""
    return _vsp_g.GetParmLinkAParm(link_id)

def GetParmLinkBParm(link_id):
    r"""GetParmLinkBParm(std::string const & link_id) -> std::string"""
    return _vsp_g.GetParmLinkBParm(link_id)

def SetParmLinkAParm(link_id, parm_id):
    r"""SetParmLinkAParm(std::string const & link_id, std::string const & parm_id)"""
    return _vsp_g.SetParmLinkAParm(link_id, parm_id)

def SetParmLinkBParm(link_id, parm_id):
    r"""SetParmLinkBParm(std::string const & link_id, std::string const & parm_id)"""
    return _vsp_g.SetParmLinkBParm(link_id, parm_id)

def DelParmLink(link_id):
    r"""DelParmLink(std::string const & link_id)"""
    return _vsp_g.DelParmLink(link_id)

def DelAllParmLinks():
    r"""DelAllParmLinks()"""
    return _vsp_g.DelAllParmLinks()

def SortParmLinksByA():
    r"""SortParmLinksByA()"""
    return _vsp_g.SortParmLinksByA()

def SortParmLinksByB():
    r"""SortParmLinksByB()"""
    return _vsp_g.SortParmLinksByB()

def LinkAllComp(parm_a_id, parm_b_id):
    r"""LinkAllComp(std::string const & parm_a_id, std::string const & parm_b_id) -> bool"""
    return _vsp_g.LinkAllComp(parm_a_id, parm_b_id)

def LinkAllGroup(parm_a_id, parm_b_id):
    r"""LinkAllGroup(std::string const & parm_a_id, std::string const & parm_b_id) -> bool"""
    return _vsp_g.LinkAllGroup(parm_a_id, parm_b_id)

def GetParmLinkOffsetFlag(link_id):
    r"""GetParmLinkOffsetFlag(std::string const & link_id) -> bool"""
    return _vsp_g.GetParmLinkOffsetFlag(link_id)

def SetParmLinkOffsetFlag(link_id, flag):
    r"""SetParmLinkOffsetFlag(std::string const & link_id, bool flag)"""
    return _vsp_g.SetParmLinkOffsetFlag(link_id, flag)

def GetParmLinkScaleFlag(link_id):
    r"""GetParmLinkScaleFlag(std::string const & link_id) -> bool"""
    return _vsp_g.GetParmLinkScaleFlag(link_id)

def SetParmLinkScaleFlag(link_id, flag):
    r"""SetParmLinkScaleFlag(std::string const & link_id, bool flag)"""
    return _vsp_g.SetParmLinkScaleFlag(link_id, flag)

def GetParmLinkLowerLimitFlag(link_id):
    r"""GetParmLinkLowerLimitFlag(std::string const & link_id) -> bool"""
    return _vsp_g.GetParmLinkLowerLimitFlag(link_id)

def SetParmLinkLowerLimitFlag(link_id, flag):
    r"""SetParmLinkLowerLimitFlag(std::string const & link_id, bool flag)"""
    return _vsp_g.SetParmLinkLowerLimitFlag(link_id, flag)

def GetParmLinkUpperLimitFlag(link_id):
    r"""GetParmLinkUpperLimitFlag(std::string const & link_id) -> bool"""
    return _vsp_g.GetParmLinkUpperLimitFlag(link_id)

def SetParmLinkUpperLimitFlag(link_id, flag):
    r"""SetParmLinkUpperLimitFlag(std::string const & link_id, bool flag)"""
    return _vsp_g.SetParmLinkUpperLimitFlag(link_id, flag)

def GetAdvLinkNames():
    r"""GetAdvLinkNames() -> StringVector"""
    return _vsp_g.GetAdvLinkNames()

def GetLinkIndex(name):
    r"""GetLinkIndex(std::string const & name) -> int"""
    return _vsp_g.GetLinkIndex(name)

def GetAdvLinkName(index):
    r"""GetAdvLinkName(int index) -> std::string"""
    return _vsp_g.GetAdvLinkName(index)

def SetAdvLinkName(index, name):
    r"""SetAdvLinkName(int index, std::string const & name)"""
    return _vsp_g.SetAdvLinkName(index, name)

def DelAdvLink(index):
    r"""DelAdvLink(int index)"""
    return _vsp_g.DelAdvLink(index)

def DelAllAdvLinks():
    r"""DelAllAdvLinks()"""
    return _vsp_g.DelAllAdvLinks()

def AddAdvLink(name):
    r"""AddAdvLink(std::string const & name)"""
    return _vsp_g.AddAdvLink(name)

def AddAdvLinkInput(index, parm_id, var_name):
    r"""AddAdvLinkInput(int index, std::string const & parm_id, std::string const & var_name)"""
    return _vsp_g.AddAdvLinkInput(index, parm_id, var_name)

def AddAdvLinkOutput(index, parm_id, var_name):
    r"""AddAdvLinkOutput(int index, std::string const & parm_id, std::string const & var_name)"""
    return _vsp_g.AddAdvLinkOutput(index, parm_id, var_name)

def DelAllAdvLinkInputs(index):
    r"""DelAllAdvLinkInputs(int index)"""
    return _vsp_g.DelAllAdvLinkInputs(index)

def DelAllAdvLinkOutputs(index):
    r"""DelAllAdvLinkOutputs(int index)"""
    return _vsp_g.DelAllAdvLinkOutputs(index)

def DelAdvLinkInput(index, var_name):
    r"""DelAdvLinkInput(int index, std::string const & var_name)"""
    return _vsp_g.DelAdvLinkInput(index, var_name)

def DelAdvLinkOutput(index, var_name):
    r"""DelAdvLinkOutput(int index, std::string const & var_name)"""
    return _vsp_g.DelAdvLinkOutput(index, var_name)

def GetAdvLinkInputNames(index):
    r"""GetAdvLinkInputNames(int index) -> StringVector"""
    return _vsp_g.GetAdvLinkInputNames(index)

def GetAdvLinkInputParms(index):
    r"""GetAdvLinkInputParms(int index) -> StringVector"""
    return _vsp_g.GetAdvLinkInputParms(index)

def GetAdvLinkOutputNames(index):
    r"""GetAdvLinkOutputNames(int index) -> StringVector"""
    return _vsp_g.GetAdvLinkOutputNames(index)

def GetAdvLinkOutputParms(index):
    r"""GetAdvLinkOutputParms(int index) -> StringVector"""
    return _vsp_g.GetAdvLinkOutputParms(index)

def ValidateAdvLinkParms(index):
    r"""ValidateAdvLinkParms(int index) -> bool"""
    return _vsp_g.ValidateAdvLinkParms(index)

def SetAdvLinkCode(index, code):
    r"""SetAdvLinkCode(int index, std::string const & code)"""
    return _vsp_g.SetAdvLinkCode(index, code)

def GetAdvLinkCode(index):
    r"""GetAdvLinkCode(int index) -> std::string"""
    return _vsp_g.GetAdvLinkCode(index)

def SearchReplaceAdvLinkCode(index, _from, to):
    r"""SearchReplaceAdvLinkCode(int index, std::string const & _from, std::string const & to)"""
    return _vsp_g.SearchReplaceAdvLinkCode(index, _from, to)

def BuildAdvLinkScript(index):
    r"""BuildAdvLinkScript(int index) -> bool"""
    return _vsp_g.BuildAdvLinkScript(index)

def WriteAdvLinkCodeFile(index, file_name):
    r"""WriteAdvLinkCodeFile(int index, std::string const & file_name)"""
    return _vsp_g.WriteAdvLinkCodeFile(index, file_name)

def ReorderAdvLinkInput(index, var_name, reorder_type):
    r"""ReorderAdvLinkInput(int index, std::string const & var_name, int reorder_type)"""
    return _vsp_g.ReorderAdvLinkInput(index, var_name, reorder_type)

def ReorderAdvLinkOutput(index, var_name, reorder_type):
    r"""ReorderAdvLinkOutput(int index, std::string const & var_name, int reorder_type)"""
    return _vsp_g.ReorderAdvLinkOutput(index, var_name, reorder_type)

def ReadAdvLinkCodeFile(index, file_name):
    r"""ReadAdvLinkCodeFile(int index, std::string const & file_name)"""
    return _vsp_g.ReadAdvLinkCodeFile(index, file_name)

def SortAdvLinkInputsVar(index):
    r"""SortAdvLinkInputsVar(int index)"""
    return _vsp_g.SortAdvLinkInputsVar(index)

def SortAdvLinkInputsCGP(index):
    r"""SortAdvLinkInputsCGP(int index)"""
    return _vsp_g.SortAdvLinkInputsCGP(index)

def SortAdvLinkOutputsVar(index):
    r"""SortAdvLinkOutputsVar(int index)"""
    return _vsp_g.SortAdvLinkOutputsVar(index)

def SortAdvLinkOutputsCGP(index):
    r"""SortAdvLinkOutputsCGP(int index)"""
    return _vsp_g.SortAdvLinkOutputsCGP(index)

def AddVec3D(INOUT, x, y, z):
    r"""AddVec3D(Vec3dVec INOUT, double x, double y, double z)"""
    return _vsp_g.AddVec3D(INOUT, x, y, z)
class vec3d(object):
    r"""Proxy of C++ vec3d class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    v = property(_vsp_g.vec3d_v_get, _vsp_g.vec3d_v_set, doc=r"""v : a(3).double""")

    def __init__(self, *args):
        r"""
        __init__(vec3d self) -> vec3d
        __init__(vec3d self, vec3d a) -> vec3d
        __init__(vec3d self, double xx, double yy, double zz) -> vec3d
        __init__(vec3d self, threed_point_type const & a) -> vec3d
        __init__(vec3d self, double const [3] a) -> vec3d
        __init__(vec3d self, float const [3] a) -> vec3d
        __init__(vec3d self, DoubleVector a) -> vec3d
        """
        _vsp_g.vec3d_swiginit(self, _vsp_g.new_vec3d(*args))

    def as_vec2d_xy(self):
        r"""as_vec2d_xy(vec3d self) -> vec2d"""
        return _vsp_g.vec3d_as_vec2d_xy(self)

    def set_xyz(self, xx, yy, zz):
        r"""set_xyz(vec3d self, double xx, double yy, double zz) -> vec3d"""
        return _vsp_g.vec3d_set_xyz(self, xx, yy, zz)

    def set_vec(self, a):
        r"""set_vec(vec3d self, DoubleVector a) -> vec3d"""
        return _vsp_g.vec3d_set_vec(self, a)

    def set_arr(self, *args):
        r"""
        set_arr(vec3d self, double const [] a) -> vec3d
        set_arr(vec3d self, float const [] a) -> vec3d
        """
        return _vsp_g.vec3d_set_arr(self, *args)

    def set_x(self, xx):
        r"""set_x(vec3d self, double xx) -> vec3d"""
        return _vsp_g.vec3d_set_x(self, xx)

    def set_y(self, yy):
        r"""set_y(vec3d self, double yy) -> vec3d"""
        return _vsp_g.vec3d_set_y(self, yy)

    def set_z(self, zz):
        r"""set_z(vec3d self, double zz) -> vec3d"""
        return _vsp_g.vec3d_set_z(self, zz)

    def set_refx(self, a):
        r"""set_refx(vec3d self, vec3d a) -> vec3d"""
        return _vsp_g.vec3d_set_refx(self, a)

    def set_refy(self, a):
        r"""set_refy(vec3d self, vec3d a) -> vec3d"""
        return _vsp_g.vec3d_set_refy(self, a)

    def set_refz(self, a):
        r"""set_refz(vec3d self, vec3d a) -> vec3d"""
        return _vsp_g.vec3d_set_refz(self, a)

    def get_pnt(self, *args):
        r"""
        get_pnt(vec3d self, double [3] pnt)
        get_pnt(vec3d self, float [3] pnt)
        get_pnt(vec3d self, threed_point_type & pnt)
        """
        return _vsp_g.vec3d_get_pnt(self, *args)

    def x(self):
        r"""x(vec3d self) -> double"""
        return _vsp_g.vec3d_x(self)

    def y(self):
        r"""y(vec3d self) -> double"""
        return _vsp_g.vec3d_y(self)

    def z(self):
        r"""z(vec3d self) -> double"""
        return _vsp_g.vec3d_z(self)

    def data(self):
        r"""data(vec3d self) -> double *"""
        return _vsp_g.vec3d_data(self)

    def Transform(self, m):
        r"""Transform(vec3d self, Matrix4d m)"""
        return _vsp_g.vec3d_Transform(self, m)

    def FlipNormal(self):
        r"""FlipNormal(vec3d self)"""
        return _vsp_g.vec3d_FlipNormal(self)

    def rotate_x(self, theta):
        r"""rotate_x(vec3d self, double theta)"""
        return _vsp_g.vec3d_rotate_x(self, theta)

    def rotate_y(self, theta):
        r"""rotate_y(vec3d self, double theta)"""
        return _vsp_g.vec3d_rotate_y(self, theta)

    def rotate_z(self, theta):
        r"""rotate_z(vec3d self, double theta)"""
        return _vsp_g.vec3d_rotate_z(self, theta)

    def scale_x(self, scale):
        r"""scale_x(vec3d self, double scale)"""
        return _vsp_g.vec3d_scale_x(self, scale)

    def scale_y(self, scale):
        r"""scale_y(vec3d self, double scale)"""
        return _vsp_g.vec3d_scale_y(self, scale)

    def scale_z(self, scale):
        r"""scale_z(vec3d self, double scale)"""
        return _vsp_g.vec3d_scale_z(self, scale)

    def offset_x(self, offset):
        r"""offset_x(vec3d self, double offset)"""
        return _vsp_g.vec3d_offset_x(self, offset)

    def offset_y(self, offset):
        r"""offset_y(vec3d self, double offset)"""
        return _vsp_g.vec3d_offset_y(self, offset)

    def offset_z(self, offset):
        r"""offset_z(vec3d self, double offset)"""
        return _vsp_g.vec3d_offset_z(self, offset)

    def offset_i(self, offset, idir):
        r"""offset_i(vec3d self, double offset, int idir)"""
        return _vsp_g.vec3d_offset_i(self, offset, idir)

    def reflect_xy(self):
        r"""reflect_xy(vec3d self) -> vec3d"""
        return _vsp_g.vec3d_reflect_xy(self)

    def reflect_xz(self):
        r"""reflect_xz(vec3d self) -> vec3d"""
        return _vsp_g.vec3d_reflect_xz(self)

    def reflect_yz(self):
        r"""reflect_yz(vec3d self) -> vec3d"""
        return _vsp_g.vec3d_reflect_yz(self)

    def swap_xy(self):
        r"""swap_xy(vec3d self) -> vec3d"""
        return _vsp_g.vec3d_swap_xy(self)

    def swap_xz(self):
        r"""swap_xz(vec3d self) -> vec3d"""
        return _vsp_g.vec3d_swap_xz(self)

    def swap_yz(self):
        r"""swap_yz(vec3d self) -> vec3d"""
        return _vsp_g.vec3d_swap_yz(self)

    def __imul__(self, b):
        r"""__imul__(vec3d self, double b) -> vec3d"""
        return _vsp_g.vec3d___imul__(self, b)

    def __iadd__(self, *args):
        r"""
        __iadd__(vec3d self, vec3d b) -> vec3d
        __iadd__(vec3d self, double [] b) -> vec3d
        __iadd__(vec3d self, float [] b) -> vec3d
        """
        return _vsp_g.vec3d___iadd__(self, *args)

    def __isub__(self, *args):
        r"""
        __isub__(vec3d self, vec3d b) -> vec3d
        __isub__(vec3d self, double [] b) -> vec3d
        __isub__(vec3d self, float [] b) -> vec3d
        """
        return _vsp_g.vec3d___isub__(self, *args)

    def mag(self):
        r"""mag(vec3d self) -> double"""
        return _vsp_g.vec3d_mag(self)

    def magsq(self):
        r"""magsq(vec3d self) -> double"""
        return _vsp_g.vec3d_magsq(self)

    def normalize(self):
        r"""normalize(vec3d self)"""
        return _vsp_g.vec3d_normalize(self)

    def major_comp(self):
        r"""major_comp(vec3d self) -> int"""
        return _vsp_g.vec3d_major_comp(self)

    def minor_comp(self):
        r"""minor_comp(vec3d self) -> int"""
        return _vsp_g.vec3d_minor_comp(self)

    def isnan(self):
        r"""isnan(vec3d self) -> bool"""
        return _vsp_g.vec3d_isnan(self)

    def isinf(self):
        r"""isinf(vec3d self) -> bool"""
        return _vsp_g.vec3d_isinf(self)

    def isfinite(self):
        r"""isfinite(vec3d self) -> bool"""
        return _vsp_g.vec3d_isfinite(self)

    def _print(self, *args):
        r"""_print(vec3d self, char const * label="")"""
        return _vsp_g.vec3d__print(self, *args)

    def as_numpy(self):
        return _vsp_g.vec3d_as_numpy(self)
    __swig_destroy__ = _vsp_g.delete_vec3d

# Register vec3d in _vsp_g:
_vsp_g.vec3d_swigregister(vec3d)
cvar = _vsp_g.cvar

def signed_angle(a, b, ref):
    r"""signed_angle(vec3d a, vec3d b, vec3d ref) -> double"""
    return _vsp_g.signed_angle(a, b, ref)

def radius_of_circle(p1, p2, p3):
    r"""radius_of_circle(vec3d p1, vec3d p2, vec3d p3) -> double"""
    return _vsp_g.radius_of_circle(p1, p2, p3)

def center_of_circle(p1, p2, p3, center):
    r"""center_of_circle(vec3d p1, vec3d p2, vec3d p3, vec3d center)"""
    return _vsp_g.center_of_circle(p1, p2, p3, center)

def triangle_plane_intersect_test(org, norm, p1, p2, p3):
    r"""triangle_plane_intersect_test(vec3d org, vec3d norm, vec3d p1, vec3d p2, vec3d p3) -> bool"""
    return _vsp_g.triangle_plane_intersect_test(org, norm, p1, p2, p3)

def triangle_plane_minimum_dist(org, norm, p1, p2, p3, pa, pb):
    r"""triangle_plane_minimum_dist(vec3d org, vec3d norm, vec3d p1, vec3d p2, vec3d p3, vec3d pa, vec3d pb) -> double"""
    return _vsp_g.triangle_plane_minimum_dist(org, norm, p1, p2, p3, pa, pb)

def triangle_plane_maximum_dist(org, norm, p1, p2, p3, pa, pb):
    r"""triangle_plane_maximum_dist(vec3d org, vec3d norm, vec3d p1, vec3d p2, vec3d p3, vec3d pa, vec3d pb) -> double"""
    return _vsp_g.triangle_plane_maximum_dist(org, norm, p1, p2, p3, pa, pb)

def plane_plane_intersection(p0, n0, p1, n1, p, v):
    r"""plane_plane_intersection(vec3d p0, vec3d n0, vec3d p1, vec3d n1, vec3d p, vec3d v) -> bool"""
    return _vsp_g.plane_plane_intersection(p0, n0, p1, n1, p, v)

def angle_pnt_2_plane(*args):
    r"""
    angle_pnt_2_plane(vec3d ptplane, vec3d norm, vec3d ptaxis, vec3d axis, vec3d pt, int ccw, vec3d prot) -> double
    angle_pnt_2_plane(vec3d ptplane, vec3d norm, vec3d ptaxis, vec3d axis, vec3d pt, int ccw, vec3d prot1, vec3d prot2, double & theta1, double & theta2)
    """
    return _vsp_g.angle_pnt_2_plane(*args)

def signed_dist_pnt_2_plane(org, norm, pnt):
    r"""signed_dist_pnt_2_plane(vec3d org, vec3d norm, vec3d pnt) -> double"""
    return _vsp_g.signed_dist_pnt_2_plane(org, norm, pnt)

def dist_pnt_2_plane(org, norm, pnt):
    r"""dist_pnt_2_plane(vec3d org, vec3d norm, vec3d pnt) -> double"""
    return _vsp_g.dist_pnt_2_plane(org, norm, pnt)

def dist_pnt_2_line(line_pt1, line_pt2, pnt):
    r"""dist_pnt_2_line(vec3d line_pt1, vec3d line_pt2, vec3d pnt) -> double"""
    return _vsp_g.dist_pnt_2_line(line_pt1, line_pt2, pnt)

def dist_pnt_2_ray(line_pt1, dir_unit_vec, pnt):
    r"""dist_pnt_2_ray(vec3d line_pt1, vec3d dir_unit_vec, vec3d pnt) -> double"""
    return _vsp_g.dist_pnt_2_ray(line_pt1, dir_unit_vec, pnt)

def proj_u_on_v(u, v):
    r"""proj_u_on_v(vec3d u, vec3d v) -> vec3d"""
    return _vsp_g.proj_u_on_v(u, v)

def proj_pnt_on_ray(*args):
    r"""
    proj_pnt_on_ray(vec3d line_pt1, vec3d line_dir, vec3d pnt) -> vec3d
    proj_pnt_on_ray(vec3d line_pt1, vec3d line_dir, vec3d pnt, double & t) -> vec3d
    """
    return _vsp_g.proj_pnt_on_ray(*args)

def proj_pnt_on_line(line_pt1, line_pt2, pnt):
    r"""proj_pnt_on_line(vec3d line_pt1, vec3d line_pt2, vec3d pnt) -> vec3d"""
    return _vsp_g.proj_pnt_on_line(line_pt1, line_pt2, pnt)

def proj_pnt_to_plane(org, plane_ln1, plane_ln2, pnt):
    r"""proj_pnt_to_plane(vec3d org, vec3d plane_ln1, vec3d plane_ln2, vec3d pnt) -> vec3d"""
    return _vsp_g.proj_pnt_to_plane(org, plane_ln1, plane_ln2, pnt)

def proj_vec_to_plane(vec, norm):
    r"""proj_vec_to_plane(vec3d vec, vec3d norm) -> vec3d"""
    return _vsp_g.proj_vec_to_plane(vec, norm)

def tri_seg_intersect(A, B, C, D, E, u, w, t):
    r"""tri_seg_intersect(vec3d A, vec3d B, vec3d C, vec3d D, vec3d E, double & u, double & w, double & t) -> int"""
    return _vsp_g.tri_seg_intersect(A, B, C, D, E, u, w, t)

def tri_ray_intersect(A, B, C, D, E, u, w, t):
    r"""tri_ray_intersect(vec3d A, vec3d B, vec3d C, vec3d D, vec3d E, double & u, double & w, double & t) -> int"""
    return _vsp_g.tri_ray_intersect(A, B, C, D, E, u, w, t)

def plane_ray_intersect(*args):
    r"""
    plane_ray_intersect(vec3d A, vec3d B, vec3d C, vec3d D, vec3d E, double & t) -> int
    plane_ray_intersect(vec3d orig, vec3d norm, vec3d D, vec3d E, double & t) -> int
    """
    return _vsp_g.plane_ray_intersect(*args)

def ray_ray_intersect(A, B, C, D, int_pnt1, int_pnt2):
    r"""ray_ray_intersect(vec3d A, vec3d B, vec3d C, vec3d D, vec3d int_pnt1, vec3d int_pnt2) -> int"""
    return _vsp_g.ray_ray_intersect(A, B, C, D, int_pnt1, int_pnt2)

def tetra_volume(A, B, C):
    r"""tetra_volume(vec3d A, vec3d B, vec3d C) -> double"""
    return _vsp_g.tetra_volume(A, B, C)

def area(A, B, C):
    r"""area(vec3d A, vec3d B, vec3d C) -> double"""
    return _vsp_g.area(A, B, C)

def dist3D_Segment_to_Segment(*args):
    r"""
    dist3D_Segment_to_Segment(vec3d S1P0, vec3d S1P1, vec3d S2P0, vec3d S2P1) -> double
    dist3D_Segment_to_Segment(vec3d S1P0, vec3d S1P1, vec3d S2P0, vec3d S2P1, double * Lt, vec3d Ln, double * St, vec3d Sn) -> double
    """
    return _vsp_g.dist3D_Segment_to_Segment(*args)

def nearSegSeg(L0, L1, S0, S1, Lt, Ln, St, Sn):
    r"""nearSegSeg(vec3d L0, vec3d L1, vec3d S0, vec3d S1, double * Lt, vec3d Ln, double * St, vec3d Sn) -> double"""
    return _vsp_g.nearSegSeg(L0, L1, S0, S1, Lt, Ln, St, Sn)

def pointLineDistSquared(p, lp0, lp1, t, pon):
    r"""pointLineDistSquared(vec3d p, vec3d lp0, vec3d lp1, double & t, vec3d pon) -> double"""
    return _vsp_g.pointLineDistSquared(p, lp0, lp1, t, pon)

def pointSegDistSquared(p, sp0, sp1, t, pon):
    r"""pointSegDistSquared(vec3d p, vec3d sp0, vec3d sp1, double & t, vec3d pon) -> double"""
    return _vsp_g.pointSegDistSquared(p, sp0, sp1, t, pon)

def point_on_line(lp0, lp1, t):
    r"""point_on_line(vec3d lp0, vec3d lp1, double const & t) -> vec3d"""
    return _vsp_g.point_on_line(lp0, lp1, t)

def MapToPlane(p, planeOrig, planeVec1, planeVec2):
    r"""MapToPlane(vec3d p, vec3d planeOrig, vec3d planeVec1, vec3d planeVec2) -> vec2d"""
    return _vsp_g.MapToPlane(p, planeOrig, planeVec1, planeVec2)

def MapFromPlane(uw, planeOrig, planeVec1, planeVec2):
    r"""MapFromPlane(vec2d uw, vec3d planeOrig, vec3d planeVec1, vec3d planeVec2) -> vec3d"""
    return _vsp_g.MapFromPlane(uw, planeOrig, planeVec1, planeVec2)

def plane_half_space(planeOrig, planeNorm, pnt):
    r"""plane_half_space(vec3d planeOrig, vec3d planeNorm, vec3d pnt) -> int"""
    return _vsp_g.plane_half_space(planeOrig, planeNorm, pnt)

def line_line_intersect(p1, p2, p3, p4, s, t):
    r"""line_line_intersect(vec3d p1, vec3d p2, vec3d p3, vec3d p4, double * s, double * t) -> bool"""
    return _vsp_g.line_line_intersect(p1, p2, p3, p4, s, t)

def RotateArbAxis(p, theta, r):
    r"""RotateArbAxis(vec3d p, double theta, vec3d r) -> vec3d"""
    return _vsp_g.RotateArbAxis(p, theta, r)

def PtInTri(v0, v1, v2, p):
    r"""PtInTri(vec3d v0, vec3d v1, vec3d v2, vec3d p) -> bool"""
    return _vsp_g.PtInTri(v0, v1, v2, p)

def BarycentricWeights(v0, v1, v2, p):
    r"""BarycentricWeights(vec3d v0, vec3d v1, vec3d v2, vec3d p) -> vec3d"""
    return _vsp_g.BarycentricWeights(v0, v1, v2, p)

def BilinearWeights(p0, p1, p, weights):
    r"""BilinearWeights(vec3d p0, vec3d p1, vec3d p, DoubleVector weights)"""
    return _vsp_g.BilinearWeights(p0, p1, p, weights)

def tri_tri_min_dist(v0, v1, v2, v3, v4, v5, p1, p2):
    r"""tri_tri_min_dist(vec3d v0, vec3d v1, vec3d v2, vec3d v3, vec3d v4, vec3d v5, vec3d p1, vec3d p2) -> double"""
    return _vsp_g.tri_tri_min_dist(v0, v1, v2, v3, v4, v5, p1, p2)

def pnt_tri_min_dist(v0, v1, v2, pnt, pnearest):
    r"""pnt_tri_min_dist(vec3d v0, vec3d v1, vec3d v2, vec3d pnt, vec3d pnearest) -> double"""
    return _vsp_g.pnt_tri_min_dist(v0, v1, v2, pnt, pnearest)

def slerp(a, b, t):
    r"""slerp(vec3d a, vec3d b, double const & t) -> vec3d"""
    return _vsp_g.slerp(a, b, t)

def printpt(v):
    r"""printpt(vec3d v)"""
    return _vsp_g.printpt(v)

def ToSpherical(v):
    r"""ToSpherical(vec3d v) -> vec3d"""
    return _vsp_g.ToSpherical(v)

def ToSpherical2(v, vdet):
    r"""ToSpherical2(vec3d v, vec3d vdet) -> vec3d"""
    return _vsp_g.ToSpherical2(v, vdet)

def ToCartesian(v):
    r"""ToCartesian(vec3d v) -> vec3d"""
    return _vsp_g.ToCartesian(v)

def FitPlane(pts, cen, norm):
    r"""FitPlane(Vec3dVec pts, vec3d cen, vec3d norm)"""
    return _vsp_g.FitPlane(pts, cen, norm)


def to_string(v):
    r"""to_string(vec3d v) -> std::string"""
    return _vsp_g.to_string(v)

def compsum(x):
    r"""compsum(Vec3dVec x) -> vec3d"""
    return _vsp_g.compsum(x)

def raySphereIntersectionFromInside(p, v, c, r, x):
    r"""raySphereIntersectionFromInside(vec3d p, vec3d v, vec3d c, double r, vec3d x) -> bool"""
    return _vsp_g.raySphereIntersectionFromInside(p, v, c, r, x)
class vec2d(object):
    r"""Proxy of C++ vec2d class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    v = property(_vsp_g.vec2d_v_get, _vsp_g.vec2d_v_set, doc=r"""v : a(2).double""")

    def __init__(self, *args):
        r"""
        __init__(vec2d self) -> vec2d
        __init__(vec2d self, vec2d a) -> vec2d
        __init__(vec2d self, double xx, double yy) -> vec2d
        """
        _vsp_g.vec2d_swiginit(self, _vsp_g.new_vec2d(*args))

    def set_xy(self, xx, yy):
        r"""set_xy(vec2d self, double xx, double yy) -> vec2d"""
        return _vsp_g.vec2d_set_xy(self, xx, yy)

    def set_x(self, xx):
        r"""set_x(vec2d self, double xx) -> vec2d"""
        return _vsp_g.vec2d_set_x(self, xx)

    def set_y(self, yy):
        r"""set_y(vec2d self, double yy) -> vec2d"""
        return _vsp_g.vec2d_set_y(self, yy)

    def x(self):
        r"""x(vec2d self) -> double"""
        return _vsp_g.vec2d_x(self)

    def y(self):
        r"""y(vec2d self) -> double"""
        return _vsp_g.vec2d_y(self)

    def data(self):
        r"""data(vec2d self) -> double *"""
        return _vsp_g.vec2d_data(self)

    def transform(self, *args):
        r"""
        transform(vec2d self, float [3][3] mat) -> vec2d
        transform(vec2d self, double [3][3] mat) -> vec2d
        """
        return _vsp_g.vec2d_transform(self, *args)

    def __iadd__(self, b):
        r"""__iadd__(vec2d self, vec2d b) -> vec2d"""
        return _vsp_g.vec2d___iadd__(self, b)

    def __isub__(self, b):
        r"""__isub__(vec2d self, vec2d b) -> vec2d"""
        return _vsp_g.vec2d___isub__(self, b)

    def __imul__(self, b):
        r"""__imul__(vec2d self, double b) -> vec2d"""
        return _vsp_g.vec2d___imul__(self, b)

    def mag(self):
        r"""mag(vec2d self) -> double"""
        return _vsp_g.vec2d_mag(self)

    def normalize(self):
        r"""normalize(vec2d self)"""
        return _vsp_g.vec2d_normalize(self)
    __swig_destroy__ = _vsp_g.delete_vec2d

# Register vec2d in _vsp_g:
_vsp_g.vec2d_swigregister(vec2d)

def dist(*args):
    r"""
    dist(vec3d a, vec3d b) -> double
    dist(vec2d a, vec2d b) -> double
    """
    return _vsp_g.dist(*args)

def dist_squared(*args):
    r"""
    dist_squared(vec3d a, vec3d b) -> double
    dist_squared(vec2d a, vec2d b) -> double
    """
    return _vsp_g.dist_squared(*args)

def cross(*args):
    r"""
    cross(vec3d a, vec3d b) -> vec3d
    cross(vec2d a, vec2d b) -> double
    """
    return _vsp_g.cross(*args)

def dot(*args):
    r"""
    dot(vec3d a, vec3d b) -> double
    dot(vec2d a, vec2d b) -> double
    """
    return _vsp_g.dot(*args)

def angle(*args):
    r"""
    angle(vec3d a, vec3d b) -> double
    angle(vec2d a, vec2d b) -> double
    """
    return _vsp_g.angle(*args)

def cos_angle(*args):
    r"""
    cos_angle(vec3d a, vec3d b) -> double
    cos_angle(vec2d a, vec2d b) -> double
    """
    return _vsp_g.cos_angle(*args)

def seg_seg_intersect(pnt_A, pnt_B, pnt_C, pnt_D, int_pnt, t1, t2):
    r"""seg_seg_intersect(vec2d pnt_A, vec2d pnt_B, vec2d pnt_C, vec2d pnt_D, vec2d int_pnt, double & t1, double & t2) -> int"""
    return _vsp_g.seg_seg_intersect(pnt_A, pnt_B, pnt_C, pnt_D, int_pnt, t1, t2)

def proj_pnt_on_line_seg(*args):
    r"""
    proj_pnt_on_line_seg(vec3d line_pt1, vec3d line_pt2, vec3d pnt) -> vec3d
    proj_pnt_on_line_seg(vec2d line_A, vec2d line_B, vec2d pnt) -> vec2d
    """
    return _vsp_g.proj_pnt_on_line_seg(*args)

def proj_pnt_on_line_u(line_A, line_B, pnt):
    r"""proj_pnt_on_line_u(vec2d line_A, vec2d line_B, vec2d pnt) -> double"""
    return _vsp_g.proj_pnt_on_line_u(line_A, line_B, pnt)

def encode(x_min, y_min, x_max, y_max, pnt, code):
    r"""encode(double x_min, double y_min, double x_max, double y_max, vec2d pnt, int [4] code)"""
    return _vsp_g.encode(x_min, y_min, x_max, y_max, pnt, code)

def clip_seg_rect(x_min, y_min, x_max, y_max, pnt1, pnt2, visible):
    r"""clip_seg_rect(double x_min, double y_min, double x_max, double y_max, vec2d pnt1, vec2d pnt2, int & visible)"""
    return _vsp_g.clip_seg_rect(x_min, y_min, x_max, y_max, pnt1, pnt2, visible)

def PointInPolygon(R, pnts):
    r"""PointInPolygon(vec2d R, std::vector< vec2d,std::allocator< vec2d > > const & pnts) -> bool"""
    return _vsp_g.PointInPolygon(R, pnts)

def det(p0, p1, offset):
    r"""det(vec2d p0, vec2d p1, vec2d offset) -> double"""
    return _vsp_g.det(p0, p1, offset)

def poly_area(*args):
    r"""
    poly_area(Vec3dVec pnt_vec) -> double
    poly_area(std::vector< vec2d,std::allocator< vec2d > > const & pnt_vec) -> double
    """
    return _vsp_g.poly_area(*args)

def poly_centroid(pnt_vec):
    r"""poly_centroid(std::vector< vec2d,std::allocator< vec2d > > const & pnt_vec) -> vec2d"""
    return _vsp_g.poly_centroid(pnt_vec)

def orient2d(p0, p1, p):
    r"""orient2d(vec2d p0, vec2d p1, vec2d p) -> double"""
    return _vsp_g.orient2d(p0, p1, p)

def bi_lin_interp(p0, p1, p2, p3, s, t, p):
    r"""bi_lin_interp(vec2d p0, vec2d p1, vec2d p2, vec2d p3, double s, double t, vec2d p)"""
    return _vsp_g.bi_lin_interp(p0, p1, p2, p3, s, t, p)

def inverse_bi_lin_interp(p0, p1, p2, p3, p, s, t, s2, t2):
    r"""inverse_bi_lin_interp(vec2d p0, vec2d p1, vec2d p2, vec2d p3, vec2d p, double & s, double & t, double & s2, double & t2) -> int"""
    return _vsp_g.inverse_bi_lin_interp(p0, p1, p2, p3, p, s, t, s2, t2)

class Matrix4d(object):
    r"""Proxy of C++ Matrix4d class."""

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

    def __init__(self):
        r"""__init__(Matrix4d self) -> Matrix4d"""
        _vsp_g.Matrix4d_swiginit(self, _vsp_g.new_Matrix4d())

    def loadIdentity(self):
        r"""loadIdentity(Matrix4d self)"""
        return _vsp_g.Matrix4d_loadIdentity(self)

    def _print(self, *args):
        r"""_print(Matrix4d self, std::string const & header="")"""
        return _vsp_g.Matrix4d__print(self, *args)

    @staticmethod
    def setIdentity(m):
        r"""setIdentity(double * m)"""
        return _vsp_g.Matrix4d_setIdentity(m)

    def translatef(self, x, y, z):
        r"""translatef(Matrix4d self, double const & x, double const & y, double const & z)"""
        return _vsp_g.Matrix4d_translatef(self, x, y, z)

    def translatev(self, v):
        r"""translatev(Matrix4d self, vec3d v)"""
        return _vsp_g.Matrix4d_translatev(self, v)

    def rotateX(self, ang):
        r"""rotateX(Matrix4d self, double const & ang)"""
        return _vsp_g.Matrix4d_rotateX(self, ang)

    def rotateY(self, ang):
        r"""rotateY(Matrix4d self, double const & ang)"""
        return _vsp_g.Matrix4d_rotateY(self, ang)

    def rotateZ(self, ang):
        r"""rotateZ(Matrix4d self, double const & ang)"""
        return _vsp_g.Matrix4d_rotateZ(self, ang)

    def rotate(self, angle, axis):
        r"""rotate(Matrix4d self, double const & angle, vec3d axis)"""
        return _vsp_g.Matrix4d_rotate(self, angle, axis)

    def rotatealongX(self, dir1):
        r"""rotatealongX(Matrix4d self, vec3d dir1)"""
        return _vsp_g.Matrix4d_rotatealongX(self, dir1)

    def zeroTranslations(self):
        r"""zeroTranslations(Matrix4d self)"""
        return _vsp_g.Matrix4d_zeroTranslations(self)

    def affineInverse(self):
        r"""affineInverse(Matrix4d self)"""
        return _vsp_g.Matrix4d_affineInverse(self)

    def scale(self, scale):
        r"""scale(Matrix4d self, double const & scale)"""
        return _vsp_g.Matrix4d_scale(self, scale)

    def scalex(self, scalex):
        r"""scalex(Matrix4d self, double const & scalex)"""
        return _vsp_g.Matrix4d_scalex(self, scalex)

    def scaley(self, scaley):
        r"""scaley(Matrix4d self, double const & scaley)"""
        return _vsp_g.Matrix4d_scaley(self, scaley)

    def scalez(self, scalez):
        r"""scalez(Matrix4d self, double const & scalez)"""
        return _vsp_g.Matrix4d_scalez(self, scalez)

    def flipx(self):
        r"""flipx(Matrix4d self)"""
        return _vsp_g.Matrix4d_flipx(self)

    def getMat(self, m):
        r"""getMat(Matrix4d self, double * m)"""
        return _vsp_g.Matrix4d_getMat(self, m)

    def matMult(self, *args):
        r"""
        matMult(Matrix4d self, double const * m)
        matMult(Matrix4d self, Matrix4d m)
        """
        return _vsp_g.Matrix4d_matMult(self, *args)

    def postMult(self, *args):
        r"""
        postMult(Matrix4d self, double const * m)
        postMult(Matrix4d self, Matrix4d m)
        """
        return _vsp_g.Matrix4d_postMult(self, *args)

    def initMat(self, *args):
        r"""
        initMat(Matrix4d self, double const * m)
        initMat(Matrix4d self, Matrix4d m)
        """
        return _vsp_g.Matrix4d_initMat(self, *args)

    def mult(self, _in, out):
        r"""mult(Matrix4d self, double const [4] _in, double [4] out)"""
        return _vsp_g.Matrix4d_mult(self, _in, out)

    def data(self):
        r"""data(Matrix4d self) -> double *"""
        return _vsp_g.Matrix4d_data(self)

    def const_data(self):
        r"""const_data(Matrix4d self) -> double const *"""
        return _vsp_g.Matrix4d_const_data(self)

    def loadXZRef(self):
        r"""loadXZRef(Matrix4d self)"""
        return _vsp_g.Matrix4d_loadXZRef(self)

    def loadXYRef(self):
        r"""loadXYRef(Matrix4d self)"""
        return _vsp_g.Matrix4d_loadXYRef(self)

    def loadYZRef(self):
        r"""loadYZRef(Matrix4d self)"""
        return _vsp_g.Matrix4d_loadYZRef(self)

    def mirrory(self):
        r"""mirrory(Matrix4d self)"""
        return _vsp_g.Matrix4d_mirrory(self)

    def xform(self, _in):
        r"""xform(Matrix4d self, vec3d _in) -> vec3d"""
        return _vsp_g.Matrix4d_xform(self, _in)

    def xformvec(self, _in):
        r"""xformvec(Matrix4d self, Vec3dVec _in)"""
        return _vsp_g.Matrix4d_xformvec(self, _in)

    def xformmat(self, _in):
        r"""xformmat(Matrix4d self, std::vector< std::vector< vec3d,std::allocator< vec3d > >,std::allocator< std::vector< vec3d,std::allocator< vec3d > > > > & _in)"""
        return _vsp_g.Matrix4d_xformmat(self, _in)

    def xformnorm(self, _in):
        r"""xformnorm(Matrix4d self, vec3d _in) -> vec3d"""
        return _vsp_g.Matrix4d_xformnorm(self, _in)

    def xformnormvec(self, _in):
        r"""xformnormvec(Matrix4d self, Vec3dVec _in)"""
        return _vsp_g.Matrix4d_xformnormvec(self, _in)

    def xformnormmat(self, _in):
        r"""xformnormmat(Matrix4d self, std::vector< std::vector< vec3d,std::allocator< vec3d > >,std::allocator< std::vector< vec3d,std::allocator< vec3d > > > > & _in)"""
        return _vsp_g.Matrix4d_xformnormmat(self, _in)

    def getAngles(self):
        r"""getAngles(Matrix4d self) -> vec3d"""
        return _vsp_g.Matrix4d_getAngles(self)

    def getArcballAngles(self):
        r"""getArcballAngles(Matrix4d self) -> vec3d"""
        return _vsp_g.Matrix4d_getArcballAngles(self)

    def getTranslation(self):
        r"""getTranslation(Matrix4d self) -> vec3d"""
        return _vsp_g.Matrix4d_getTranslation(self)

    def buildXForm(self, pos, rot, cent_rot):
        r"""buildXForm(Matrix4d self, vec3d pos, vec3d rot, vec3d cent_rot)"""
        return _vsp_g.Matrix4d_buildXForm(self, pos, rot, cent_rot)

    def getBasis(self, xdir, ydir, zdir):
        r"""getBasis(Matrix4d self, vec3d xdir, vec3d ydir, vec3d zdir)"""
        return _vsp_g.Matrix4d_getBasis(self, xdir, ydir, zdir)

    def setBasis(self, xdir, ydir, zdir):
        r"""setBasis(Matrix4d self, vec3d xdir, vec3d ydir, vec3d zdir)"""
        return _vsp_g.Matrix4d_setBasis(self, xdir, ydir, zdir)

    def getRotationAxis(self, axis_dir, axis_pnt, angle):
        r"""getRotationAxis(Matrix4d self, vec3d axis_dir, vec3d axis_pnt, double & angle)"""
        return _vsp_g.Matrix4d_getRotationAxis(self, axis_dir, axis_pnt, angle)

    def toQuat(self, qw, qx, qy, qz, tx, ty, tz):
        r"""toQuat(Matrix4d self, double & qw, double & qx, double & qy, double & qz, double & tx, double & ty, double & tz)"""
        return _vsp_g.Matrix4d_toQuat(self, qw, qx, qy, qz, tx, ty, tz)
    __swig_destroy__ = _vsp_g.delete_Matrix4d

# Register Matrix4d in _vsp_g:
_vsp_g.Matrix4d_swigregister(Matrix4d)

def Matrix4d_setIdentity(m):
    r"""Matrix4d_setIdentity(double * m)"""
    return _vsp_g.Matrix4d_setIdentity(m)



# **Placeholder start**
def IsFacade():
    """
    Returns True if the facade API is in use.


    .. code-block:: python

        is_facade = IsFacade()

    """

    return False
def IsGUIRunning():
    """
    Returns True if the GUI event loop is running.


    .. code-block:: python

        is_gui_active = IsGUIRunning()

    """

    return False
