Source code for openvsp.vsp

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

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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

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

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)

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

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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

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

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

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IntVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(IntVector self) -> SwigPyIterator"""
        return _vsp.IntVector_iterator(self)

    def __iter__(self):
        return self.iterator()

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


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


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


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


    def __setslice__(self, *args):
        """
        __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.IntVector___setslice__(self, *args)


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


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


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


    def __setitem__(self, *args):
        """
        __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.IntVector___setitem__(self, *args)


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


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


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


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


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


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


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


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


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


    def clear(self):
        """clear(IntVector self)"""
        return _vsp.IntVector_clear(self)


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


    def pop_back(self):
        """pop_back(IntVector self)"""
        return _vsp.IntVector_pop_back(self)


    def erase(self, *args):
        """
        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.IntVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(int)> self) -> IntVector
        __init__(std::vector<(int)> self, IntVector arg2) -> IntVector
        __init__(std::vector<(int)> self, std::vector< int >::size_type size) -> IntVector
        __init__(std::vector<(int)> self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> IntVector
        """
        this = _vsp.new_IntVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


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


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


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


    def resize(self, *args):
        """
        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.IntVector_resize(self, *args)


    def insert(self, *args):
        """
        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.IntVector_insert(self, *args)


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


    def capacity(self):
        """capacity(IntVector self) -> std::vector< int >::size_type"""
        return _vsp.IntVector_capacity(self)

    __swig_destroy__ = _vsp.delete_IntVector
    __del__ = lambda self: None
IntVector_swigregister = _vsp.IntVector_swigregister
IntVector_swigregister(IntVector)

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

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoubleVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(DoubleVector self) -> SwigPyIterator"""
        return _vsp.DoubleVector_iterator(self)

    def __iter__(self):
        return self.iterator()

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


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


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


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


    def __setslice__(self, *args):
        """
        __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.DoubleVector___setslice__(self, *args)


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


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


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


    def __setitem__(self, *args):
        """
        __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.DoubleVector___setitem__(self, *args)


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


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


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


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


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


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


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


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


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


    def clear(self):
        """clear(DoubleVector self)"""
        return _vsp.DoubleVector_clear(self)


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


    def pop_back(self):
        """pop_back(DoubleVector self)"""
        return _vsp.DoubleVector_pop_back(self)


    def erase(self, *args):
        """
        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.DoubleVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(double)> self) -> DoubleVector
        __init__(std::vector<(double)> self, DoubleVector arg2) -> DoubleVector
        __init__(std::vector<(double)> self, std::vector< double >::size_type size) -> DoubleVector
        __init__(std::vector<(double)> self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> DoubleVector
        """
        this = _vsp.new_DoubleVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


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


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


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


    def resize(self, *args):
        """
        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.DoubleVector_resize(self, *args)


    def insert(self, *args):
        """
        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.DoubleVector_insert(self, *args)


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


    def capacity(self):
        """capacity(DoubleVector self) -> std::vector< double >::size_type"""
        return _vsp.DoubleVector_capacity(self)

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

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

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(StringVector self) -> SwigPyIterator"""
        return _vsp.StringVector_iterator(self)

    def __iter__(self):
        return self.iterator()

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


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


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


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


    def __setslice__(self, *args):
        """
        __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.StringVector___setslice__(self, *args)


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


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


    def __getitem__(self, *args):
        """
        __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.StringVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __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.StringVector___setitem__(self, *args)


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


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


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


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


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


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


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


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


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


    def clear(self):
        """clear(StringVector self)"""
        return _vsp.StringVector_clear(self)


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


    def pop_back(self):
        """pop_back(StringVector self)"""
        return _vsp.StringVector_pop_back(self)


    def erase(self, *args):
        """
        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.StringVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(std::string)> self) -> StringVector
        __init__(std::vector<(std::string)> self, StringVector arg2) -> StringVector
        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size) -> StringVector
        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> StringVector
        """
        this = _vsp.new_StringVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


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


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


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


    def resize(self, *args):
        """
        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.StringVector_resize(self, *args)


    def insert(self, *args):
        """
        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.StringVector_insert(self, *args)


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


    def capacity(self):
        """capacity(StringVector self) -> std::vector< std::string >::size_type"""
        return _vsp.StringVector_capacity(self)

    __swig_destroy__ = _vsp.delete_StringVector
    __del__ = lambda self: None
StringVector_swigregister = _vsp.StringVector_swigregister
StringVector_swigregister(StringVector)

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

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BoolVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BoolVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(BoolVector self) -> SwigPyIterator"""
        return _vsp.BoolVector_iterator(self)

    def __iter__(self):
        return self.iterator()

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


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


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


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


    def __setslice__(self, *args):
        """
        __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.BoolVector___setslice__(self, *args)


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


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


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


    def __setitem__(self, *args):
        """
        __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.BoolVector___setitem__(self, *args)


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


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


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


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


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


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


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


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


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


    def clear(self):
        """clear(BoolVector self)"""
        return _vsp.BoolVector_clear(self)


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


    def pop_back(self):
        """pop_back(BoolVector self)"""
        return _vsp.BoolVector_pop_back(self)


    def erase(self, *args):
        """
        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.BoolVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(bool)> self) -> BoolVector
        __init__(std::vector<(bool)> self, BoolVector arg2) -> BoolVector
        __init__(std::vector<(bool)> self, std::vector< bool >::size_type size) -> BoolVector
        __init__(std::vector<(bool)> self, std::vector< bool >::size_type size, std::vector< bool >::value_type value) -> BoolVector
        """
        this = _vsp.new_BoolVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


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


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


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


    def resize(self, *args):
        """
        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.BoolVector_resize(self, *args)


    def insert(self, *args):
        """
        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.BoolVector_insert(self, *args)


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


    def capacity(self):
        """capacity(BoolVector self) -> std::vector< bool >::size_type"""
        return _vsp.BoolVector_capacity(self)

    __swig_destroy__ = _vsp.delete_BoolVector
    __del__ = lambda self: None
BoolVector_swigregister = _vsp.BoolVector_swigregister
BoolVector_swigregister(BoolVector)

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

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringVecVec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringVecVec, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(StringVecVec self) -> SwigPyIterator"""
        return _vsp.StringVecVec_iterator(self)

    def __iter__(self):
        return self.iterator()

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


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


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


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


    def __setslice__(self, *args):
        """
        __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.StringVecVec___setslice__(self, *args)


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


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


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


    def __setitem__(self, *args):
        """
        __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.StringVecVec___setitem__(self, *args)


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


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


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


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


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


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


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


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


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


    def clear(self):
        """clear(StringVecVec self)"""
        return _vsp.StringVecVec_clear(self)


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


    def pop_back(self):
        """pop_back(StringVecVec self)"""
        return _vsp.StringVecVec_pop_back(self)


    def erase(self, *args):
        """
        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.StringVecVec_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(std::vector<(std::string)>)> self) -> StringVecVec
        __init__(std::vector<(std::vector<(std::string)>)> self, StringVecVec arg2) -> StringVecVec
        __init__(std::vector<(std::vector<(std::string)>)> self, std::vector< std::vector< std::string > >::size_type size) -> StringVecVec
        __init__(std::vector<(std::vector<(std::string)>)> self, std::vector< std::vector< std::string > >::size_type size, StringVector value) -> StringVecVec
        """
        this = _vsp.new_StringVecVec(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


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


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


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


    def resize(self, *args):
        """
        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.StringVecVec_resize(self, *args)


    def insert(self, *args):
        """
        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.StringVecVec_insert(self, *args)


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


    def capacity(self):
        """capacity(StringVecVec self) -> std::vector< std::vector< std::string > >::size_type"""
        return _vsp.StringVecVec_capacity(self)

    __swig_destroy__ = _vsp.delete_StringVecVec
    __del__ = lambda self: None
StringVecVec_swigregister = _vsp.StringVecVec_swigregister
StringVecVec_swigregister(StringVecVec)

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

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntVecVec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IntVecVec, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(IntVecVec self) -> SwigPyIterator"""
        return _vsp.IntVecVec_iterator(self)

    def __iter__(self):
        return self.iterator()

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


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


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


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


    def __setslice__(self, *args):
        """
        __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.IntVecVec___setslice__(self, *args)


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


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


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


    def __setitem__(self, *args):
        """
        __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.IntVecVec___setitem__(self, *args)


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


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


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


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


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


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


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


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


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


    def clear(self):
        """clear(IntVecVec self)"""
        return _vsp.IntVecVec_clear(self)


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


    def pop_back(self):
        """pop_back(IntVecVec self)"""
        return _vsp.IntVecVec_pop_back(self)


    def erase(self, *args):
        """
        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.IntVecVec_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(std::vector<(int)>)> self) -> IntVecVec
        __init__(std::vector<(std::vector<(int)>)> self, IntVecVec arg2) -> IntVecVec
        __init__(std::vector<(std::vector<(int)>)> self, std::vector< std::vector< int > >::size_type size) -> IntVecVec
        __init__(std::vector<(std::vector<(int)>)> self, std::vector< std::vector< int > >::size_type size, IntVector value) -> IntVecVec
        """
        this = _vsp.new_IntVecVec(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


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


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


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


    def resize(self, *args):
        """
        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.IntVecVec_resize(self, *args)


    def insert(self, *args):
        """
        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.IntVecVec_insert(self, *args)


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


    def capacity(self):
        """capacity(IntVecVec self) -> std::vector< std::vector< int > >::size_type"""
        return _vsp.IntVecVec_capacity(self)

    __swig_destroy__ = _vsp.delete_IntVecVec
    __del__ = lambda self: None
IntVecVec_swigregister = _vsp.IntVecVec_swigregister
IntVecVec_swigregister(IntVecVec)

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

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVecVec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoubleVecVec, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(DoubleVecVec self) -> SwigPyIterator"""
        return _vsp.DoubleVecVec_iterator(self)

    def __iter__(self):
        return self.iterator()

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


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


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


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


    def __setslice__(self, *args):
        """
        __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.DoubleVecVec___setslice__(self, *args)


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


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


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


    def __setitem__(self, *args):
        """
        __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.DoubleVecVec___setitem__(self, *args)


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


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


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


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


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


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


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


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


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


    def clear(self):
        """clear(DoubleVecVec self)"""
        return _vsp.DoubleVecVec_clear(self)


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


    def pop_back(self):
        """pop_back(DoubleVecVec self)"""
        return _vsp.DoubleVecVec_pop_back(self)


    def erase(self, *args):
        """
        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.DoubleVecVec_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(std::vector<(double)>)> self) -> DoubleVecVec
        __init__(std::vector<(std::vector<(double)>)> self, DoubleVecVec arg2) -> DoubleVecVec
        __init__(std::vector<(std::vector<(double)>)> self, std::vector< std::vector< double > >::size_type size) -> DoubleVecVec
        __init__(std::vector<(std::vector<(double)>)> self, std::vector< std::vector< double > >::size_type size, DoubleVector value) -> DoubleVecVec
        """
        this = _vsp.new_DoubleVecVec(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


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


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


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


    def resize(self, *args):
        """
        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.DoubleVecVec_resize(self, *args)


    def insert(self, *args):
        """
        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.DoubleVecVec_insert(self, *args)


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


    def capacity(self):
        """capacity(DoubleVecVec self) -> std::vector< std::vector< double > >::size_type"""
        return _vsp.DoubleVecVec_capacity(self)

    __swig_destroy__ = _vsp.delete_DoubleVecVec
    __del__ = lambda self: None
DoubleVecVec_swigregister = _vsp.DoubleVecVec_swigregister
DoubleVecVec_swigregister(DoubleVecVec)

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

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Vec3dVec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Vec3dVec, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(Vec3dVec self) -> SwigPyIterator"""
        return _vsp.Vec3dVec_iterator(self)

    def __iter__(self):
        return self.iterator()

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


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


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


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


    def __setslice__(self, *args):
        """
        __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.Vec3dVec___setslice__(self, *args)


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


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


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


    def __setitem__(self, *args):
        """
        __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.Vec3dVec___setitem__(self, *args)


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


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


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


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


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


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


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


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


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


    def clear(self):
        """clear(Vec3dVec self)"""
        return _vsp.Vec3dVec_clear(self)


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


    def pop_back(self):
        """pop_back(Vec3dVec self)"""
        return _vsp.Vec3dVec_pop_back(self)


    def erase(self, *args):
        """
        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.Vec3dVec_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(vec3d)> self) -> Vec3dVec
        __init__(std::vector<(vec3d)> self, Vec3dVec arg2) -> Vec3dVec
        __init__(std::vector<(vec3d)> self, std::vector< vec3d >::size_type size) -> Vec3dVec
        __init__(std::vector<(vec3d)> self, std::vector< vec3d >::size_type size, vec3d value) -> Vec3dVec
        """
        this = _vsp.new_Vec3dVec(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


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


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


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


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


    def insert(self, *args):
        """
        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.Vec3dVec_insert(self, *args)


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


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


    def as_numpy(self):
        return _vsp.Vec3dVec_as_numpy(self)
    __swig_destroy__ = _vsp.delete_Vec3dVec
    __del__ = lambda self: None
Vec3dVec_swigregister = _vsp.Vec3dVec_swigregister
Vec3dVec_swigregister(Vec3dVec)

class Vec2dVec(_object):
    """Proxy of C++ std::vector<(vec2d)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Vec2dVec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Vec2dVec, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(Vec2dVec self) -> SwigPyIterator"""
        return _vsp.Vec2dVec_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(Vec2dVec self) -> bool"""
        return _vsp.Vec2dVec___nonzero__(self)


    def __bool__(self):
        """__bool__(Vec2dVec self) -> bool"""
        return _vsp.Vec2dVec___bool__(self)


    def __len__(self):
        """__len__(Vec2dVec self) -> std::vector< vec2d >::size_type"""
        return _vsp.Vec2dVec___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(Vec2dVec self, std::vector< vec2d >::difference_type i, std::vector< vec2d >::difference_type j) -> Vec2dVec"""
        return _vsp.Vec2dVec___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(Vec2dVec self, std::vector< vec2d >::difference_type i, std::vector< vec2d >::difference_type j)
        __setslice__(Vec2dVec self, std::vector< vec2d >::difference_type i, std::vector< vec2d >::difference_type j, Vec2dVec v)
        """
        return _vsp.Vec2dVec___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(Vec2dVec self, std::vector< vec2d >::difference_type i, std::vector< vec2d >::difference_type j)"""
        return _vsp.Vec2dVec___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(Vec2dVec self, std::vector< vec2d >::difference_type i)
        __delitem__(Vec2dVec self, PySliceObject * slice)
        """
        return _vsp.Vec2dVec___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(Vec2dVec self, PySliceObject * slice) -> Vec2dVec
        __getitem__(Vec2dVec self, std::vector< vec2d >::difference_type i) -> vec2d
        """
        return _vsp.Vec2dVec___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(Vec2dVec self, PySliceObject * slice, Vec2dVec v)
        __setitem__(Vec2dVec self, PySliceObject * slice)
        __setitem__(Vec2dVec self, std::vector< vec2d >::difference_type i, vec2d x)
        """
        return _vsp.Vec2dVec___setitem__(self, *args)


    def pop(self):
        """pop(Vec2dVec self) -> vec2d"""
        return _vsp.Vec2dVec_pop(self)


    def append(self, x):
        """append(Vec2dVec self, vec2d x)"""
        return _vsp.Vec2dVec_append(self, x)


    def empty(self):
        """empty(Vec2dVec self) -> bool"""
        return _vsp.Vec2dVec_empty(self)


    def size(self):
        """size(Vec2dVec self) -> std::vector< vec2d >::size_type"""
        return _vsp.Vec2dVec_size(self)


    def swap(self, v):
        """swap(Vec2dVec self, Vec2dVec v)"""
        return _vsp.Vec2dVec_swap(self, v)


    def begin(self):
        """begin(Vec2dVec self) -> std::vector< vec2d >::iterator"""
        return _vsp.Vec2dVec_begin(self)


    def end(self):
        """end(Vec2dVec self) -> std::vector< vec2d >::iterator"""
        return _vsp.Vec2dVec_end(self)


    def rbegin(self):
        """rbegin(Vec2dVec self) -> std::vector< vec2d >::reverse_iterator"""
        return _vsp.Vec2dVec_rbegin(self)


    def rend(self):
        """rend(Vec2dVec self) -> std::vector< vec2d >::reverse_iterator"""
        return _vsp.Vec2dVec_rend(self)


    def clear(self):
        """clear(Vec2dVec self)"""
        return _vsp.Vec2dVec_clear(self)


    def get_allocator(self):
        """get_allocator(Vec2dVec self) -> std::vector< vec2d >::allocator_type"""
        return _vsp.Vec2dVec_get_allocator(self)


    def pop_back(self):
        """pop_back(Vec2dVec self)"""
        return _vsp.Vec2dVec_pop_back(self)


    def erase(self, *args):
        """
        erase(Vec2dVec self, std::vector< vec2d >::iterator pos) -> std::vector< vec2d >::iterator
        erase(Vec2dVec self, std::vector< vec2d >::iterator first, std::vector< vec2d >::iterator last) -> std::vector< vec2d >::iterator
        """
        return _vsp.Vec2dVec_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(vec2d)> self) -> Vec2dVec
        __init__(std::vector<(vec2d)> self, Vec2dVec arg2) -> Vec2dVec
        __init__(std::vector<(vec2d)> self, std::vector< vec2d >::size_type size) -> Vec2dVec
        __init__(std::vector<(vec2d)> self, std::vector< vec2d >::size_type size, vec2d value) -> Vec2dVec
        """
        this = _vsp.new_Vec2dVec(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(Vec2dVec self, vec2d x)"""
        return _vsp.Vec2dVec_push_back(self, x)


    def front(self):
        """front(Vec2dVec self) -> vec2d"""
        return _vsp.Vec2dVec_front(self)


    def back(self):
        """back(Vec2dVec self) -> vec2d"""
        return _vsp.Vec2dVec_back(self)


    def assign(self, n, x):
        """assign(Vec2dVec self, std::vector< vec2d >::size_type n, vec2d x)"""
        return _vsp.Vec2dVec_assign(self, n, x)


    def resize(self, *args):
        """
        resize(Vec2dVec self, std::vector< vec2d >::size_type new_size)
        resize(Vec2dVec self, std::vector< vec2d >::size_type new_size, vec2d x)
        """
        return _vsp.Vec2dVec_resize(self, *args)


    def insert(self, *args):
        """
        insert(Vec2dVec self, std::vector< vec2d >::iterator pos, vec2d x) -> std::vector< vec2d >::iterator
        insert(Vec2dVec self, std::vector< vec2d >::iterator pos, std::vector< vec2d >::size_type n, vec2d x)
        """
        return _vsp.Vec2dVec_insert(self, *args)


    def reserve(self, n):
        """reserve(Vec2dVec self, std::vector< vec2d >::size_type n)"""
        return _vsp.Vec2dVec_reserve(self, n)


    def capacity(self):
        """capacity(Vec2dVec self) -> std::vector< vec2d >::size_type"""
        return _vsp.Vec2dVec_capacity(self)

    __swig_destroy__ = _vsp.delete_Vec2dVec
    __del__ = lambda self: None
Vec2dVec_swigregister = _vsp.Vec2dVec_swigregister
Vec2dVec_swigregister(Vec2dVec)

class Vec3dVecVec(_object):
    """Proxy of C++ std::vector<(std::vector<(vec3d)>)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Vec3dVecVec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Vec3dVecVec, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(Vec3dVecVec self) -> SwigPyIterator"""
        return _vsp.Vec3dVecVec_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(Vec3dVecVec self) -> bool"""
        return _vsp.Vec3dVecVec___nonzero__(self)


    def __bool__(self):
        """__bool__(Vec3dVecVec self) -> bool"""
        return _vsp.Vec3dVecVec___bool__(self)


    def __len__(self):
        """__len__(Vec3dVecVec self) -> std::vector< std::vector< vec3d > >::size_type"""
        return _vsp.Vec3dVecVec___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(Vec3dVecVec self, std::vector< std::vector< vec3d > >::difference_type i, std::vector< std::vector< vec3d > >::difference_type j) -> Vec3dVecVec"""
        return _vsp.Vec3dVecVec___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(Vec3dVecVec self, std::vector< std::vector< vec3d > >::difference_type i, std::vector< std::vector< vec3d > >::difference_type j)
        __setslice__(Vec3dVecVec self, std::vector< std::vector< vec3d > >::difference_type i, std::vector< std::vector< vec3d > >::difference_type j, Vec3dVecVec v)
        """
        return _vsp.Vec3dVecVec___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(Vec3dVecVec self, std::vector< std::vector< vec3d > >::difference_type i, std::vector< std::vector< vec3d > >::difference_type j)"""
        return _vsp.Vec3dVecVec___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(Vec3dVecVec self, std::vector< std::vector< vec3d > >::difference_type i)
        __delitem__(Vec3dVecVec self, PySliceObject * slice)
        """
        return _vsp.Vec3dVecVec___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(Vec3dVecVec self, PySliceObject * slice) -> Vec3dVecVec
        __getitem__(Vec3dVecVec self, std::vector< std::vector< vec3d > >::difference_type i) -> Vec3dVec
        """
        return _vsp.Vec3dVecVec___getitem__(self, *args)


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


    def pop(self):
        """pop(Vec3dVecVec self) -> Vec3dVec"""
        return _vsp.Vec3dVecVec_pop(self)


    def append(self, x):
        """append(Vec3dVecVec self, Vec3dVec x)"""
        return _vsp.Vec3dVecVec_append(self, x)


    def empty(self):
        """empty(Vec3dVecVec self) -> bool"""
        return _vsp.Vec3dVecVec_empty(self)


    def size(self):
        """size(Vec3dVecVec self) -> std::vector< std::vector< vec3d > >::size_type"""
        return _vsp.Vec3dVecVec_size(self)


    def swap(self, v):
        """swap(Vec3dVecVec self, Vec3dVecVec v)"""
        return _vsp.Vec3dVecVec_swap(self, v)


    def begin(self):
        """begin(Vec3dVecVec self) -> std::vector< std::vector< vec3d > >::iterator"""
        return _vsp.Vec3dVecVec_begin(self)


    def end(self):
        """end(Vec3dVecVec self) -> std::vector< std::vector< vec3d > >::iterator"""
        return _vsp.Vec3dVecVec_end(self)


    def rbegin(self):
        """rbegin(Vec3dVecVec self) -> std::vector< std::vector< vec3d > >::reverse_iterator"""
        return _vsp.Vec3dVecVec_rbegin(self)


    def rend(self):
        """rend(Vec3dVecVec self) -> std::vector< std::vector< vec3d > >::reverse_iterator"""
        return _vsp.Vec3dVecVec_rend(self)


    def clear(self):
        """clear(Vec3dVecVec self)"""
        return _vsp.Vec3dVecVec_clear(self)


    def get_allocator(self):
        """get_allocator(Vec3dVecVec self) -> std::vector< std::vector< vec3d > >::allocator_type"""
        return _vsp.Vec3dVecVec_get_allocator(self)


    def pop_back(self):
        """pop_back(Vec3dVecVec self)"""
        return _vsp.Vec3dVecVec_pop_back(self)


    def erase(self, *args):
        """
        erase(Vec3dVecVec self, std::vector< std::vector< vec3d > >::iterator pos) -> std::vector< std::vector< vec3d > >::iterator
        erase(Vec3dVecVec self, std::vector< std::vector< vec3d > >::iterator first, std::vector< std::vector< vec3d > >::iterator last) -> std::vector< std::vector< vec3d > >::iterator
        """
        return _vsp.Vec3dVecVec_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(std::vector<(vec3d)>)> self) -> Vec3dVecVec
        __init__(std::vector<(std::vector<(vec3d)>)> self, Vec3dVecVec arg2) -> Vec3dVecVec
        __init__(std::vector<(std::vector<(vec3d)>)> self, std::vector< std::vector< vec3d > >::size_type size) -> Vec3dVecVec
        __init__(std::vector<(std::vector<(vec3d)>)> self, std::vector< std::vector< vec3d > >::size_type size, Vec3dVec value) -> Vec3dVecVec
        """
        this = _vsp.new_Vec3dVecVec(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(Vec3dVecVec self, Vec3dVec x)"""
        return _vsp.Vec3dVecVec_push_back(self, x)


    def front(self):
        """front(Vec3dVecVec self) -> Vec3dVec"""
        return _vsp.Vec3dVecVec_front(self)


    def back(self):
        """back(Vec3dVecVec self) -> Vec3dVec"""
        return _vsp.Vec3dVecVec_back(self)


    def assign(self, n, x):
        """assign(Vec3dVecVec self, std::vector< std::vector< vec3d > >::size_type n, Vec3dVec x)"""
        return _vsp.Vec3dVecVec_assign(self, n, x)


    def resize(self, *args):
        """
        resize(Vec3dVecVec self, std::vector< std::vector< vec3d > >::size_type new_size)
        resize(Vec3dVecVec self, std::vector< std::vector< vec3d > >::size_type new_size, Vec3dVec x)
        """
        return _vsp.Vec3dVecVec_resize(self, *args)


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


    def reserve(self, n):
        """reserve(Vec3dVecVec self, std::vector< std::vector< vec3d > >::size_type n)"""
        return _vsp.Vec3dVecVec_reserve(self, n)


    def capacity(self):
        """capacity(Vec3dVecVec self) -> std::vector< std::vector< vec3d > >::size_type"""
        return _vsp.Vec3dVecVec_capacity(self)

    __swig_destroy__ = _vsp.delete_Vec3dVecVec
    __del__ = lambda self: None
Vec3dVecVec_swigregister = _vsp.Vec3dVecVec_swigregister
Vec3dVecVec_swigregister(Vec3dVecVec)

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

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Matrix4dVec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Matrix4dVec, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(Matrix4dVec self) -> SwigPyIterator"""
        return _vsp.Matrix4dVec_iterator(self)

    def __iter__(self):
        return self.iterator()

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


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


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


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


    def __setslice__(self, *args):
        """
        __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.Matrix4dVec___setslice__(self, *args)


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


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


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


    def __setitem__(self, *args):
        """
        __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.Matrix4dVec___setitem__(self, *args)


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


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


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


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


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


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


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


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


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


    def clear(self):
        """clear(Matrix4dVec self)"""
        return _vsp.Matrix4dVec_clear(self)


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


    def pop_back(self):
        """pop_back(Matrix4dVec self)"""
        return _vsp.Matrix4dVec_pop_back(self)


    def erase(self, *args):
        """
        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.Matrix4dVec_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(Matrix4d)> self) -> Matrix4dVec
        __init__(std::vector<(Matrix4d)> self, Matrix4dVec arg2) -> Matrix4dVec
        __init__(std::vector<(Matrix4d)> self, std::vector< Matrix4d >::size_type size) -> Matrix4dVec
        __init__(std::vector<(Matrix4d)> self, std::vector< Matrix4d >::size_type size, Matrix4d value) -> Matrix4dVec
        """
        this = _vsp.new_Matrix4dVec(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


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


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


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


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


    def insert(self, *args):
        """
        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.Matrix4dVec_insert(self, *args)


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


    def capacity(self):
        """capacity(Matrix4dVec self) -> std::vector< Matrix4d >::size_type"""
        return _vsp.Matrix4dVec_capacity(self)

    __swig_destroy__ = _vsp.delete_Matrix4dVec
    __del__ = lambda self: None
Matrix4dVec_swigregister = _vsp.Matrix4dVec_swigregister
Matrix4dVec_swigregister(Matrix4dVec)

ABS = _vsp.ABS
REL = _vsp.REL
SELIG_AF_EXPORT = _vsp.SELIG_AF_EXPORT
BEZIER_AF_EXPORT = _vsp.BEZIER_AF_EXPORT
ALIGN_LEFT = _vsp.ALIGN_LEFT
ALIGN_CENTER = _vsp.ALIGN_CENTER
ALIGN_RIGHT = _vsp.ALIGN_RIGHT
ALIGN_PIXEL = _vsp.ALIGN_PIXEL
ALIGN_TOP = _vsp.ALIGN_TOP
ALIGN_MIDDLE = _vsp.ALIGN_MIDDLE
ALIGN_BOTTOM = _vsp.ALIGN_BOTTOM
NUM_ALIGN_TYPE = _vsp.NUM_ALIGN_TYPE
ANG_RAD = _vsp.ANG_RAD
ANG_DEG = _vsp.ANG_DEG
ANG_0 = _vsp.ANG_0
ANG_90 = _vsp.ANG_90
ANG_180 = _vsp.ANG_180
ANG_270 = _vsp.ANG_270
NUM_ANG = _vsp.NUM_ANG
ATMOS_TYPE_US_STANDARD_1976 = _vsp.ATMOS_TYPE_US_STANDARD_1976
ATMOS_TYPE_HERRINGTON_1966 = _vsp.ATMOS_TYPE_HERRINGTON_1966
ATMOS_TYPE_MANUAL_P_R = _vsp.ATMOS_TYPE_MANUAL_P_R
ATMOS_TYPE_MANUAL_P_T = _vsp.ATMOS_TYPE_MANUAL_P_T
ATMOS_TYPE_MANUAL_R_T = _vsp.ATMOS_TYPE_MANUAL_R_T
ATMOS_TYPE_MANUAL_RE_L = _vsp.ATMOS_TYPE_MANUAL_RE_L
ATTACH_TRANS_NONE = _vsp.ATTACH_TRANS_NONE
ATTACH_TRANS_COMP = _vsp.ATTACH_TRANS_COMP
ATTACH_TRANS_UV = _vsp.ATTACH_TRANS_UV
ATTACH_TRANS_RST = _vsp.ATTACH_TRANS_RST
ATTACH_TRANS_LMN = _vsp.ATTACH_TRANS_LMN
ATTACH_TRANS_EtaMN = _vsp.ATTACH_TRANS_EtaMN
ATTACH_TRANS_NUM_TYPES = _vsp.ATTACH_TRANS_NUM_TYPES
ATTACH_ROT_NONE = _vsp.ATTACH_ROT_NONE
ATTACH_ROT_COMP = _vsp.ATTACH_ROT_COMP
ATTACH_ROT_UV = _vsp.ATTACH_ROT_UV
ATTACH_ROT_RST = _vsp.ATTACH_ROT_RST
ATTACH_ROT_LMN = _vsp.ATTACH_ROT_LMN
ATTACH_ROT_EtaMN = _vsp.ATTACH_ROT_EtaMN
ATTACH_ROT_NUM_TYPES = _vsp.ATTACH_ROT_NUM_TYPES
ATTROBJ_PARM = _vsp.ATTROBJ_PARM
ATTROBJ_GEOM = _vsp.ATTROBJ_GEOM
ATTROBJ_VEH = _vsp.ATTROBJ_VEH
ATTROBJ_SUBSURF = _vsp.ATTROBJ_SUBSURF
ATTROBJ_MEASURE = _vsp.ATTROBJ_MEASURE
ATTROBJ_LINK = _vsp.ATTROBJ_LINK
ATTROBJ_ADVLINK = _vsp.ATTROBJ_ADVLINK
ATTROBJ_ATTR = _vsp.ATTROBJ_ATTR
ATTROBJ_COLLECTION = _vsp.ATTROBJ_COLLECTION
ATTROBJ_XSEC = _vsp.ATTROBJ_XSEC
ATTROBJ_SEC = _vsp.ATTROBJ_SEC
ATTROBJ_MODE = _vsp.ATTROBJ_MODE
ATTROBJ_SET = _vsp.ATTROBJ_SET
ATTROBJ_VARGROUP = _vsp.ATTROBJ_VARGROUP
ATTROBJ_VARSETTING = _vsp.ATTROBJ_VARSETTING
ATTROBJ_FREE = _vsp.ATTROBJ_FREE
ATTR_GROUP_NONE = _vsp.ATTR_GROUP_NONE
ATTR_GROUP_WATERMARK = _vsp.ATTR_GROUP_WATERMARK
NUM_ATTR_EVENT_GROUPS = _vsp.NUM_ATTR_EVENT_GROUPS
AUX_GEOM_ROTOR_TIP_PATH = _vsp.AUX_GEOM_ROTOR_TIP_PATH
AUX_GEOM_ROTOR_BURST = _vsp.AUX_GEOM_ROTOR_BURST
AUX_GEOM_THREE_PT_GROUND = _vsp.AUX_GEOM_THREE_PT_GROUND
AUX_GEOM_TWO_PT_GROUND = _vsp.AUX_GEOM_TWO_PT_GROUND
AUX_GEOM_ONE_PT_GROUND = _vsp.AUX_GEOM_ONE_PT_GROUND
AUX_GEOM_THREE_PT_CCE = _vsp.AUX_GEOM_THREE_PT_CCE
AUX_GEOM_SUPER_CONE = _vsp.AUX_GEOM_SUPER_CONE
AUX_GEOM_SINGLE_GEAR = _vsp.AUX_GEOM_SINGLE_GEAR
AUX_GEOM_ROTOR_FRAGMENT = _vsp.AUX_GEOM_ROTOR_FRAGMENT
AUX_GEOM_THROWN_BLADE = _vsp.AUX_GEOM_THROWN_BLADE
AUX_GEOM_TIRE_SPRAY = _vsp.AUX_GEOM_TIRE_SPRAY
AUX_GEOM_WHEEL_TIRE_FAILURE = _vsp.AUX_GEOM_WHEEL_TIRE_FAILURE
NUM_AUX_GEOM_MODES = _vsp.NUM_AUX_GEOM_MODES
BOGIE_CENTER_DIST = _vsp.BOGIE_CENTER_DIST
BOGIE_CENTER_DIST_FRAC = _vsp.BOGIE_CENTER_DIST_FRAC
BOGIE_GAP = _vsp.BOGIE_GAP
BOGIE_GAP_FRAC = _vsp.BOGIE_GAP_FRAC
NUM_BOGIE_SPACING_TYPE = _vsp.NUM_BOGIE_SPACING_TYPE
BOR_FLOWTHROUGH = _vsp.BOR_FLOWTHROUGH
BOR_UPPER = _vsp.BOR_UPPER
BOR_LOWER = _vsp.BOR_LOWER
BOR_NUM_MODES = _vsp.BOR_NUM_MODES
MAX_CAMB = _vsp.MAX_CAMB
DESIGN_CL = _vsp.DESIGN_CL
CAM_TOP = _vsp.CAM_TOP
CAM_FRONT = _vsp.CAM_FRONT
CAM_FRONT_YUP = _vsp.CAM_FRONT_YUP
CAM_LEFT = _vsp.CAM_LEFT
CAM_LEFT_ISO = _vsp.CAM_LEFT_ISO
CAM_BOTTOM = _vsp.CAM_BOTTOM
CAM_REAR = _vsp.CAM_REAR
CAM_RIGHT = _vsp.CAM_RIGHT
CAM_RIGHT_ISO = _vsp.CAM_RIGHT_ISO
CAM_CENTER = _vsp.CAM_CENTER
NO_END_CAP = _vsp.NO_END_CAP
FLAT_END_CAP = _vsp.FLAT_END_CAP
ROUND_END_CAP = _vsp.ROUND_END_CAP
EDGE_END_CAP = _vsp.EDGE_END_CAP
SHARP_END_CAP = _vsp.SHARP_END_CAP
POINT_END_CAP = _vsp.POINT_END_CAP
ROUND_EXT_END_CAP_NONE = _vsp.ROUND_EXT_END_CAP_NONE
ROUND_EXT_END_CAP_LE = _vsp.ROUND_EXT_END_CAP_LE
ROUND_EXT_END_CAP_TE = _vsp.ROUND_EXT_END_CAP_TE
ROUND_EXT_END_CAP_BOTH = _vsp.ROUND_EXT_END_CAP_BOTH
NUM_END_CAP_OPTIONS = _vsp.NUM_END_CAP_OPTIONS
CFD_MIN_EDGE_LEN = _vsp.CFD_MIN_EDGE_LEN
CFD_MAX_EDGE_LEN = _vsp.CFD_MAX_EDGE_LEN
CFD_MAX_GAP = _vsp.CFD_MAX_GAP
CFD_NUM_CIRCLE_SEGS = _vsp.CFD_NUM_CIRCLE_SEGS
CFD_GROWTH_RATIO = _vsp.CFD_GROWTH_RATIO
CFD_LIMIT_GROWTH_FLAG = _vsp.CFD_LIMIT_GROWTH_FLAG
CFD_INTERSECT_SUBSURFACE_FLAG = _vsp.CFD_INTERSECT_SUBSURFACE_FLAG
CFD_HALF_MESH_FLAG = _vsp.CFD_HALF_MESH_FLAG
CFD_FAR_FIELD_FLAG = _vsp.CFD_FAR_FIELD_FLAG
CFD_FAR_MAX_EDGE_LEN = _vsp.CFD_FAR_MAX_EDGE_LEN
CFD_FAR_MAX_GAP = _vsp.CFD_FAR_MAX_GAP
CFD_FAR_NUM_CIRCLE_SEGS = _vsp.CFD_FAR_NUM_CIRCLE_SEGS
CFD_FAR_SIZE_ABS_FLAG = _vsp.CFD_FAR_SIZE_ABS_FLAG
CFD_FAR_LENGTH = _vsp.CFD_FAR_LENGTH
CFD_FAR_WIDTH = _vsp.CFD_FAR_WIDTH
CFD_FAR_HEIGHT = _vsp.CFD_FAR_HEIGHT
CFD_FAR_X_SCALE = _vsp.CFD_FAR_X_SCALE
CFD_FAR_Y_SCALE = _vsp.CFD_FAR_Y_SCALE
CFD_FAR_Z_SCALE = _vsp.CFD_FAR_Z_SCALE
CFD_FAR_LOC_MAN_FLAG = _vsp.CFD_FAR_LOC_MAN_FLAG
CFD_FAR_LOC_X = _vsp.CFD_FAR_LOC_X
CFD_FAR_LOC_Y = _vsp.CFD_FAR_LOC_Y
CFD_FAR_LOC_Z = _vsp.CFD_FAR_LOC_Z
CFD_SRF_XYZ_FLAG = _vsp.CFD_SRF_XYZ_FLAG
CFD_STL_FILE_NAME = _vsp.CFD_STL_FILE_NAME
CFD_POLY_FILE_NAME = _vsp.CFD_POLY_FILE_NAME
CFD_TRI_FILE_NAME = _vsp.CFD_TRI_FILE_NAME
CFD_OBJ_FILE_NAME = _vsp.CFD_OBJ_FILE_NAME
CFD_DAT_FILE_NAME = _vsp.CFD_DAT_FILE_NAME
CFD_KEY_FILE_NAME = _vsp.CFD_KEY_FILE_NAME
CFD_GMSH_FILE_NAME = _vsp.CFD_GMSH_FILE_NAME
CFD_TKEY_FILE_NAME = _vsp.CFD_TKEY_FILE_NAME
CFD_FACET_FILE_NAME = _vsp.CFD_FACET_FILE_NAME
CFD_VSPGEOM_FILE_NAME = _vsp.CFD_VSPGEOM_FILE_NAME
CFD_NUM_FILE_NAMES = _vsp.CFD_NUM_FILE_NAMES
POINT_SOURCE = _vsp.POINT_SOURCE
LINE_SOURCE = _vsp.LINE_SOURCE
BOX_SOURCE = _vsp.BOX_SOURCE
ULINE_SOURCE = _vsp.ULINE_SOURCE
WLINE_SOURCE = _vsp.WLINE_SOURCE
NUM_SOURCE_TYPES = _vsp.NUM_SOURCE_TYPES
TAG = _vsp.TAG
REASON = _vsp.REASON
CF_LAM_BLASIUS = _vsp.CF_LAM_BLASIUS
CF_LAM_BLASIUS_W_HEAT = _vsp.CF_LAM_BLASIUS_W_HEAT
CF_TURB_EXPLICIT_FIT_SPALDING = _vsp.CF_TURB_EXPLICIT_FIT_SPALDING
CF_TURB_EXPLICIT_FIT_SPALDING_CHI = _vsp.CF_TURB_EXPLICIT_FIT_SPALDING_CHI
CF_TURB_EXPLICIT_FIT_SCHOENHERR = _vsp.CF_TURB_EXPLICIT_FIT_SCHOENHERR
DO_NOT_USE_CF_TURB_IMPLICIT_KARMAN = _vsp.DO_NOT_USE_CF_TURB_IMPLICIT_KARMAN
CF_TURB_IMPLICIT_SCHOENHERR = _vsp.CF_TURB_IMPLICIT_SCHOENHERR
CF_TURB_IMPLICIT_KARMAN_SCHOENHERR = _vsp.CF_TURB_IMPLICIT_KARMAN_SCHOENHERR
CF_TURB_POWER_LAW_BLASIUS = _vsp.CF_TURB_POWER_LAW_BLASIUS
CF_TURB_POWER_LAW_PRANDTL_LOW_RE = _vsp.CF_TURB_POWER_LAW_PRANDTL_LOW_RE
CF_TURB_POWER_LAW_PRANDTL_MEDIUM_RE = _vsp.CF_TURB_POWER_LAW_PRANDTL_MEDIUM_RE
CF_TURB_POWER_LAW_PRANDTL_HIGH_RE = _vsp.CF_TURB_POWER_LAW_PRANDTL_HIGH_RE
CF_TURB_SCHLICHTING_COMPRESSIBLE = _vsp.CF_TURB_SCHLICHTING_COMPRESSIBLE
DO_NOT_USE_CF_TURB_SCHLICHTING_INCOMPRESSIBLE = _vsp.DO_NOT_USE_CF_TURB_SCHLICHTING_INCOMPRESSIBLE
DO_NOT_USE_CF_TURB_SCHLICHTING_PRANDTL = _vsp.DO_NOT_USE_CF_TURB_SCHLICHTING_PRANDTL
DO_NOT_USE_CF_TURB_SCHULTZ_GRUNOW_HIGH_RE = _vsp.DO_NOT_USE_CF_TURB_SCHULTZ_GRUNOW_HIGH_RE
CF_TURB_SCHULTZ_GRUNOW_SCHOENHERR = _vsp.CF_TURB_SCHULTZ_GRUNOW_SCHOENHERR
DO_NOT_USE_CF_TURB_WHITE_CHRISTOPH_COMPRESSIBLE = _vsp.DO_NOT_USE_CF_TURB_WHITE_CHRISTOPH_COMPRESSIBLE
CF_TURB_ROUGHNESS_SCHLICHTING_AVG = _vsp.CF_TURB_ROUGHNESS_SCHLICHTING_AVG
DO_NOT_USE_CF_TURB_ROUGHNESS_SCHLICHTING_LOCAL = _vsp.DO_NOT_USE_CF_TURB_ROUGHNESS_SCHLICHTING_LOCAL
DO_NOT_USE_CF_TURB_ROUGHNESS_WHITE = _vsp.DO_NOT_USE_CF_TURB_ROUGHNESS_WHITE
CF_TURB_ROUGHNESS_SCHLICHTING_AVG_FLOW_CORRECTION = _vsp.CF_TURB_ROUGHNESS_SCHLICHTING_AVG_FLOW_CORRECTION
CF_TURB_HEATTRANSFER_WHITE_CHRISTOPH = _vsp.CF_TURB_HEATTRANSFER_WHITE_CHRISTOPH
CHEVRON_NONE = _vsp.CHEVRON_NONE
CHEVRON_PARTIAL = _vsp.CHEVRON_PARTIAL
CHEVRON_FULL = _vsp.CHEVRON_FULL
CHEVRON_NUM_TYPES = _vsp.CHEVRON_NUM_TYPES
CHEVRON_W01_SE = _vsp.CHEVRON_W01_SE
CHEVRON_W01_CW = _vsp.CHEVRON_W01_CW
CHEVRON_W01_NUM_MODES = _vsp.CHEVRON_W01_NUM_MODES
COLLISION_OK = _vsp.COLLISION_OK
COLLISION_INTERSECT_NO_SOLUTION = _vsp.COLLISION_INTERSECT_NO_SOLUTION
COLLISION_CLEAR_NO_SOLUTION = _vsp.COLLISION_CLEAR_NO_SOLUTION
NO_FILE_TYPE = _vsp.NO_FILE_TYPE
COMP_GEOM_TXT_TYPE = _vsp.COMP_GEOM_TXT_TYPE
COMP_GEOM_CSV_TYPE = _vsp.COMP_GEOM_CSV_TYPE
DRAG_BUILD_TSV_TYPE_DEPRECATED = _vsp.DRAG_BUILD_TSV_TYPE_DEPRECATED
SLICE_TXT_TYPE = _vsp.SLICE_TXT_TYPE
MASS_PROP_TXT_TYPE = _vsp.MASS_PROP_TXT_TYPE
DEGEN_GEOM_CSV_TYPE = _vsp.DEGEN_GEOM_CSV_TYPE
DEGEN_GEOM_M_TYPE = _vsp.DEGEN_GEOM_M_TYPE
CFD_STL_TYPE = _vsp.CFD_STL_TYPE
CFD_POLY_TYPE = _vsp.CFD_POLY_TYPE
CFD_TRI_TYPE = _vsp.CFD_TRI_TYPE
CFD_OBJ_TYPE = _vsp.CFD_OBJ_TYPE
CFD_DAT_TYPE = _vsp.CFD_DAT_TYPE
CFD_KEY_TYPE = _vsp.CFD_KEY_TYPE
CFD_GMSH_TYPE = _vsp.CFD_GMSH_TYPE
CFD_SRF_TYPE_DEPRECATED = _vsp.CFD_SRF_TYPE_DEPRECATED
CFD_TKEY_TYPE = _vsp.CFD_TKEY_TYPE
PROJ_AREA_CSV_TYPE = _vsp.PROJ_AREA_CSV_TYPE
WAVE_DRAG_TXT_TYPE = _vsp.WAVE_DRAG_TXT_TYPE
VSPAERO_PANEL_TRI_TYPE = _vsp.VSPAERO_PANEL_TRI_TYPE
DRAG_BUILD_CSV_TYPE = _vsp.DRAG_BUILD_CSV_TYPE
CFD_FACET_TYPE = _vsp.CFD_FACET_TYPE
CFD_CURV_TYPE_DEPRECATED = _vsp.CFD_CURV_TYPE_DEPRECATED
CFD_PLOT3D_TYPE_DEPRECATED = _vsp.CFD_PLOT3D_TYPE_DEPRECATED
CFD_VSPGEOM_TYPE = _vsp.CFD_VSPGEOM_TYPE
VSPAERO_VSPGEOM_TYPE = _vsp.VSPAERO_VSPGEOM_TYPE
U_TRIM = _vsp.U_TRIM
L_TRIM = _vsp.L_TRIM
ETA_TRIM = _vsp.ETA_TRIM
NUM_TRIM_TYPES = _vsp.NUM_TRIM_TYPES
DELIM_COMMA = _vsp.DELIM_COMMA
DELIM_USCORE = _vsp.DELIM_USCORE
DELIM_SPACE = _vsp.DELIM_SPACE
DELIM_NONE = _vsp.DELIM_NONE
DELIM_NUM_TYPES = _vsp.DELIM_NUM_TYPES
DEPTH_FRONT = _vsp.DEPTH_FRONT
DEPTH_REAR = _vsp.DEPTH_REAR
DEPTH_FREE = _vsp.DEPTH_FREE
NUM_DEPTH_TYPE = _vsp.NUM_DEPTH_TYPE
SET_3D = _vsp.SET_3D
SET_2D = _vsp.SET_2D
X_DIR = _vsp.X_DIR
Y_DIR = _vsp.Y_DIR
Z_DIR = _vsp.Z_DIR
ALL_DIR = _vsp.ALL_DIR
DISPLAY_BEZIER = _vsp.DISPLAY_BEZIER
DISPLAY_DEGEN_SURF = _vsp.DISPLAY_DEGEN_SURF
DISPLAY_DEGEN_PLATE = _vsp.DISPLAY_DEGEN_PLATE
DISPLAY_DEGEN_CAMBER = _vsp.DISPLAY_DEGEN_CAMBER
GEOM_DRAW_WIRE = _vsp.GEOM_DRAW_WIRE
GEOM_DRAW_HIDDEN = _vsp.GEOM_DRAW_HIDDEN
GEOM_DRAW_SHADE = _vsp.GEOM_DRAW_SHADE
GEOM_DRAW_TEXTURE = _vsp.GEOM_DRAW_TEXTURE
GEOM_DRAW_NONE = _vsp.GEOM_DRAW_NONE
ENGINE_GEOM_NONE = _vsp.ENGINE_GEOM_NONE
ENGINE_GEOM_INLET = _vsp.ENGINE_GEOM_INLET
ENGINE_GEOM_INLET_OUTLET = _vsp.ENGINE_GEOM_INLET_OUTLET
ENGINE_GEOM_OUTLET = _vsp.ENGINE_GEOM_OUTLET
ENGINE_GEOM_IO_NUM_TYPES = _vsp.ENGINE_GEOM_IO_NUM_TYPES
ENGINE_GEOM_FLOWTHROUGH = _vsp.ENGINE_GEOM_FLOWTHROUGH
ENGINE_GEOM_TO_LIP = _vsp.ENGINE_GEOM_TO_LIP
ENGINE_GEOM_FLOWPATH = _vsp.ENGINE_GEOM_FLOWPATH
ENGINE_GEOM_TO_FACE = _vsp.ENGINE_GEOM_TO_FACE
ENGINE_GEOM_NUM_TYPES = _vsp.ENGINE_GEOM_NUM_TYPES
ENGINE_LOC_INDEX = _vsp.ENGINE_LOC_INDEX
ENGINE_LOC_U = _vsp.ENGINE_LOC_U
ENGINE_LOC_INLET_LIP = _vsp.ENGINE_LOC_INLET_LIP
ENGINE_LOC_INLET_FACE = _vsp.ENGINE_LOC_INLET_FACE
ENGINE_LOC_OUTLET_LIP = _vsp.ENGINE_LOC_OUTLET_LIP
ENGINE_LOC_OUTLET_FACE = _vsp.ENGINE_LOC_OUTLET_FACE
ENGINE_LOC_NUM = _vsp.ENGINE_LOC_NUM
ENGINE_MODE_FLOWTHROUGH = _vsp.ENGINE_MODE_FLOWTHROUGH
ENGINE_MODE_FLOWTHROUGH_NEG = _vsp.ENGINE_MODE_FLOWTHROUGH_NEG
ENGINE_MODE_FLOWTHROUGH_NEG_ONLY = _vsp.ENGINE_MODE_FLOWTHROUGH_NEG_ONLY
ENGINE_MODE_TO_LIP = _vsp.ENGINE_MODE_TO_LIP
ENGINE_MODE_TO_FACE = _vsp.ENGINE_MODE_TO_FACE
ENGINE_MODE_TO_FACE_NEG = _vsp.ENGINE_MODE_TO_FACE_NEG
ENGINE_MODE_TO_FACE_NEG_ONLY = _vsp.ENGINE_MODE_TO_FACE_NEG_ONLY
ENGINE_MODE_EXTEND = _vsp.ENGINE_MODE_EXTEND
ENGINE_MODE_NUM_TYPES = _vsp.ENGINE_MODE_NUM_TYPES
VSP_UNKNOWN = _vsp.VSP_UNKNOWN
VSP_OK = _vsp.VSP_OK
VSP_INVALID_PTR = _vsp.VSP_INVALID_PTR
VSP_INVALID_TYPE = _vsp.VSP_INVALID_TYPE
VSP_CANT_FIND_TYPE = _vsp.VSP_CANT_FIND_TYPE
VSP_CANT_FIND_PARM = _vsp.VSP_CANT_FIND_PARM
VSP_CANT_FIND_NAME = _vsp.VSP_CANT_FIND_NAME
VSP_INVALID_GEOM_ID = _vsp.VSP_INVALID_GEOM_ID
VSP_FILE_DOES_NOT_EXIST = _vsp.VSP_FILE_DOES_NOT_EXIST
VSP_FILE_WRITE_FAILURE = _vsp.VSP_FILE_WRITE_FAILURE
VSP_FILE_READ_FAILURE = _vsp.VSP_FILE_READ_FAILURE
VSP_WRONG_GEOM_TYPE = _vsp.VSP_WRONG_GEOM_TYPE
VSP_WRONG_XSEC_TYPE = _vsp.VSP_WRONG_XSEC_TYPE
VSP_WRONG_FILE_TYPE = _vsp.VSP_WRONG_FILE_TYPE
VSP_INDEX_OUT_RANGE = _vsp.VSP_INDEX_OUT_RANGE
VSP_INVALID_XSEC_ID = _vsp.VSP_INVALID_XSEC_ID
VSP_INVALID_ID = _vsp.VSP_INVALID_ID
VSP_CANT_SET_NOT_EQ_PARM = _vsp.VSP_CANT_SET_NOT_EQ_PARM
VSP_AMBIGUOUS_SUBSURF = _vsp.VSP_AMBIGUOUS_SUBSURF
VSP_INVALID_VARPRESET_SETNAME = _vsp.VSP_INVALID_VARPRESET_SETNAME
VSP_INVALID_VARPRESET_GROUPNAME = _vsp.VSP_INVALID_VARPRESET_GROUPNAME
VSP_CONFORMAL_PARENT_UNSUPPORTED = _vsp.VSP_CONFORMAL_PARENT_UNSUPPORTED
VSP_UNEXPECTED_RESET_REMAP_ID = _vsp.VSP_UNEXPECTED_RESET_REMAP_ID
VSP_INVALID_INPUT_VAL = _vsp.VSP_INVALID_INPUT_VAL
VSP_INVALID_CF_EQN = _vsp.VSP_INVALID_CF_EQN
VSP_INVALID_DRIVERS = _vsp.VSP_INVALID_DRIVERS
VSP_ADV_LINK_BUILD_FAIL = _vsp.VSP_ADV_LINK_BUILD_FAIL
VSP_DEPRECATED = _vsp.VSP_DEPRECATED
VSP_LINK_LOOP_DETECTED = _vsp.VSP_LINK_LOOP_DETECTED
VSP_LINK_OUTPUT_NOT_ASSIGNED = _vsp.VSP_LINK_OUTPUT_NOT_ASSIGNED
VSP_DUPLICATE_NAME = _vsp.VSP_DUPLICATE_NAME
VSP_GUI_DEVICE_DEACTIVATED = _vsp.VSP_GUI_DEVICE_DEACTIVATED
VSP_COULD_NOT_CREATE_BACKGROUND3D = _vsp.VSP_COULD_NOT_CREATE_BACKGROUND3D
VSP_NUM_ERROR_CODE = _vsp.VSP_NUM_ERROR_CODE
EXCRESCENCE_COUNT = _vsp.EXCRESCENCE_COUNT
EXCRESCENCE_CD = _vsp.EXCRESCENCE_CD
EXCRESCENCE_PERCENT_GEOM = _vsp.EXCRESCENCE_PERCENT_GEOM
EXCRESCENCE_MARGIN = _vsp.EXCRESCENCE_MARGIN
EXCRESCENCE_DRAGAREA = _vsp.EXCRESCENCE_DRAGAREA
EXPORT_FELISA = _vsp.EXPORT_FELISA
EXPORT_XSEC = _vsp.EXPORT_XSEC
EXPORT_STL = _vsp.EXPORT_STL
EXPORT_AWAVE = _vsp.EXPORT_AWAVE
EXPORT_NASCART = _vsp.EXPORT_NASCART
EXPORT_POVRAY = _vsp.EXPORT_POVRAY
EXPORT_CART3D = _vsp.EXPORT_CART3D
EXPORT_VSPGEOM = _vsp.EXPORT_VSPGEOM
EXPORT_VORXSEC = _vsp.EXPORT_VORXSEC
EXPORT_XSECGEOM = _vsp.EXPORT_XSECGEOM
EXPORT_GMSH = _vsp.EXPORT_GMSH
EXPORT_X3D = _vsp.EXPORT_X3D
EXPORT_STEP = _vsp.EXPORT_STEP
EXPORT_PLOT3D = _vsp.EXPORT_PLOT3D
EXPORT_IGES = _vsp.EXPORT_IGES
EXPORT_BEM = _vsp.EXPORT_BEM
EXPORT_DXF = _vsp.EXPORT_DXF
EXPORT_FACET = _vsp.EXPORT_FACET
EXPORT_SVG = _vsp.EXPORT_SVG
EXPORT_PMARC = _vsp.EXPORT_PMARC
EXPORT_OBJ = _vsp.EXPORT_OBJ
EXPORT_SELIG_AIRFOIL = _vsp.EXPORT_SELIG_AIRFOIL
EXPORT_BEZIER_AIRFOIL = _vsp.EXPORT_BEZIER_AIRFOIL
EXPORT_IGES_STRUCTURE = _vsp.EXPORT_IGES_STRUCTURE
EXPORT_STEP_STRUCTURE = _vsp.EXPORT_STEP_STRUCTURE
FEA_BCM_USER = _vsp.FEA_BCM_USER
FEA_BCM_ALL = _vsp.FEA_BCM_ALL
FEA_BCM_PIN = _vsp.FEA_BCM_PIN
FEA_BCM_SYMM = _vsp.FEA_BCM_SYMM
FEA_BCM_ASYMM = _vsp.FEA_BCM_ASYMM
FEA_NUM_BCM_MODES = _vsp.FEA_NUM_BCM_MODES
FEA_BC_STRUCTURE = _vsp.FEA_BC_STRUCTURE
FEA_BC_PART = _vsp.FEA_BC_PART
FEA_BC_SUBSURF = _vsp.FEA_BC_SUBSURF
FEA_NUM_BC_TYPES = _vsp.FEA_NUM_BC_TYPES
FEA_XSEC_GENERAL = _vsp.FEA_XSEC_GENERAL
FEA_XSEC_CIRC = _vsp.FEA_XSEC_CIRC
FEA_XSEC_PIPE = _vsp.FEA_XSEC_PIPE
FEA_XSEC_I = _vsp.FEA_XSEC_I
FEA_XSEC_RECT = _vsp.FEA_XSEC_RECT
FEA_XSEC_BOX = _vsp.FEA_XSEC_BOX
FEA_MASS_FILE_NAME = _vsp.FEA_MASS_FILE_NAME
FEA_NASTRAN_FILE_NAME = _vsp.FEA_NASTRAN_FILE_NAME
FEA_NKEY_FILE_NAME = _vsp.FEA_NKEY_FILE_NAME
FEA_CALCULIX_FILE_NAME = _vsp.FEA_CALCULIX_FILE_NAME
FEA_STL_FILE_NAME = _vsp.FEA_STL_FILE_NAME
FEA_GMSH_FILE_NAME = _vsp.FEA_GMSH_FILE_NAME
FEA_SRF_FILE_NAME = _vsp.FEA_SRF_FILE_NAME
FEA_CURV_FILE_NAME = _vsp.FEA_CURV_FILE_NAME
FEA_PLOT3D_FILE_NAME = _vsp.FEA_PLOT3D_FILE_NAME
FEA_IGES_FILE_NAME = _vsp.FEA_IGES_FILE_NAME
FEA_STEP_FILE_NAME = _vsp.FEA_STEP_FILE_NAME
FEA_NUM_FILE_NAMES = _vsp.FEA_NUM_FILE_NAMES
FEA_FIX_PT_ON_BODY = _vsp.FEA_FIX_PT_ON_BODY
FEA_FIX_PT_GLOBAL_XYZ = _vsp.FEA_FIX_PT_GLOBAL_XYZ
FEA_FIX_PT_DELTA_XYZ = _vsp.FEA_FIX_PT_DELTA_XYZ
FEA_FIX_PT_DELTA_UVN = _vsp.FEA_FIX_PT_DELTA_UVN
FEA_FIX_PT_GEOM_ORIGIN = _vsp.FEA_FIX_PT_GEOM_ORIGIN
FEA_FIX_PT_GEOM_CG = _vsp.FEA_FIX_PT_GEOM_CG
FEA_NUM_FIX_PT_TYPES = _vsp.FEA_NUM_FIX_PT_TYPES
FEA_ISOTROPIC = _vsp.FEA_ISOTROPIC
FEA_ENG_ORTHO = _vsp.FEA_ENG_ORTHO
FEA_ENG_ORTHO_TRANS_ISO = _vsp.FEA_ENG_ORTHO_TRANS_ISO
FEA_LAMINATE = _vsp.FEA_LAMINATE
FEA_NUM_MAT_TYPES = _vsp.FEA_NUM_MAT_TYPES
FEA_ORIENT_GLOBAL_X = _vsp.FEA_ORIENT_GLOBAL_X
FEA_ORIENT_GLOBAL_Y = _vsp.FEA_ORIENT_GLOBAL_Y
FEA_ORIENT_GLOBAL_Z = _vsp.FEA_ORIENT_GLOBAL_Z
FEA_ORIENT_COMP_X = _vsp.FEA_ORIENT_COMP_X
FEA_ORIENT_COMP_Y = _vsp.FEA_ORIENT_COMP_Y
FEA_ORIENT_COMP_Z = _vsp.FEA_ORIENT_COMP_Z
FEA_ORIENT_PART_U = _vsp.FEA_ORIENT_PART_U
FEA_ORIENT_PART_V = _vsp.FEA_ORIENT_PART_V
FEA_ORIENT_OML_U = _vsp.FEA_ORIENT_OML_U
FEA_ORIENT_OML_V = _vsp.FEA_ORIENT_OML_V
FEA_ORIENT_OML_R = _vsp.FEA_ORIENT_OML_R
FEA_ORIENT_OML_S = _vsp.FEA_ORIENT_OML_S
FEA_ORIENT_OML_T = _vsp.FEA_ORIENT_OML_T
FEA_NUM_ORIENT_TYPES = _vsp.FEA_NUM_ORIENT_TYPES
FEA_DEPRECATED = _vsp.FEA_DEPRECATED
FEA_SHELL = _vsp.FEA_SHELL
FEA_BEAM = _vsp.FEA_BEAM
FEA_SHELL_AND_BEAM = _vsp.FEA_SHELL_AND_BEAM
FEA_NO_ELEMENTS = _vsp.FEA_NO_ELEMENTS
FEA_NUM_ELEMENT_TYPES = _vsp.FEA_NUM_ELEMENT_TYPES
FEA_SLICE = _vsp.FEA_SLICE
FEA_RIB = _vsp.FEA_RIB
FEA_SPAR = _vsp.FEA_SPAR
FEA_FIX_POINT = _vsp.FEA_FIX_POINT
FEA_DOME = _vsp.FEA_DOME
FEA_RIB_ARRAY = _vsp.FEA_RIB_ARRAY
FEA_SLICE_ARRAY = _vsp.FEA_SLICE_ARRAY
FEA_SKIN = _vsp.FEA_SKIN
FEA_TRIM = _vsp.FEA_TRIM
FEA_POLY_SPAR = _vsp.FEA_POLY_SPAR
FEA_NUM_TYPES = _vsp.FEA_NUM_TYPES
NO_NORMAL = _vsp.NO_NORMAL
LE_NORMAL = _vsp.LE_NORMAL
TE_NORMAL = _vsp.TE_NORMAL
SPAR_NORMAL = _vsp.SPAR_NORMAL
FEA_KEEP = _vsp.FEA_KEEP
FEA_DELETE = _vsp.FEA_DELETE
FEA_NUM_SHELL_TREATMENT_TYPES = _vsp.FEA_NUM_SHELL_TREATMENT_TYPES
XY_BODY = _vsp.XY_BODY
YZ_BODY = _vsp.YZ_BODY
XZ_BODY = _vsp.XZ_BODY
XY_ABS = _vsp.XY_ABS
YZ_ABS = _vsp.YZ_ABS
XZ_ABS = _vsp.XZ_ABS
SPINE_NORMAL = _vsp.SPINE_NORMAL
POLY_SPAR_POINT_U01 = _vsp.POLY_SPAR_POINT_U01
POLY_SPAR_POINT_U0N = _vsp.POLY_SPAR_POINT_U0N
POLY_SPAR_POINT_ETA = _vsp.POLY_SPAR_POINT_ETA
NUM_POLY_SPAR_POINT_TYPES = _vsp.NUM_POLY_SPAR_POINT_TYPES
SI_UNIT = _vsp.SI_UNIT
CGS_UNIT = _vsp.CGS_UNIT
MPA_UNIT = _vsp.MPA_UNIT
BFT_UNIT = _vsp.BFT_UNIT
BIN_UNIT = _vsp.BIN_UNIT
FIT_MODEL_FIXED = _vsp.FIT_MODEL_FIXED
FIT_MODEL_FREE = _vsp.FIT_MODEL_FREE
FF_B_MANUAL = _vsp.FF_B_MANUAL
FF_B_SCHEMENSKY_FUSE = _vsp.FF_B_SCHEMENSKY_FUSE
FF_B_SCHEMENSKY_NACELLE = _vsp.FF_B_SCHEMENSKY_NACELLE
FF_B_HOERNER_STREAMBODY = _vsp.FF_B_HOERNER_STREAMBODY
FF_B_TORENBEEK = _vsp.FF_B_TORENBEEK
FF_B_SHEVELL = _vsp.FF_B_SHEVELL
FF_B_COVERT = _vsp.FF_B_COVERT
FF_B_JENKINSON_FUSE = _vsp.FF_B_JENKINSON_FUSE
FF_B_JENKINSON_WING_NACELLE = _vsp.FF_B_JENKINSON_WING_NACELLE
FF_B_JENKINSON_AFT_FUSE_NACELLE = _vsp.FF_B_JENKINSON_AFT_FUSE_NACELLE
FF_W_MANUAL = _vsp.FF_W_MANUAL
FF_W_EDET_CONV = _vsp.FF_W_EDET_CONV
FF_W_EDET_ADV = _vsp.FF_W_EDET_ADV
FF_W_HOERNER = _vsp.FF_W_HOERNER
FF_W_COVERT = _vsp.FF_W_COVERT
FF_W_SHEVELL = _vsp.FF_W_SHEVELL
FF_W_KROO = _vsp.FF_W_KROO
FF_W_TORENBEEK = _vsp.FF_W_TORENBEEK
FF_W_DATCOM = _vsp.FF_W_DATCOM
FF_W_SCHEMENSKY_6_SERIES_AF = _vsp.FF_W_SCHEMENSKY_6_SERIES_AF
FF_W_SCHEMENSKY_4_SERIES_AF = _vsp.FF_W_SCHEMENSKY_4_SERIES_AF
FF_W_JENKINSON_WING = _vsp.FF_W_JENKINSON_WING
FF_W_JENKINSON_TAIL = _vsp.FF_W_JENKINSON_TAIL
FF_W_SCHEMENSKY_SUPERCRITICAL_AF = _vsp.FF_W_SCHEMENSKY_SUPERCRITICAL_AF
ONE_THIRD_ROTOR_FRAGMENT = _vsp.ONE_THIRD_ROTOR_FRAGMENT
INTERMEDIATE_FRAGMENT = _vsp.INTERMEDIATE_FRAGMENT
ALTERNATE_FRAGMENT = _vsp.ALTERNATE_FRAGMENT
FAN_FRAGMENT = _vsp.FAN_FRAGMENT
SMALL_FRAGMENT = _vsp.SMALL_FRAGMENT
GENERIC_FRAGMENT = _vsp.GENERIC_FRAGMENT
NUM_FRAGMENT_MODES = _vsp.NUM_FRAGMENT_MODES
PD_UNITS_IMPERIAL = _vsp.PD_UNITS_IMPERIAL
PD_UNITS_METRIC = _vsp.PD_UNITS_METRIC
OPEN = _vsp.OPEN
SAVE = _vsp.SAVE
NUM_FILE_CHOOSER_MODES = _vsp.NUM_FILE_CHOOSER_MODES
FC_OPENVSP = _vsp.FC_OPENVSP
FC_NATIVE = _vsp.FC_NATIVE
NUM_FILE_CHOOSER_TYPES = _vsp.NUM_FILE_CHOOSER_TYPES
GDEV_TAB = _vsp.GDEV_TAB
GDEV_SCROLL_TAB = _vsp.GDEV_SCROLL_TAB
GDEV_GROUP = _vsp.GDEV_GROUP
GDEV_PARM_BUTTON = _vsp.GDEV_PARM_BUTTON
GDEV_INPUT = _vsp.GDEV_INPUT
GDEV_OUTPUT = _vsp.GDEV_OUTPUT
GDEV_SLIDER = _vsp.GDEV_SLIDER
GDEV_SLIDER_ADJ_RANGE = _vsp.GDEV_SLIDER_ADJ_RANGE
GDEV_CHECK_BUTTON = _vsp.GDEV_CHECK_BUTTON
GDEV_CHECK_BUTTON_BIT = _vsp.GDEV_CHECK_BUTTON_BIT
GDEV_RADIO_BUTTON = _vsp.GDEV_RADIO_BUTTON
GDEV_TOGGLE_BUTTON = _vsp.GDEV_TOGGLE_BUTTON
GDEV_TOGGLE_BUTTON_FREE = _vsp.GDEV_TOGGLE_BUTTON_FREE
GDEV_TOGGLE_RADIO_GROUP = _vsp.GDEV_TOGGLE_RADIO_GROUP
GDEV_TRIGGER_BUTTON = _vsp.GDEV_TRIGGER_BUTTON
GDEV_COUNTER = _vsp.GDEV_COUNTER
GDEV_CHOICE = _vsp.GDEV_CHOICE
GDEV_ADD_CHOICE_ITEM = _vsp.GDEV_ADD_CHOICE_ITEM
GDEV_SLIDER_INPUT = _vsp.GDEV_SLIDER_INPUT
GDEV_SLIDER_ADJ_RANGE_INPUT = _vsp.GDEV_SLIDER_ADJ_RANGE_INPUT
GDEV_SLIDER_ADJ_RANGE_TWO_INPUT = _vsp.GDEV_SLIDER_ADJ_RANGE_TWO_INPUT
GDEV_FRACT_PARM_SLIDER = _vsp.GDEV_FRACT_PARM_SLIDER
GDEV_STRING_INPUT = _vsp.GDEV_STRING_INPUT
GDEV_INDEX_SELECTOR = _vsp.GDEV_INDEX_SELECTOR
GDEV_COLOR_PICKER = _vsp.GDEV_COLOR_PICKER
GDEV_YGAP = _vsp.GDEV_YGAP
GDEV_DIVIDER_BOX = _vsp.GDEV_DIVIDER_BOX
GDEV_BEGIN_SAME_LINE = _vsp.GDEV_BEGIN_SAME_LINE
GDEV_END_SAME_LINE = _vsp.GDEV_END_SAME_LINE
GDEV_FORCE_WIDTH = _vsp.GDEV_FORCE_WIDTH
GDEV_SET_FORMAT = _vsp.GDEV_SET_FORMAT
NUM_GDEV_TYPES = _vsp.NUM_GDEV_TYPES
ALL_GDEV_TYPES = _vsp.ALL_GDEV_TYPES
GEAR_CONFIGURATION_DOWN = _vsp.GEAR_CONFIGURATION_DOWN
GEAR_CONFIGURATION_UP = _vsp.GEAR_CONFIGURATION_UP
GEAR_CONFIGURATION_UP_AND_DOWN = _vsp.GEAR_CONFIGURATION_UP_AND_DOWN
GEAR_CONFIGURATION_INTERMEDIATE = _vsp.GEAR_CONFIGURATION_INTERMEDIATE
GEAR_CONFIGURATION_ALL = _vsp.GEAR_CONFIGURATION_ALL
NUM_GEAR_CONFIGURATION_MODES = _vsp.NUM_GEAR_CONFIGURATION_MODES
GEAR_STOWED_POSITION = _vsp.GEAR_STOWED_POSITION
GEAR_MECHANISM = _vsp.GEAR_MECHANISM
NUM_GEAR_RETRACT_MODES = _vsp.NUM_GEAR_RETRACT_MODES
GEAR_SUSPENSION_NOMINAL = _vsp.GEAR_SUSPENSION_NOMINAL
GEAR_SUSPENSION_COMPRESSED = _vsp.GEAR_SUSPENSION_COMPRESSED
GEAR_SUSPENSION_EXTENDED = _vsp.GEAR_SUSPENSION_EXTENDED
NUM_GEAR_SUSPENSION_MODES = _vsp.NUM_GEAR_SUSPENSION_MODES
MALE = _vsp.MALE
FEMALE = _vsp.FEMALE
EXTERNAL_INTERFERENCE = _vsp.EXTERNAL_INTERFERENCE
PACKAGING_INTERFERENCE = _vsp.PACKAGING_INTERFERENCE
EXTERNAL_SELF_INTERFERENCE = _vsp.EXTERNAL_SELF_INTERFERENCE
PLANE_STATIC_DISTANCE_INTERFERENCE = _vsp.PLANE_STATIC_DISTANCE_INTERFERENCE
PLANE_2PT_ANGLE_INTERFERENCE = _vsp.PLANE_2PT_ANGLE_INTERFERENCE
GEAR_CG_TIPBACK_ANALYSIS = _vsp.GEAR_CG_TIPBACK_ANALYSIS
PLANE_1PT_ANGLE_INTERFERENCE = _vsp.PLANE_1PT_ANGLE_INTERFERENCE
GEAR_WEIGHT_DISTRIBUTION_ANALYSIS = _vsp.GEAR_WEIGHT_DISTRIBUTION_ANALYSIS
GEAR_TIPOVER_ANALYSIS = _vsp.GEAR_TIPOVER_ANALYSIS
GEAR_TURN_ANALYSIS = _vsp.GEAR_TURN_ANALYSIS
VISIBLE_FROM_POINT_ANALYSIS = _vsp.VISIBLE_FROM_POINT_ANALYSIS
CCE_INTERFERENCE = _vsp.CCE_INTERFERENCE
LINEAR_SWEPT_VOLUME_ANALYSIS = _vsp.LINEAR_SWEPT_VOLUME_ANALYSIS
VISIBLE_AT_SURF_ANALYSIS = _vsp.VISIBLE_AT_SURF_ANALYSIS
RISK_ANGLE = _vsp.RISK_ANGLE
COMP_GEOM = _vsp.COMP_GEOM
PLANAR_SLICE = _vsp.PLANAR_SLICE
PROJ_AREA = _vsp.PROJ_AREA
MASS_PROP = _vsp.MASS_PROP
AERO_CENTER = _vsp.AERO_CENTER
NUM_INTERFERENCE_TYPES = _vsp.NUM_INTERFERENCE_TYPES
POD_GEOM_SCREEN = _vsp.POD_GEOM_SCREEN
FUSELAGE_GEOM_SCREEN = _vsp.FUSELAGE_GEOM_SCREEN
MS_WING_GEOM_SCREEN = _vsp.MS_WING_GEOM_SCREEN
BLANK_GEOM_SCREEN = _vsp.BLANK_GEOM_SCREEN
MESH_GEOM_SCREEN = _vsp.MESH_GEOM_SCREEN
NGON_MESH_GEOM_SCREEN = _vsp.NGON_MESH_GEOM_SCREEN
STACK_GEOM_SCREEN = _vsp.STACK_GEOM_SCREEN
CUSTOM_GEOM_SCREEN = _vsp.CUSTOM_GEOM_SCREEN
PT_CLOUD_GEOM_SCREEN = _vsp.PT_CLOUD_GEOM_SCREEN
PROP_GEOM_SCREEN = _vsp.PROP_GEOM_SCREEN
HINGE_GEOM_SCREEN = _vsp.HINGE_GEOM_SCREEN
MULT_GEOM_SCREEN = _vsp.MULT_GEOM_SCREEN
CONFORMAL_SCREEN = _vsp.CONFORMAL_SCREEN
ELLIPSOID_GEOM_SCREEN = _vsp.ELLIPSOID_GEOM_SCREEN
BOR_GEOM_SCREEN = _vsp.BOR_GEOM_SCREEN
WIRE_FRAME_GEOM_SCREEN = _vsp.WIRE_FRAME_GEOM_SCREEN
HUMAN_GEOM_SCREEN = _vsp.HUMAN_GEOM_SCREEN
ROUTING_GEOM_SCREEN = _vsp.ROUTING_GEOM_SCREEN
AUXILIARY_GEOM_SCREEN = _vsp.AUXILIARY_GEOM_SCREEN
GEAR_GEOM_SCREEN = _vsp.GEAR_GEOM_SCREEN
COBRA_GEOM_SCREEN = _vsp.COBRA_GEOM_SCREEN
NUM_GEOM_SCREENS = _vsp.NUM_GEOM_SCREENS
ALL_GEOM_SCREENS = _vsp.ALL_GEOM_SCREENS
VSP_ADV_LINK_SCREEN = _vsp.VSP_ADV_LINK_SCREEN
VSP_ADV_LINK_VAR_RENAME_SCREEN = _vsp.VSP_ADV_LINK_VAR_RENAME_SCREEN
VSP_AERO_STRUCT_SCREEN = _vsp.VSP_AERO_STRUCT_SCREEN
VSP_AIRFOIL_CURVES_EXPORT_SCREEN = _vsp.VSP_AIRFOIL_CURVES_EXPORT_SCREEN
VSP_AIRFOIL_POINTS_EXPORT_SCREEN = _vsp.VSP_AIRFOIL_POINTS_EXPORT_SCREEN
VSP_ATTRIBUTE_EXPLORER_SCREEN = _vsp.VSP_ATTRIBUTE_EXPLORER_SCREEN
VSP_BACKGROUND_SCREEN = _vsp.VSP_BACKGROUND_SCREEN
VSP_BACKGROUND3D_SCREEN = _vsp.VSP_BACKGROUND3D_SCREEN
VSP_BACKGROUND3D_PREVIEW_SCREEN = _vsp.VSP_BACKGROUND3D_PREVIEW_SCREEN
VSP_BEM_OPTIONS_SCREEN = _vsp.VSP_BEM_OPTIONS_SCREEN
VSP_CFD_MESH_SCREEN = _vsp.VSP_CFD_MESH_SCREEN
VSP_CLIPPING_SCREEN = _vsp.VSP_CLIPPING_SCREEN
VSP_COMP_GEOM_SCREEN = _vsp.VSP_COMP_GEOM_SCREEN
VSP_COR_SCREEN = _vsp.VSP_COR_SCREEN
VSP_CURVE_EDIT_SCREEN = _vsp.VSP_CURVE_EDIT_SCREEN
VSP_DEGEN_GEOM_SCREEN = _vsp.VSP_DEGEN_GEOM_SCREEN
VSP_DESIGN_VAR_SCREEN = _vsp.VSP_DESIGN_VAR_SCREEN
VSP_DXF_OPTIONS_SCREEN = _vsp.VSP_DXF_OPTIONS_SCREEN
VSP_EXPORT_SCREEN = _vsp.VSP_EXPORT_SCREEN
VSP_FEA_PART_EDIT_SCREEN = _vsp.VSP_FEA_PART_EDIT_SCREEN
VSP_FEA_XSEC_SCREEN = _vsp.VSP_FEA_XSEC_SCREEN
VSP_FIT_MODEL_SCREEN = _vsp.VSP_FIT_MODEL_SCREEN
VSP_IGES_OPTIONS_SCREEN = _vsp.VSP_IGES_OPTIONS_SCREEN
VSP_IGES_STRUCTURE_OPTIONS_SCREEN = _vsp.VSP_IGES_STRUCTURE_OPTIONS_SCREEN
VSP_EXPORT_CUSTOM_SCRIPT = _vsp.VSP_EXPORT_CUSTOM_SCRIPT
VSP_GEOMETRY_ANALYSIS_SCREEN = _vsp.VSP_GEOMETRY_ANALYSIS_SCREEN
VSP_IMPORT_SCREEN = _vsp.VSP_IMPORT_SCREEN
VSP_LIGHTING_SCREEN = _vsp.VSP_LIGHTING_SCREEN
VSP_MANAGE_GEOM_SCREEN = _vsp.VSP_MANAGE_GEOM_SCREEN
VSP_MANAGE_TEXTURE_SCREEN = _vsp.VSP_MANAGE_TEXTURE_SCREEN
VSP_MASS_PROP_SCREEN = _vsp.VSP_MASS_PROP_SCREEN
VSP_MATERIAL_EDIT_SCREEN = _vsp.VSP_MATERIAL_EDIT_SCREEN
VSP_MEASURE_SCREEN = _vsp.VSP_MEASURE_SCREEN
VSP_MODE_EDITOR_SCREEN = _vsp.VSP_MODE_EDITOR_SCREEN
VSP_NERF_MANAGE_GEOM_SCREEN = _vsp.VSP_NERF_MANAGE_GEOM_SCREEN
VSP_SNAP_TO_SCREEN = _vsp.VSP_SNAP_TO_SCREEN
VSP_PARASITE_DRAG_SCREEN = _vsp.VSP_PARASITE_DRAG_SCREEN
VSP_PARM_DEBUG_SCREEN = _vsp.VSP_PARM_DEBUG_SCREEN
VSP_PARM_LINK_SCREEN = _vsp.VSP_PARM_LINK_SCREEN
VSP_PARM_SCREEN = _vsp.VSP_PARM_SCREEN
VSP_PICK_SET_SCREEN = _vsp.VSP_PICK_SET_SCREEN
VSP_PREFERENCES_SCREEN = _vsp.VSP_PREFERENCES_SCREEN
VSP_PROJECTION_SCREEN = _vsp.VSP_PROJECTION_SCREEN
VSP_PSLICE_SCREEN = _vsp.VSP_PSLICE_SCREEN
VSP_RESULTS_VIEWER_SCREEN = _vsp.VSP_RESULTS_VIEWER_SCREEN
VSP_SCREENSHOT_SCREEN = _vsp.VSP_SCREENSHOT_SCREEN
VSP_SELECT_FILE_SCREEN = _vsp.VSP_SELECT_FILE_SCREEN
VSP_SET_EDITOR_SCREEN = _vsp.VSP_SET_EDITOR_SCREEN
VSP_STEP_OPTIONS_SCREEN = _vsp.VSP_STEP_OPTIONS_SCREEN
VSP_STEP_STRUCTURE_OPTIONS_SCREEN = _vsp.VSP_STEP_STRUCTURE_OPTIONS_SCREEN
VSP_STL_OPTIONS_SCREEN = _vsp.VSP_STL_OPTIONS_SCREEN
VSP_STRUCT_SCREEN = _vsp.VSP_STRUCT_SCREEN
VSP_STRUCT_ASSEMBLY_SCREEN = _vsp.VSP_STRUCT_ASSEMBLY_SCREEN
VSP_SURFACE_INTERSECTION_SCREEN = _vsp.VSP_SURFACE_INTERSECTION_SCREEN
VSP_SVG_OPTIONS_SCREEN = _vsp.VSP_SVG_OPTIONS_SCREEN
VSP_USER_PARM_SCREEN = _vsp.VSP_USER_PARM_SCREEN
VSP_VAR_PRESET_SCREEN = _vsp.VSP_VAR_PRESET_SCREEN
VSP_VEH_NOTES_SCREEN = _vsp.VSP_VEH_NOTES_SCREEN
VSP_VEH_SCREEN = _vsp.VSP_VEH_SCREEN
VSP_VIEW_SCREEN = _vsp.VSP_VIEW_SCREEN
VSP_VSPAERO_PLOT_SCREEN = _vsp.VSP_VSPAERO_PLOT_SCREEN
VSP_VSPAERO_SCREEN = _vsp.VSP_VSPAERO_SCREEN
VSP_XSEC_SCREEN = _vsp.VSP_XSEC_SCREEN
VSP_WAVEDRAG_SCREEN = _vsp.VSP_WAVEDRAG_SCREEN
VSP_MAIN_SCREEN = _vsp.VSP_MAIN_SCREEN
VSP_NUM_SCREENS = _vsp.VSP_NUM_SCREENS
VSP_ALL_SCREENS = _vsp.VSP_ALL_SCREENS
EDIT_XSEC_CIRCLE = _vsp.EDIT_XSEC_CIRCLE
EDIT_XSEC_ELLIPSE = _vsp.EDIT_XSEC_ELLIPSE
EDIT_XSEC_RECTANGLE = _vsp.EDIT_XSEC_RECTANGLE
NUM_INIT_EDIT_XSEC_TYPES = _vsp.NUM_INIT_EDIT_XSEC_TYPES
IMPORT_STL = _vsp.IMPORT_STL
IMPORT_NASCART = _vsp.IMPORT_NASCART
IMPORT_CART3D_TRI = _vsp.IMPORT_CART3D_TRI
IMPORT_XSEC_MESH = _vsp.IMPORT_XSEC_MESH
IMPORT_PTS = _vsp.IMPORT_PTS
IMPORT_V2 = _vsp.IMPORT_V2
IMPORT_BEM = _vsp.IMPORT_BEM
IMPORT_XSEC_WIRE = _vsp.IMPORT_XSEC_WIRE
IMPORT_P3D_WIRE = _vsp.IMPORT_P3D_WIRE
INTERSECT_SRF_FILE_NAME = _vsp.INTERSECT_SRF_FILE_NAME
INTERSECT_CURV_FILE_NAME = _vsp.INTERSECT_CURV_FILE_NAME
INTERSECT_PLOT3D_FILE_NAME = _vsp.INTERSECT_PLOT3D_FILE_NAME
INTERSECT_IGES_FILE_NAME = _vsp.INTERSECT_IGES_FILE_NAME
INTERSECT_STEP_FILE_NAME = _vsp.INTERSECT_STEP_FILE_NAME
INTERSECT_NUM_FILE_NAMES = _vsp.INTERSECT_NUM_FILE_NAMES
LEN_MM = _vsp.LEN_MM
LEN_CM = _vsp.LEN_CM
LEN_M = _vsp.LEN_M
LEN_IN = _vsp.LEN_IN
LEN_FT = _vsp.LEN_FT
LEN_YD = _vsp.LEN_YD
LEN_UNITLESS = _vsp.LEN_UNITLESS
NUM_LEN_UNIT = _vsp.NUM_LEN_UNIT
MASS_UNIT_G = _vsp.MASS_UNIT_G
MASS_UNIT_KG = _vsp.MASS_UNIT_KG
MASS_UNIT_TONNE = _vsp.MASS_UNIT_TONNE
MASS_UNIT_LBM = _vsp.MASS_UNIT_LBM
MASS_UNIT_SLUG = _vsp.MASS_UNIT_SLUG
MASS_LBFSEC2IN = _vsp.MASS_LBFSEC2IN
NUM_MASS_UNIT = _vsp.NUM_MASS_UNIT
NO_REASON = _vsp.NO_REASON
MAX_LEN_CONSTRAINT = _vsp.MAX_LEN_CONSTRAINT
CURV_GAP = _vsp.CURV_GAP
CURV_NCIRCSEG = _vsp.CURV_NCIRCSEG
SOURCES = _vsp.SOURCES
MIN_LEN_CONSTRAINT = _vsp.MIN_LEN_CONSTRAINT
MIN_LEN_CONSTRAINT_CURV_GAP = _vsp.MIN_LEN_CONSTRAINT_CURV_GAP
MIN_LEN_CONSTRAINT_CURV_NCIRCSEG = _vsp.MIN_LEN_CONSTRAINT_CURV_NCIRCSEG
MIN_LEN_CONSTRAINT_SOURCES = _vsp.MIN_LEN_CONSTRAINT_SOURCES
GROW_LIMIT_MAX_LEN_CONSTRAINT = _vsp.GROW_LIMIT_MAX_LEN_CONSTRAINT
GROW_LIMIT_CURV_GAP = _vsp.GROW_LIMIT_CURV_GAP
GROW_LIMIT_CURV_NCIRCSEG = _vsp.GROW_LIMIT_CURV_NCIRCSEG
GROW_LIMIT_SOURCES = _vsp.GROW_LIMIT_SOURCES
GROW_LIMIT_MIN_LEN_CONSTRAINT = _vsp.GROW_LIMIT_MIN_LEN_CONSTRAINT
GROW_LIMIT_MIN_LEN_CONSTRAINT_CURV_GAP = _vsp.GROW_LIMIT_MIN_LEN_CONSTRAINT_CURV_GAP
GROW_LIMIT_MIN_LEN_CONSTRAINT_CURV_NCIRCSEG = _vsp.GROW_LIMIT_MIN_LEN_CONSTRAINT_CURV_NCIRCSEG
GROW_LIMIT_MIN_LEN_CONSTRAINT_SOURCES = _vsp.GROW_LIMIT_MIN_LEN_CONSTRAINT_SOURCES
NUM_MESH_REASON = _vsp.NUM_MESH_REASON
MIN_LEN_INCREMENT = _vsp.MIN_LEN_INCREMENT
GROW_LIMIT_INCREMENT = _vsp.GROW_LIMIT_INCREMENT
MIN_GROW_LIMIT = _vsp.MIN_GROW_LIMIT
TRI_MESH_TYPE = _vsp.TRI_MESH_TYPE
QUAD_MESH_TYPE = _vsp.QUAD_MESH_TYPE
NGON_MESH_TYPE = _vsp.NGON_MESH_TYPE
NUM_MESH_TYPE = _vsp.NUM_MESH_TYPE
EXTENT_FORWARD_INF = _vsp.EXTENT_FORWARD_INF
EXTENT_REVERSE_INF = _vsp.EXTENT_REVERSE_INF
EXTENT_FORWARD_FINITE = _vsp.EXTENT_FORWARD_FINITE
EXTENT_REVERSE_FINITE = _vsp.EXTENT_REVERSE_FINITE
EXTENT_SLIDER_FULL = _vsp.EXTENT_SLIDER_FULL
EXTENT_SLIDER_BEFORE = _vsp.EXTENT_SLIDER_BEFORE
EXTENT_SLIDER_AFTER = _vsp.EXTENT_SLIDER_AFTER
MOTION_NUM_EXTENT_TYPES = _vsp.MOTION_NUM_EXTENT_TYPES
ID_LENGTH_PRESET_GROUP = _vsp.ID_LENGTH_PRESET_GROUP
ID_LENGTH_PRESET_SETTING = _vsp.ID_LENGTH_PRESET_SETTING
ID_LENGTH_ATTR = _vsp.ID_LENGTH_ATTR
ID_LENGTH_ATTRCOLL = _vsp.ID_LENGTH_ATTRCOLL
ID_LENGTH_PARMCONTAINER = _vsp.ID_LENGTH_PARMCONTAINER
ID_LENGTH_PARM = _vsp.ID_LENGTH_PARM
PARM_DOUBLE_TYPE = _vsp.PARM_DOUBLE_TYPE
PARM_INT_TYPE = _vsp.PARM_INT_TYPE
PARM_BOOL_TYPE = _vsp.PARM_BOOL_TYPE
PARM_FRACTION_TYPE = _vsp.PARM_FRACTION_TYPE
PARM_LIMITED_INT_TYPE = _vsp.PARM_LIMITED_INT_TYPE
PARM_NOTEQ_TYPE = _vsp.PARM_NOTEQ_TYPE
PARM_POWER_INT_TYPE = _vsp.PARM_POWER_INT_TYPE
PATCH_NONE = _vsp.PATCH_NONE
PATCH_POINT = _vsp.PATCH_POINT
PATCH_LINE = _vsp.PATCH_LINE
PATCH_COPY = _vsp.PATCH_COPY
PATCH_HALFWAY = _vsp.PATCH_HALFWAY
PATCH_NUM_TYPES = _vsp.PATCH_NUM_TYPES
LINEAR = _vsp.LINEAR
PCHIP = _vsp.PCHIP
CEDIT = _vsp.CEDIT
APPROX_CEDIT = _vsp.APPROX_CEDIT
NUM_PCURV_TYPE = _vsp.NUM_PCURV_TYPE
PRES_UNIT_PSF = _vsp.PRES_UNIT_PSF
PRES_UNIT_PSI = _vsp.PRES_UNIT_PSI
PRES_UNIT_BA = _vsp.PRES_UNIT_BA
PRES_UNIT_PA = _vsp.PRES_UNIT_PA
PRES_UNIT_KPA = _vsp.PRES_UNIT_KPA
PRES_UNIT_MPA = _vsp.PRES_UNIT_MPA
PRES_UNIT_INCHHG = _vsp.PRES_UNIT_INCHHG
PRES_UNIT_MMHG = _vsp.PRES_UNIT_MMHG
PRES_UNIT_MMH20 = _vsp.PRES_UNIT_MMH20
PRES_UNIT_MB = _vsp.PRES_UNIT_MB
PRES_UNIT_ATM = _vsp.PRES_UNIT_ATM
NUM_PRES_UNIT = _vsp.NUM_PRES_UNIT
NO_BOUNDARY = _vsp.NO_BOUNDARY
SET_BOUNDARY = _vsp.SET_BOUNDARY
GEOM_BOUNDARY = _vsp.GEOM_BOUNDARY
NUM_PROJ_BNDY_OPTIONS = _vsp.NUM_PROJ_BNDY_OPTIONS
X_PROJ = _vsp.X_PROJ
Y_PROJ = _vsp.Y_PROJ
Z_PROJ = _vsp.Z_PROJ
GEOM_PROJ = _vsp.GEOM_PROJ
VEC_PROJ = _vsp.VEC_PROJ
NUM_PROJ_DIR_OPTIONS = _vsp.NUM_PROJ_DIR_OPTIONS
SET_TARGET = _vsp.SET_TARGET
GEOM_TARGET = _vsp.GEOM_TARGET
MODE_TARGET = _vsp.MODE_TARGET
Z_TARGET = _vsp.Z_TARGET
XYZ_TARGET = _vsp.XYZ_TARGET
NUM_PROJ_TGT_OPTIONS = _vsp.NUM_PROJ_TGT_OPTIONS
PROP_AZI_UNIFORM = _vsp.PROP_AZI_UNIFORM
PROP_AZI_FREE = _vsp.PROP_AZI_FREE
PROP_AZI_BALANCED = _vsp.PROP_AZI_BALANCED
NUM_PROP_AZI = _vsp.NUM_PROP_AZI
PROP_BLADE_TRADITIONAL = _vsp.PROP_BLADE_TRADITIONAL
PROP_BLADE_NONTRADITIONAL = _vsp.PROP_BLADE_NONTRADITIONAL
NUM_PROP_BLADE_MODES = _vsp.NUM_PROP_BLADE_MODES
RPM_PROP_DRIVER = _vsp.RPM_PROP_DRIVER
CT_PROP_DRIVER = _vsp.CT_PROP_DRIVER
CP_PROP_DRIVER = _vsp.CP_PROP_DRIVER
T_PROP_DRIVER = _vsp.T_PROP_DRIVER
ETA_PROP_DRIVER = _vsp.ETA_PROP_DRIVER
J_PROP_DRIVER = _vsp.J_PROP_DRIVER
P_PROP_DRIVER = _vsp.P_PROP_DRIVER
CQ_PROP_DRIVER = _vsp.CQ_PROP_DRIVER
Q_PROP_DRIVER = _vsp.Q_PROP_DRIVER
NUM_PROP_DRIVER = _vsp.NUM_PROP_DRIVER
PROP_BLADES = _vsp.PROP_BLADES
PROP_BOTH = _vsp.PROP_BOTH
PROP_DISK = _vsp.PROP_DISK
PROP_CHORD = _vsp.PROP_CHORD
PROP_TWIST = _vsp.PROP_TWIST
PROP_RAKE = _vsp.PROP_RAKE
PROP_SKEW = _vsp.PROP_SKEW
PROP_SWEEP = _vsp.PROP_SWEEP
PROP_THICK = _vsp.PROP_THICK
PROP_CLI = _vsp.PROP_CLI
PROP_AXIAL = _vsp.PROP_AXIAL
PROP_TANGENTIAL = _vsp.PROP_TANGENTIAL
NUM_PROP_PCURVE = _vsp.NUM_PROP_PCURVE
REORDER_MOVE_UP = _vsp.REORDER_MOVE_UP
REORDER_MOVE_DOWN = _vsp.REORDER_MOVE_DOWN
REORDER_MOVE_TOP = _vsp.REORDER_MOVE_TOP
REORDER_MOVE_BOTTOM = _vsp.REORDER_MOVE_BOTTOM
NUM_REORDER_TYPES = _vsp.NUM_REORDER_TYPES
MANUAL_REF = _vsp.MANUAL_REF
COMPONENT_REF = _vsp.COMPONENT_REF
NUM_REF_TYPES = _vsp.NUM_REF_TYPES
INVALID_TYPE = _vsp.INVALID_TYPE
BOOL_DATA = _vsp.BOOL_DATA
INT_DATA = _vsp.INT_DATA
DOUBLE_DATA = _vsp.DOUBLE_DATA
STRING_DATA = _vsp.STRING_DATA
VEC3D_DATA = _vsp.VEC3D_DATA
INT_MATRIX_DATA = _vsp.INT_MATRIX_DATA
DOUBLE_MATRIX_DATA = _vsp.DOUBLE_MATRIX_DATA
ATTR_COLLECTION_DATA = _vsp.ATTR_COLLECTION_DATA
PARM_REFERENCE_DATA = _vsp.PARM_REFERENCE_DATA
MESH_INDEXED_TRI = _vsp.MESH_INDEXED_TRI
MESH_SLICE_TRI = _vsp.MESH_SLICE_TRI
GEOM_XSECS = _vsp.GEOM_XSECS
MESH_INDEX_AND_SLICE_TRI = _vsp.MESH_INDEX_AND_SLICE_TRI
RHO_UNIT_SLUG_FT3 = _vsp.RHO_UNIT_SLUG_FT3
RHO_UNIT_G_CM3 = _vsp.RHO_UNIT_G_CM3
RHO_UNIT_KG_M3 = _vsp.RHO_UNIT_KG_M3
RHO_UNIT_TONNE_MM3 = _vsp.RHO_UNIT_TONNE_MM3
RHO_UNIT_LBM_FT3 = _vsp.RHO_UNIT_LBM_FT3
RHO_UNIT_LBFSEC2_IN4 = _vsp.RHO_UNIT_LBFSEC2_IN4
RHO_UNIT_LBM_IN3 = _vsp.RHO_UNIT_LBM_IN3
NUM_RHO_UNIT = _vsp.NUM_RHO_UNIT
ROUTE_PT_COMP = _vsp.ROUTE_PT_COMP
ROUTE_PT_UV = _vsp.ROUTE_PT_UV
ROUTE_PT_RST = _vsp.ROUTE_PT_RST
ROUTE_PT_LMN = _vsp.ROUTE_PT_LMN
ROUTE_PT_EtaMN = _vsp.ROUTE_PT_EtaMN
ROUTE_PT_NUM_TYPES = _vsp.ROUTE_PT_NUM_TYPES
ROUTE_PT_DELTA_XYZ = _vsp.ROUTE_PT_DELTA_XYZ
ROUTE_PT_DELTA_COMP = _vsp.ROUTE_PT_DELTA_COMP
ROUTE_PT_DELTA_UVN = _vsp.ROUTE_PT_DELTA_UVN
ROUTE_PT_DELTA_NUM_TYPES = _vsp.ROUTE_PT_DELTA_NUM_TYPES
SCALE_WIDTH = _vsp.SCALE_WIDTH
SCALE_HEIGHT = _vsp.SCALE_HEIGHT
SCALE_WIDTH_HEIGHT = _vsp.SCALE_WIDTH_HEIGHT
SCALE_RESOLUTION = _vsp.SCALE_RESOLUTION
SCALE_WIDTH_AR = _vsp.SCALE_WIDTH_AR
SCALE_HEIGHT_AR = _vsp.SCALE_HEIGHT_AR
NUM_SCALE_TYPES = _vsp.NUM_SCALE_TYPES
SET_NONE = _vsp.SET_NONE
SET_ALL = _vsp.SET_ALL
SET_SHOWN = _vsp.SET_SHOWN
SET_NOT_SHOWN = _vsp.SET_NOT_SHOWN
SET_FIRST_USER = _vsp.SET_FIRST_USER
MIN_NUM_USER = _vsp.MIN_NUM_USER
MAX_NUM_SETS = _vsp.MAX_NUM_SETS
STACK_PRESET_DEFAULT = _vsp.STACK_PRESET_DEFAULT
STACK_PRESET_CYLINDER_ENDPTS = _vsp.STACK_PRESET_CYLINDER_ENDPTS
STACK_PRESET_CYLINDER_ENDCAPS = _vsp.STACK_PRESET_CYLINDER_ENDCAPS
STACK_PRESET_FLOWTHRU_OUTLIP_ORIG = _vsp.STACK_PRESET_FLOWTHRU_OUTLIP_ORIG
STACK_PRESET_FLOWTHRU_INLIP_ORIG = _vsp.STACK_PRESET_FLOWTHRU_INLIP_ORIG
STACK_PRESET_FLOWTHRU_MID_ORIG = _vsp.STACK_PRESET_FLOWTHRU_MID_ORIG
STACK_PRESET_BOTHFACEFACE = _vsp.STACK_PRESET_BOTHFACEFACE
STACK_PRESET_BOTHLIPFACE = _vsp.STACK_PRESET_BOTHLIPFACE
STACK_PRESET_BOTHFACELIP = _vsp.STACK_PRESET_BOTHFACELIP
STACK_PRESET_BOTHLIPLIP = _vsp.STACK_PRESET_BOTHLIPLIP
STACK_PRESET_OUTFACE = _vsp.STACK_PRESET_OUTFACE
STACK_PRESET_OUTLIP = _vsp.STACK_PRESET_OUTLIP
STACK_PRESET_INFACE = _vsp.STACK_PRESET_INFACE
STACK_PRESET_INLIP = _vsp.STACK_PRESET_INLIP
STACK_PRESET_FLOWPATH_BOTH = _vsp.STACK_PRESET_FLOWPATH_BOTH
STACK_PRESET_FLOWPATH_IN = _vsp.STACK_PRESET_FLOWPATH_IN
STACK_PRESET_FLOWPATH_OUT = _vsp.STACK_PRESET_FLOWPATH_OUT
STEP_SHELL = _vsp.STEP_SHELL
STEP_BREP = _vsp.STEP_BREP
SS_INC_TREAT_AS_PARENT = _vsp.SS_INC_TREAT_AS_PARENT
SS_INC_SEPARATE_TREATMENT = _vsp.SS_INC_SEPARATE_TREATMENT
SS_INC_ZERO_DRAG = _vsp.SS_INC_ZERO_DRAG
INSIDE = _vsp.INSIDE
OUTSIDE = _vsp.OUTSIDE
NONE = _vsp.NONE
CONST_U = _vsp.CONST_U
CONST_W = _vsp.CONST_W
SS_LINE = _vsp.SS_LINE
SS_RECTANGLE = _vsp.SS_RECTANGLE
SS_ELLIPSE = _vsp.SS_ELLIPSE
SS_CONTROL = _vsp.SS_CONTROL
SS_LINE_ARRAY = _vsp.SS_LINE_ARRAY
SS_FINITE_LINE = _vsp.SS_FINITE_LINE
SS_XSEC_CURVE = _vsp.SS_XSEC_CURVE
SS_INTERSECT = _vsp.SS_INTERSECT
SS_NUM_TYPES = _vsp.SS_NUM_TYPES
SYM_XY = _vsp.SYM_XY
SYM_XZ = _vsp.SYM_XZ
SYM_YZ = _vsp.SYM_YZ
SYM_ROT_X = _vsp.SYM_ROT_X
SYM_ROT_Y = _vsp.SYM_ROT_Y
SYM_ROT_Z = _vsp.SYM_ROT_Z
SYM_PLANAR_TYPES = _vsp.SYM_PLANAR_TYPES
SYM_NUM_TYPES = _vsp.SYM_NUM_TYPES
SYM_NONE = _vsp.SYM_NONE
SYM_RL = _vsp.SYM_RL
SYM_TB = _vsp.SYM_TB
SYM_ALL = _vsp.SYM_ALL
TEMP_UNIT_K = _vsp.TEMP_UNIT_K
TEMP_UNIT_C = _vsp.TEMP_UNIT_C
TEMP_UNIT_F = _vsp.TEMP_UNIT_F
TEMP_UNIT_R = _vsp.TEMP_UNIT_R
NUM_TEMP_UNIT = _vsp.NUM_TEMP_UNIT
TIRE_NOMINAL_CLEARANCE = _vsp.TIRE_NOMINAL_CLEARANCE
TIRE_GROWTH_CLEARANCE = _vsp.TIRE_GROWTH_CLEARANCE
TIRE_CLEARANCE = _vsp.TIRE_CLEARANCE
NUM_TIRE_CLEARANCE_MODES = _vsp.NUM_TIRE_CLEARANCE_MODES
TIRE_STATIC_LODED_CONTACT = _vsp.TIRE_STATIC_LODED_CONTACT
TIRE_NOMINAL_CONTACT = _vsp.TIRE_NOMINAL_CONTACT
TIRE_GROWTH_CONTACT = _vsp.TIRE_GROWTH_CONTACT
TIRE_FLAT_CONTACT = _vsp.TIRE_FLAT_CONTACT
NUM_TIRE_CONTACT_MODES = _vsp.NUM_TIRE_CONTACT_MODES
TIRE_DIM_IN = _vsp.TIRE_DIM_IN
TIRE_DIM_MODEL = _vsp.TIRE_DIM_MODEL
TIRE_DIM_FRAC = _vsp.TIRE_DIM_FRAC
NUM_TIRE_DIM_MODES = _vsp.NUM_TIRE_DIM_MODES
TIRE_TRA = _vsp.TIRE_TRA
TIRE_FAIR_FLANGE = _vsp.TIRE_FAIR_FLANGE
TIRE_FAIR_WHEEL = _vsp.TIRE_FAIR_WHEEL
TIRE_BALLOON = _vsp.TIRE_BALLOON
TIRE_BALLOON_WHEEL = _vsp.TIRE_BALLOON_WHEEL
TIRE_BALLOON_FAIR_WHEEL = _vsp.TIRE_BALLOON_FAIR_WHEEL
NUM_TIRE_MODES = _vsp.NUM_TIRE_MODES
V_UNIT_FT_S = _vsp.V_UNIT_FT_S
V_UNIT_M_S = _vsp.V_UNIT_M_S
V_UNIT_MPH = _vsp.V_UNIT_MPH
V_UNIT_KM_HR = _vsp.V_UNIT_KM_HR
V_UNIT_KEAS = _vsp.V_UNIT_KEAS
V_UNIT_KTAS = _vsp.V_UNIT_KTAS
V_UNIT_MACH = _vsp.V_UNIT_MACH
VIEW_1 = _vsp.VIEW_1
VIEW_2HOR = _vsp.VIEW_2HOR
VIEW_2VER = _vsp.VIEW_2VER
VIEW_4 = _vsp.VIEW_4
ROT_0 = _vsp.ROT_0
ROT_90 = _vsp.ROT_90
ROT_180 = _vsp.ROT_180
ROT_270 = _vsp.ROT_270
VIEW_LEFT = _vsp.VIEW_LEFT
VIEW_RIGHT = _vsp.VIEW_RIGHT
VIEW_TOP = _vsp.VIEW_TOP
VIEW_BOTTOM = _vsp.VIEW_BOTTOM
VIEW_FRONT = _vsp.VIEW_FRONT
VIEW_REAR = _vsp.VIEW_REAR
VIEW_NONE = _vsp.VIEW_NONE
VIEW_NUM_TYPES = _vsp.VIEW_NUM_TYPES
NOISE_FLYBY = _vsp.NOISE_FLYBY
NOISE_FOOTPRINT = _vsp.NOISE_FOOTPRINT
NOISE_STEADY = _vsp.NOISE_STEADY
NOISE_SI = _vsp.NOISE_SI
NOISE_ENGLISH = _vsp.NOISE_ENGLISH
VSPAERO_PROP_STATIC = _vsp.VSPAERO_PROP_STATIC
VSPAERO_PROP_UNSTEADY = _vsp.VSPAERO_PROP_UNSTEADY
VSPAERO_PROP_PSEUDO_STEADY = _vsp.VSPAERO_PROP_PSEUDO_STEADY
VSPAERO_PROP_NUM_MODES = _vsp.VSPAERO_PROP_NUM_MODES
STABILITY_OFF = _vsp.STABILITY_OFF
STABILITY_DEFAULT = _vsp.STABILITY_DEFAULT
STABILITY_P_ANALYSIS = _vsp.STABILITY_P_ANALYSIS
STABILITY_Q_ANALYSIS = _vsp.STABILITY_Q_ANALYSIS
STABILITY_R_ANALYSIS = _vsp.STABILITY_R_ANALYSIS
STABILITY_PITCH = _vsp.STABILITY_PITCH
STABILITY_ADJOINT = _vsp.STABILITY_ADJOINT
STABILITY_NUM_TYPES = _vsp.STABILITY_NUM_TYPES
STALL_OFF = _vsp.STALL_OFF
STALL_ON = _vsp.STALL_ON
CFD_NORMAL = _vsp.CFD_NORMAL
CFD_NEGATIVE = _vsp.CFD_NEGATIVE
CFD_TRANSPARENT = _vsp.CFD_TRANSPARENT
CFD_STRUCTURE = _vsp.CFD_STRUCTURE
CFD_STIFFENER = _vsp.CFD_STIFFENER
CFD_MEASURE_DUCT = _vsp.CFD_MEASURE_DUCT
CFD_NUM_TYPES = _vsp.CFD_NUM_TYPES
NORMAL_SURF = _vsp.NORMAL_SURF
WING_SURF = _vsp.WING_SURF
DISK_SURF = _vsp.DISK_SURF
NUM_SURF_TYPES = _vsp.NUM_SURF_TYPES
WHEEL_TIRE_1LG = _vsp.WHEEL_TIRE_1LG
WHEEL_TIRE_1SM = _vsp.WHEEL_TIRE_1SM
WHEEL_TIRE_2 = _vsp.WHEEL_TIRE_2
WHEEL_TIRE_3E = _vsp.WHEEL_TIRE_3E
WHEEL_TIRE_3R = _vsp.WHEEL_TIRE_3R
WHEEL_TIRE_4 = _vsp.WHEEL_TIRE_4
NUM_WHEEL_TIRE_FAILURE_MODES = _vsp.NUM_WHEEL_TIRE_FAILURE_MODES
W_RIGHT_0 = _vsp.W_RIGHT_0
W_BOTTOM = _vsp.W_BOTTOM
W_LEFT = _vsp.W_LEFT
W_TOP = _vsp.W_TOP
W_RIGHT_1 = _vsp.W_RIGHT_1
W_FREE = _vsp.W_FREE
BLEND_FREE = _vsp.BLEND_FREE
BLEND_ANGLES = _vsp.BLEND_ANGLES
BLEND_MATCH_IN_LE_TRAP = _vsp.BLEND_MATCH_IN_LE_TRAP
BLEND_MATCH_IN_TE_TRAP = _vsp.BLEND_MATCH_IN_TE_TRAP
BLEND_MATCH_OUT_LE_TRAP = _vsp.BLEND_MATCH_OUT_LE_TRAP
BLEND_MATCH_OUT_TE_TRAP = _vsp.BLEND_MATCH_OUT_TE_TRAP
BLEND_MATCH_IN_ANGLES = _vsp.BLEND_MATCH_IN_ANGLES
BLEND_MATCH_LE_ANGLES = _vsp.BLEND_MATCH_LE_ANGLES
BLEND_NUM_TYPES = _vsp.BLEND_NUM_TYPES
AR_WSECT_DRIVER = _vsp.AR_WSECT_DRIVER
SPAN_WSECT_DRIVER = _vsp.SPAN_WSECT_DRIVER
AREA_WSECT_DRIVER = _vsp.AREA_WSECT_DRIVER
TAPER_WSECT_DRIVER = _vsp.TAPER_WSECT_DRIVER
AVEC_WSECT_DRIVER = _vsp.AVEC_WSECT_DRIVER
ROOTC_WSECT_DRIVER = _vsp.ROOTC_WSECT_DRIVER
TIPC_WSECT_DRIVER = _vsp.TIPC_WSECT_DRIVER
SECSWEEP_WSECT_DRIVER = _vsp.SECSWEEP_WSECT_DRIVER
NUM_WSECT_DRIVER = _vsp.NUM_WSECT_DRIVER
SWEEP_WSECT_DRIVER = _vsp.SWEEP_WSECT_DRIVER
SWEEPLOC_WSECT_DRIVER = _vsp.SWEEPLOC_WSECT_DRIVER
SECSWEEPLOC_WSECT_DRIVER = _vsp.SECSWEEPLOC_WSECT_DRIVER
XDDM_VAR = _vsp.XDDM_VAR
XDDM_CONST = _vsp.XDDM_CONST
CLOSE_NONE = _vsp.CLOSE_NONE
CLOSE_SKEWLOW = _vsp.CLOSE_SKEWLOW
CLOSE_SKEWUP = _vsp.CLOSE_SKEWUP
CLOSE_SKEWBOTH = _vsp.CLOSE_SKEWBOTH
CLOSE_EXTRAP = _vsp.CLOSE_EXTRAP
CLOSE_NUM_TYPES = _vsp.CLOSE_NUM_TYPES
XS_UNDEFINED = _vsp.XS_UNDEFINED
XS_POINT = _vsp.XS_POINT
XS_CIRCLE = _vsp.XS_CIRCLE
XS_ELLIPSE = _vsp.XS_ELLIPSE
XS_SUPER_ELLIPSE = _vsp.XS_SUPER_ELLIPSE
XS_ROUNDED_RECTANGLE = _vsp.XS_ROUNDED_RECTANGLE
XS_GENERAL_FUSE = _vsp.XS_GENERAL_FUSE
XS_FILE_FUSE = _vsp.XS_FILE_FUSE
XS_FOUR_SERIES = _vsp.XS_FOUR_SERIES
XS_SIX_SERIES = _vsp.XS_SIX_SERIES
XS_BICONVEX = _vsp.XS_BICONVEX
XS_WEDGE = _vsp.XS_WEDGE
XS_EDIT_CURVE = _vsp.XS_EDIT_CURVE
XS_FILE_AIRFOIL = _vsp.XS_FILE_AIRFOIL
XS_CST_AIRFOIL = _vsp.XS_CST_AIRFOIL
XS_VKT_AIRFOIL = _vsp.XS_VKT_AIRFOIL
XS_FOUR_DIGIT_MOD = _vsp.XS_FOUR_DIGIT_MOD
XS_FIVE_DIGIT = _vsp.XS_FIVE_DIGIT
XS_FIVE_DIGIT_MOD = _vsp.XS_FIVE_DIGIT_MOD
XS_ONE_SIX_SERIES = _vsp.XS_ONE_SIX_SERIES
XS_AC25_773 = _vsp.XS_AC25_773
XS_NUM_TYPES = _vsp.XS_NUM_TYPES
WIDTH_XSEC_DRIVER = _vsp.WIDTH_XSEC_DRIVER
AREA_XSEC_DRIVER = _vsp.AREA_XSEC_DRIVER
HEIGHT_XSEC_DRIVER = _vsp.HEIGHT_XSEC_DRIVER
HWRATIO_XSEC_DRIVER = _vsp.HWRATIO_XSEC_DRIVER
NUM_XSEC_DRIVER = _vsp.NUM_XSEC_DRIVER
CIRCLE_NUM_XSEC_DRIVER = _vsp.CIRCLE_NUM_XSEC_DRIVER
FLAP_NONE = _vsp.FLAP_NONE
FLAP_PLAIN = _vsp.FLAP_PLAIN
FLAP_NUM_TYPES = _vsp.FLAP_NUM_TYPES
XSEC_BOTH_SIDES = _vsp.XSEC_BOTH_SIDES
XSEC_LEFT_SIDE = _vsp.XSEC_LEFT_SIDE
XSEC_RIGHT_SIDE = _vsp.XSEC_RIGHT_SIDE
TRIM_NONE = _vsp.TRIM_NONE
TRIM_X = _vsp.TRIM_X
TRIM_THICK = _vsp.TRIM_THICK
TRIM_NUM_TYPES = _vsp.TRIM_NUM_TYPES
XSEC_FUSE = _vsp.XSEC_FUSE
XSEC_STACK = _vsp.XSEC_STACK
XSEC_WING = _vsp.XSEC_WING
XSEC_CUSTOM = _vsp.XSEC_CUSTOM
XSEC_PROP = _vsp.XSEC_PROP
XSEC_NUM_TYPES = _vsp.XSEC_NUM_TYPES
XS_SHIFT_LE = _vsp.XS_SHIFT_LE
XS_SHIFT_MID = _vsp.XS_SHIFT_MID
XS_SHIFT_TE = _vsp.XS_SHIFT_TE
[docs] class ErrorObj(_object): """Proxy of C++ vsp::ErrorObj class.""" __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, ErrorObj, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, ErrorObj, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(vsp::ErrorObj self) -> ErrorObj __init__(vsp::ErrorObj self, vsp::ERROR_CODE err_code, string const & err_str) -> ErrorObj __init__(vsp::ErrorObj self, ErrorObj arg2) -> ErrorObj """ this = _vsp.new_ErrorObj(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _vsp.delete_ErrorObj __del__ = lambda self: None
[docs] def GetErrorCode(self): """GetErrorCode(ErrorObj self) -> vsp::ERROR_CODE""" return _vsp.ErrorObj_GetErrorCode(self)
[docs] def GetErrorString(self): """GetErrorString(ErrorObj self) -> string""" return _vsp.ErrorObj_GetErrorString(self)
__swig_setmethods__["m_ErrorCode"] = _vsp.ErrorObj_m_ErrorCode_set __swig_getmethods__["m_ErrorCode"] = _vsp.ErrorObj_m_ErrorCode_get if _newclass: m_ErrorCode = _swig_property(_vsp.ErrorObj_m_ErrorCode_get, _vsp.ErrorObj_m_ErrorCode_set) __swig_setmethods__["m_ErrorString"] = _vsp.ErrorObj_m_ErrorString_set __swig_getmethods__["m_ErrorString"] = _vsp.ErrorObj_m_ErrorString_get if _newclass: m_ErrorString = _swig_property(_vsp.ErrorObj_m_ErrorString_get, _vsp.ErrorObj_m_ErrorString_set)
[docs] def NoError(self): """NoError(ErrorObj self)""" return _vsp.ErrorObj_NoError(self)
ErrorObj_swigregister = _vsp.ErrorObj_swigregister ErrorObj_swigregister(ErrorObj)
[docs] class ErrorMgrSingleton(_object): """Proxy of C++ vsp::ErrorMgrSingleton class.""" __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, ErrorMgrSingleton, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, ErrorMgrSingleton, name) def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") __repr__ = _swig_repr
[docs] def GetErrorLastCallFlag(self): """GetErrorLastCallFlag(ErrorMgrSingleton self) -> bool""" return _vsp.ErrorMgrSingleton_GetErrorLastCallFlag(self)
[docs] def GetNumTotalErrors(self): """GetNumTotalErrors(ErrorMgrSingleton self) -> int""" return _vsp.ErrorMgrSingleton_GetNumTotalErrors(self)
[docs] def PopLastError(self): """PopLastError(ErrorMgrSingleton self) -> ErrorObj""" return _vsp.ErrorMgrSingleton_PopLastError(self)
[docs] def GetLastError(self): """GetLastError(ErrorMgrSingleton self) -> ErrorObj""" return _vsp.ErrorMgrSingleton_GetLastError(self)
[docs] def PopErrorAndPrint(self, stream): """PopErrorAndPrint(ErrorMgrSingleton self, FILE * stream) -> bool""" return _vsp.ErrorMgrSingleton_PopErrorAndPrint(self, stream)
[docs] def SilenceErrors(self): """SilenceErrors(ErrorMgrSingleton self)""" return _vsp.ErrorMgrSingleton_SilenceErrors(self)
[docs] def PrintOnErrors(self): """PrintOnErrors(ErrorMgrSingleton self)""" return _vsp.ErrorMgrSingleton_PrintOnErrors(self)
[docs] def AddError(self, code, desc): """AddError(ErrorMgrSingleton self, vsp::ERROR_CODE code, string const & desc)""" return _vsp.ErrorMgrSingleton_AddError(self, code, desc)
[docs] def NoError(self): """NoError(ErrorMgrSingleton self)""" return _vsp.ErrorMgrSingleton_NoError(self)
[docs] def MessageCallback(self, arg2, data): """MessageCallback(ErrorMgrSingleton self, MessageBase const * arg2, MessageData const & data)""" return _vsp.ErrorMgrSingleton_MessageCallback(self, arg2, data)
[docs] def getInstance(): """getInstance() -> ErrorMgrSingleton""" return _vsp.ErrorMgrSingleton_getInstance()
getInstance = staticmethod(getInstance)
ErrorMgrSingleton_swigregister = _vsp.ErrorMgrSingleton_swigregister ErrorMgrSingleton_swigregister(ErrorMgrSingleton) def ErrorMgrSingleton_getInstance(): """ErrorMgrSingleton_getInstance() -> ErrorMgrSingleton""" return _vsp.ErrorMgrSingleton_getInstance()
[docs] def VSPCheckSetup(): """VSPCheckSetup()""" return _vsp.VSPCheckSetup()
[docs] def VSPRenew(): """VSPRenew()""" return _vsp.VSPRenew()
[docs] def Update(update_managers=True): """ Update(bool update_managers=True) Update() """ return _vsp.Update(update_managers)
[docs] def VSPExit(error_code): """VSPExit(int error_code)""" return _vsp.VSPExit(error_code)
[docs] def VSPCrash(crash_type): """VSPCrash(int crash_type)""" return _vsp.VSPCrash(crash_type)
[docs] def GetAndResetUpdateCount(): """GetAndResetUpdateCount() -> int""" return _vsp.GetAndResetUpdateCount()
[docs] def Print(*args): """ Print(std::string const & data, bool new_line=True) Print(std::string const & data) Print(vec3d data, bool new_line=True) Print(vec3d data) Print(double data, bool new_line=True) Print(double data) Print(int data, bool new_line=True) Print(int data) """ return _vsp.Print(*args)
[docs] def Min(x, y): """Min(double x, double y) -> double""" return _vsp.Min(x, y)
[docs] def Max(x, y): """Max(double x, double y) -> double""" return _vsp.Max(x, y)
[docs] def Rad2Deg(r): """Rad2Deg(double r) -> double""" return _vsp.Rad2Deg(r)
[docs] def Deg2Rad(d): """Deg2Rad(double d) -> double""" return _vsp.Deg2Rad(d)
[docs] def GetVSPVersion(): """GetVSPVersion() -> std::string""" return _vsp.GetVSPVersion()
[docs] def GetVSPVersionMajor(): """GetVSPVersionMajor() -> int""" return _vsp.GetVSPVersionMajor()
[docs] def GetVSPVersionMinor(): """GetVSPVersionMinor() -> int""" return _vsp.GetVSPVersionMinor()
[docs] def GetVSPVersionChange(): """GetVSPVersionChange() -> int""" return _vsp.GetVSPVersionChange()
[docs] def GetVSPExePath(): """GetVSPExePath() -> std::string""" return _vsp.GetVSPExePath()
[docs] def SetVSPAEROPath(path): """SetVSPAEROPath(std::string const & path) -> bool""" return _vsp.SetVSPAEROPath(path)
[docs] def GetVSPAEROPath(): """GetVSPAEROPath() -> std::string""" return _vsp.GetVSPAEROPath()
[docs] def CheckForVSPAERO(path): """CheckForVSPAERO(std::string const & path) -> bool""" return _vsp.CheckForVSPAERO(path)
[docs] def SetVSPHelpPath(path): """SetVSPHelpPath(std::string const & path) -> bool""" return _vsp.SetVSPHelpPath(path)
[docs] def GetVSPHelpPath(): """GetVSPHelpPath() -> std::string""" return _vsp.GetVSPHelpPath()
[docs] def CheckForVSPHelp(path): """CheckForVSPHelp(std::string const & path) -> bool""" return _vsp.CheckForVSPHelp(path)
def RegisterCFDMeshAnalyses(): """RegisterCFDMeshAnalyses()""" return _vsp.RegisterCFDMeshAnalyses()
[docs] def ReadVSPFile(file_name): """ReadVSPFile(std::string const & file_name)""" return _vsp.ReadVSPFile(file_name)
[docs] def WriteVSPFile(*args): """ WriteVSPFile(std::string const & file_name, int set) WriteVSPFile(std::string const & file_name) """ return _vsp.WriteVSPFile(*args)
[docs] def SetVSP3FileName(file_name): """SetVSP3FileName(std::string const & file_name)""" return _vsp.SetVSP3FileName(file_name)
[docs] def GetVSPFileName(): """GetVSPFileName() -> std::string""" return _vsp.GetVSPFileName()
[docs] def ClearVSPModel(): """ClearVSPModel()""" return _vsp.ClearVSPModel()
[docs] def InsertVSPFile(file_name, parent_geom_id): """InsertVSPFile(std::string const & file_name, std::string const & parent_geom_id)""" return _vsp.InsertVSPFile(file_name, parent_geom_id)
[docs] def ExportFile(*args): """ ExportFile(std::string const & file_name, int thick_set, int file_type, int subsFlag=1, int thin_set, bool useMode=False, std::string const & modeID) -> std::string ExportFile(std::string const & file_name, int thick_set, int file_type, int subsFlag=1, int thin_set, bool useMode=False) -> std::string ExportFile(std::string const & file_name, int thick_set, int file_type, int subsFlag=1, int thin_set) -> std::string ExportFile(std::string const & file_name, int thick_set, int file_type, int subsFlag=1) -> std::string ExportFile(std::string const & file_name, int thick_set, int file_type) -> std::string """ return _vsp.ExportFile(*args)
[docs] def ImportFile(file_name, file_type, parent): """ImportFile(std::string const & file_name, int file_type, std::string const & parent) -> std::string""" return _vsp.ImportFile(file_name, file_type, parent)
[docs] def GetBEMPropID(): """GetBEMPropID() -> std::string""" return _vsp.GetBEMPropID()
[docs] def SetBEMPropID(prop_id): """SetBEMPropID(std::string const & prop_id)""" return _vsp.SetBEMPropID(prop_id)
[docs] def ReadApplyDESFile(file_name): """ReadApplyDESFile(std::string const & file_name)""" return _vsp.ReadApplyDESFile(file_name)
[docs] def WriteDESFile(file_name): """WriteDESFile(std::string const & file_name)""" return _vsp.WriteDESFile(file_name)
[docs] def ReadApplyXDDMFile(file_name): """ReadApplyXDDMFile(std::string const & file_name)""" return _vsp.ReadApplyXDDMFile(file_name)
[docs] def WriteXDDMFile(file_name): """WriteXDDMFile(std::string const & file_name)""" return _vsp.WriteXDDMFile(file_name)
[docs] def GetNumDesignVars(): """GetNumDesignVars() -> int""" return _vsp.GetNumDesignVars()
[docs] def AddDesignVar(parm_id, type): """AddDesignVar(std::string const & parm_id, int type)""" return _vsp.AddDesignVar(parm_id, type)
[docs] def DeleteAllDesignVars(): """DeleteAllDesignVars()""" return _vsp.DeleteAllDesignVars()
[docs] def GetDesignVar(index): """GetDesignVar(int index) -> std::string""" return _vsp.GetDesignVar(index)
[docs] def GetDesignVarType(index): """GetDesignVarType(int index) -> int""" return _vsp.GetDesignVarType(index)
[docs] def GetComputationFileName(file_type): """GetComputationFileName(int file_type) -> std::string""" return _vsp.GetComputationFileName(file_type)
[docs] def SetComputationFileName(file_type, file_name): """SetComputationFileName(int file_type, std::string const & file_name)""" return _vsp.SetComputationFileName(file_type, file_name)
[docs] def ComputeMassProps(set, num_slices, idir): """ComputeMassProps(int set, int num_slices, int idir) -> std::string""" return _vsp.ComputeMassProps(set, num_slices, idir)
[docs] def ComputeCompGeom(set, half_mesh, file_export_types): """ComputeCompGeom(int set, bool half_mesh, int file_export_types) -> std::string""" return _vsp.ComputeCompGeom(set, half_mesh, file_export_types)
[docs] def ComputePlaneSlice(set, num_slices, norm, auto_bnd, start_bnd=0, end_bnd=0, measureduct=False): """ ComputePlaneSlice(int set, int num_slices, vec3d norm, bool auto_bnd, double start_bnd=0, double end_bnd=0, bool measureduct=False) -> std::string ComputePlaneSlice(int set, int num_slices, vec3d norm, bool auto_bnd, double start_bnd=0, double end_bnd=0) -> std::string ComputePlaneSlice(int set, int num_slices, vec3d norm, bool auto_bnd, double start_bnd=0) -> std::string ComputePlaneSlice(int set, int num_slices, vec3d norm, bool auto_bnd) -> std::string """ return _vsp.ComputePlaneSlice(set, num_slices, norm, auto_bnd, start_bnd, end_bnd, measureduct)
[docs] def ComputeDegenGeom(set, file_export_types): """ComputeDegenGeom(int set, int file_export_types)""" return _vsp.ComputeDegenGeom(set, file_export_types)
[docs] def ComputeCFDMesh(set, degenset, file_export_types): """ComputeCFDMesh(int set, int degenset, int file_export_types)""" return _vsp.ComputeCFDMesh(set, degenset, file_export_types)
[docs] def GetCFDMeshVal(type): """GetCFDMeshVal(int type) -> double""" return _vsp.GetCFDMeshVal(type)
[docs] def SetCFDMeshVal(type, val): """SetCFDMeshVal(int type, double val)""" return _vsp.SetCFDMeshVal(type, val)
[docs] def GetCFDWakeFlag(geom_id): """GetCFDWakeFlag(std::string const & geom_id) -> bool""" return _vsp.GetCFDWakeFlag(geom_id)
[docs] def SetCFDWakeFlag(geom_id, flag): """SetCFDWakeFlag(std::string const & geom_id, bool flag)""" return _vsp.SetCFDWakeFlag(geom_id, flag)
[docs] def SetCFDFarFieldGeomID(geom_id): """SetCFDFarFieldGeomID(std::string const & geom_id)""" return _vsp.SetCFDFarFieldGeomID(geom_id)
[docs] def GetCFDFarFieldGeomID(): """GetCFDFarFieldGeomID() -> std::string""" return _vsp.GetCFDFarFieldGeomID()
[docs] def GetNumCFDSources(geom_id): """GetNumCFDSources(std::string const & geom_id) -> int""" return _vsp.GetNumCFDSources(geom_id)
[docs] def GetCFDSourceName(geom_id, source_index): """GetCFDSourceName(std::string const & geom_id, int source_index) -> std::string""" return _vsp.GetCFDSourceName(geom_id, source_index)
[docs] def SetCFDSourceName(geom_id, source_index, name): """SetCFDSourceName(std::string const & geom_id, int source_index, std::string const & name)""" return _vsp.SetCFDSourceName(geom_id, source_index, name)
[docs] def GetCFDSourceType(geom_id, source_index): """GetCFDSourceType(std::string const & geom_id, int source_index) -> int""" return _vsp.GetCFDSourceType(geom_id, source_index)
[docs] def DeleteCFDSource(geom_id, source_index): """DeleteCFDSource(std::string const & geom_id, int source_index)""" return _vsp.DeleteCFDSource(geom_id, source_index)
[docs] def DeleteAllCFDSources(): """DeleteAllCFDSources()""" return _vsp.DeleteAllCFDSources()
[docs] def GetCFDSourceID(geom_id, source_index): """GetCFDSourceID(std::string const & geom_id, int source_index) -> std::string""" return _vsp.GetCFDSourceID(geom_id, source_index)
[docs] def AdjustAllCFDSourceLen(mult): """AdjustAllCFDSourceLen(double mult)""" return _vsp.AdjustAllCFDSourceLen(mult)
[docs] def AdjustAllCFDSourceRad(mult): """AdjustAllCFDSourceRad(double mult)""" return _vsp.AdjustAllCFDSourceRad(mult)
[docs] def AddDefaultSources(): """AddDefaultSources()""" return _vsp.AddDefaultSources()
[docs] def AddCFDSource(type, geom_id, surf_index, l1, r1, u1, w1, l2=0, r2=0, u2=0, w2=0): """ 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) 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) 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) AddCFDSource(int type, std::string const & geom_id, int surf_index, double l1, double r1, double u1, double w1, double l2=0) AddCFDSource(int type, std::string const & geom_id, int surf_index, double l1, double r1, double u1, double w1) """ return _vsp.AddCFDSource(type, geom_id, surf_index, l1, r1, u1, w1, l2, r2, u2, w2)
[docs] def GetVSPAERORefWingID(): """GetVSPAERORefWingID() -> std::string""" return _vsp.GetVSPAERORefWingID()
[docs] def SetVSPAERORefWingID(geom_id): """SetVSPAERORefWingID(std::string const & geom_id) -> std::string""" return _vsp.SetVSPAERORefWingID(geom_id)
[docs] def GetNumAnalysis(): """GetNumAnalysis() -> int""" return _vsp.GetNumAnalysis()
[docs] def ListAnalysis(): """ListAnalysis() -> StringVector""" return _vsp.ListAnalysis()
[docs] def GetAnalysisInputNames(analysis): """GetAnalysisInputNames(std::string const & analysis) -> StringVector""" return _vsp.GetAnalysisInputNames(analysis)
[docs] def GetAnalysisDoc(analysis): """GetAnalysisDoc(std::string const & analysis) -> std::string""" return _vsp.GetAnalysisDoc(analysis)
[docs] def GetAnalysisInputDoc(analysis, name): """GetAnalysisInputDoc(std::string const & analysis, std::string const & name) -> std::string""" return _vsp.GetAnalysisInputDoc(analysis, name)
[docs] def ExecAnalysis(analysis): """ExecAnalysis(std::string const & analysis) -> std::string""" return _vsp.ExecAnalysis(analysis)
[docs] def GetNumAnalysisInputData(analysis, name): """GetNumAnalysisInputData(std::string const & analysis, std::string const & name) -> int""" return _vsp.GetNumAnalysisInputData(analysis, name)
[docs] def GetAnalysisInputType(analysis, name): """GetAnalysisInputType(std::string const & analysis, std::string const & name) -> int""" return _vsp.GetAnalysisInputType(analysis, name)
[docs] def GetIntAnalysisInput(analysis, name, index=0): """ GetIntAnalysisInput(std::string const & analysis, std::string const & name, int index=0) -> IntVector GetIntAnalysisInput(std::string const & analysis, std::string const & name) -> IntVector """ return _vsp.GetIntAnalysisInput(analysis, name, index)
[docs] def GetDoubleAnalysisInput(analysis, name, index=0): """ GetDoubleAnalysisInput(std::string const & analysis, std::string const & name, int index=0) -> DoubleVector GetDoubleAnalysisInput(std::string const & analysis, std::string const & name) -> DoubleVector """ return _vsp.GetDoubleAnalysisInput(analysis, name, index)
[docs] def GetStringAnalysisInput(analysis, name, index=0): """ GetStringAnalysisInput(std::string const & analysis, std::string const & name, int index=0) -> StringVector GetStringAnalysisInput(std::string const & analysis, std::string const & name) -> StringVector """ return _vsp.GetStringAnalysisInput(analysis, name, index)
[docs] def GetVec3dAnalysisInput(analysis, name, index=0): """ GetVec3dAnalysisInput(std::string const & analysis, std::string const & name, int index=0) -> Vec3dVec GetVec3dAnalysisInput(std::string const & analysis, std::string const & name) -> Vec3dVec """ return _vsp.GetVec3dAnalysisInput(analysis, name, index)
[docs] def SetAnalysisInputDefaults(analysis): """SetAnalysisInputDefaults(std::string const & analysis)""" return _vsp.SetAnalysisInputDefaults(analysis)
[docs] def SetIntAnalysisInput(analysis, name, indata, index=0): """ SetIntAnalysisInput(std::string const & analysis, std::string const & name, IntVector indata, int index=0) SetIntAnalysisInput(std::string const & analysis, std::string const & name, IntVector indata) """ return _vsp.SetIntAnalysisInput(analysis, name, indata, index)
[docs] def SetDoubleAnalysisInput(analysis, name, indata, index=0): """ SetDoubleAnalysisInput(std::string const & analysis, std::string const & name, DoubleVector indata, int index=0) SetDoubleAnalysisInput(std::string const & analysis, std::string const & name, DoubleVector indata) """ return _vsp.SetDoubleAnalysisInput(analysis, name, indata, index)
[docs] def SetStringAnalysisInput(analysis, name, indata, index=0): """ SetStringAnalysisInput(std::string const & analysis, std::string const & name, StringVector indata, int index=0) SetStringAnalysisInput(std::string const & analysis, std::string const & name, StringVector indata) """ return _vsp.SetStringAnalysisInput(analysis, name, indata, index)
[docs] def SetVec3dAnalysisInput(analysis, name, indata, index=0): """ SetVec3dAnalysisInput(std::string const & analysis, std::string const & name, Vec3dVec indata, int index=0) SetVec3dAnalysisInput(std::string const & analysis, std::string const & name, Vec3dVec indata) """ return _vsp.SetVec3dAnalysisInput(analysis, name, indata, index)
[docs] def PrintAnalysisInputs(analysis_name): """PrintAnalysisInputs(std::string const & analysis_name)""" return _vsp.PrintAnalysisInputs(analysis_name)
[docs] def PrintAnalysisDocs(analysis_name): """PrintAnalysisDocs(std::string const & analysis_name)""" return _vsp.PrintAnalysisDocs(analysis_name)
[docs] def AddGeometryAnalysis(): """AddGeometryAnalysis() -> std::string""" return _vsp.AddGeometryAnalysis()
[docs] def AddGeometryAnalysisAzEl(geom_analysis_id, azimuth, elevation): """AddGeometryAnalysisAzEl(std::string const & geom_analysis_id, double azimuth, double elevation)""" return _vsp.AddGeometryAnalysisAzEl(geom_analysis_id, azimuth, elevation)
[docs] def DeleteGeometryAnalysisAzEl(geom_analysis_id, index): """DeleteGeometryAnalysisAzEl(std::string const & geom_analysis_id, int index)""" return _vsp.DeleteGeometryAnalysisAzEl(geom_analysis_id, index)
[docs] def DeleteAllGeometryAnalysisAzEl(geom_analysis_id): """DeleteAllGeometryAnalysisAzEl(std::string const & geom_analysis_id)""" return _vsp.DeleteAllGeometryAnalysisAzEl(geom_analysis_id)
[docs] def GetNumGeometryAnalysisAzEl(geom_analysis_id): """GetNumGeometryAnalysisAzEl(std::string const & geom_analysis_id) -> int""" return _vsp.GetNumGeometryAnalysisAzEl(geom_analysis_id)
[docs] def GetGeometryAnalysisAzimuthParm(geom_analysis_id, index): """GetGeometryAnalysisAzimuthParm(std::string const & geom_analysis_id, int index) -> std::string""" return _vsp.GetGeometryAnalysisAzimuthParm(geom_analysis_id, index)
[docs] def GetGeometryAnalysisElevationParm(geom_analysis_id, index): """GetGeometryAnalysisElevationParm(std::string const & geom_analysis_id, int index) -> std::string""" return _vsp.GetGeometryAnalysisElevationParm(geom_analysis_id, index)
[docs] def DeleteGeometryAnalysis(id): """DeleteGeometryAnalysis(std::string const & id)""" return _vsp.DeleteGeometryAnalysis(id)
[docs] def DeleteAllGeometryAnalyses(): """DeleteAllGeometryAnalyses()""" return _vsp.DeleteAllGeometryAnalyses()
[docs] def GetAllGeometryAnalysesIDVec(): """GetAllGeometryAnalysesIDVec() -> StringVector""" return _vsp.GetAllGeometryAnalysesIDVec()
[docs] def SetActiveGeometryAnalysis(id): """SetActiveGeometryAnalysis(std::string const & id)""" return _vsp.SetActiveGeometryAnalysis(id)
[docs] def GetActiveGeometryAnalysis(): """GetActiveGeometryAnalysis() -> std::string""" return _vsp.GetActiveGeometryAnalysis()
[docs] def MakeMeshGeom(ga_id): """MakeMeshGeom(std::string const & ga_id) -> std::string""" return _vsp.MakeMeshGeom(ga_id)
[docs] def SummarizeAttributes(): """SummarizeAttributes() -> std::string""" return _vsp.SummarizeAttributes()
[docs] def SummarizeAttributesAsTree(): """SummarizeAttributesAsTree() -> std::string""" return _vsp.SummarizeAttributesAsTree()
[docs] def FindAllAttributes(): """FindAllAttributes() -> StringVector""" return _vsp.FindAllAttributes()
[docs] def FindAttributesByName(search_str): """FindAttributesByName(std::string const & search_str) -> StringVector""" return _vsp.FindAttributesByName(search_str)
[docs] def FindAttributeByName(search_str, index): """FindAttributeByName(std::string const & search_str, int index) -> std::string""" return _vsp.FindAttributeByName(search_str, index)
[docs] def FindAttributeInCollection(obj_id, search_str, index): """FindAttributeInCollection(std::string const & obj_id, std::string const & search_str, int index) -> std::string""" return _vsp.FindAttributeInCollection(obj_id, search_str, index)
[docs] def FindAttributeNamesInCollection(collID): """FindAttributeNamesInCollection(std::string const & collID) -> StringVector""" return _vsp.FindAttributeNamesInCollection(collID)
[docs] def FindAttributesInCollection(collID): """FindAttributesInCollection(std::string const & collID) -> StringVector""" return _vsp.FindAttributesInCollection(collID)
[docs] def FindAttributedObjects(): """FindAttributedObjects() -> StringVector""" return _vsp.FindAttributedObjects()
[docs] def GetObjectType(attachID): """GetObjectType(std::string const & attachID) -> int""" return _vsp.GetObjectType(attachID)
[docs] def GetObjectTypeName(attachID): """GetObjectTypeName(std::string const & attachID) -> std::string""" return _vsp.GetObjectTypeName(attachID)
[docs] def GetObjectName(attachID): """GetObjectName(std::string const & attachID) -> std::string""" return _vsp.GetObjectName(attachID)
[docs] def GetObjectParent(id): """GetObjectParent(std::string const & id) -> std::string""" return _vsp.GetObjectParent(id)
[docs] def GetChildCollection(attachID): """GetChildCollection(std::string const & attachID) -> std::string""" return _vsp.GetChildCollection(attachID)
[docs] def GetGeomSetCollection(index): """GetGeomSetCollection(int const & index) -> std::string""" return _vsp.GetGeomSetCollection(index)
[docs] def GetAttributeName(attrID): """GetAttributeName(std::string const & attrID) -> std::string""" return _vsp.GetAttributeName(attrID)
[docs] def GetAttributeID(collID, attributeName, index): """GetAttributeID(std::string const & collID, std::string const & attributeName, int index) -> std::string""" return _vsp.GetAttributeID(collID, attributeName, index)
[docs] def GetAttributeDoc(attrID): """GetAttributeDoc(std::string const & attrID) -> std::string""" return _vsp.GetAttributeDoc(attrID)
[docs] def GetAttributeType(attrID): """GetAttributeType(std::string const & attrID) -> int""" return _vsp.GetAttributeType(attrID)
[docs] def GetAttributeTypeName(attrID): """GetAttributeTypeName(std::string const & attrID) -> std::string""" return _vsp.GetAttributeTypeName(attrID)
[docs] def GetAttributeBoolVal(attrID): """GetAttributeBoolVal(std::string const & attrID) -> IntVector""" return _vsp.GetAttributeBoolVal(attrID)
[docs] def GetAttributeIntVal(attrID): """GetAttributeIntVal(std::string const & attrID) -> IntVector""" return _vsp.GetAttributeIntVal(attrID)
[docs] def GetAttributeDoubleVal(attrID): """GetAttributeDoubleVal(std::string const & attrID) -> DoubleVector""" return _vsp.GetAttributeDoubleVal(attrID)
[docs] def GetAttributeStringVal(attrID): """GetAttributeStringVal(std::string const & attrID) -> StringVector""" return _vsp.GetAttributeStringVal(attrID)
[docs] def GetAttributeParmID(attrID): """GetAttributeParmID(std::string const & attrID) -> StringVector""" return _vsp.GetAttributeParmID(attrID)
[docs] def GetAttributeParmVal(attrID): """GetAttributeParmVal(std::string const & attrID) -> DoubleVector""" return _vsp.GetAttributeParmVal(attrID)
[docs] def GetAttributeParmName(attrID): """GetAttributeParmName(std::string const & attrID) -> StringVector""" return _vsp.GetAttributeParmName(attrID)
[docs] def GetAttributeVec3dVal(attrID): """GetAttributeVec3dVal(std::string const & attrID) -> Vec3dVec""" return _vsp.GetAttributeVec3dVal(attrID)
[docs] def GetAttributeIntMatrixVal(attrID): """GetAttributeIntMatrixVal(std::string const & attrID) -> IntVecVec""" return _vsp.GetAttributeIntMatrixVal(attrID)
[docs] def GetAttributeDoubleMatrixVal(attrID): """GetAttributeDoubleMatrixVal(std::string const & attrID) -> DoubleVecVec""" return _vsp.GetAttributeDoubleMatrixVal(attrID)
[docs] def SetAttributeName(attrID, name): """SetAttributeName(std::string const & attrID, std::string const & name)""" return _vsp.SetAttributeName(attrID, name)
[docs] def SetAttributeDoc(attrID, doc): """SetAttributeDoc(std::string const & attrID, std::string const & doc)""" return _vsp.SetAttributeDoc(attrID, doc)
[docs] def SetAttributeBool(attrID, value): """SetAttributeBool(std::string const & attrID, bool value)""" return _vsp.SetAttributeBool(attrID, value)
[docs] def SetAttributeInt(attrID, value): """SetAttributeInt(std::string const & attrID, int value)""" return _vsp.SetAttributeInt(attrID, value)
[docs] def SetAttributeDouble(attrID, value): """SetAttributeDouble(std::string const & attrID, double value)""" return _vsp.SetAttributeDouble(attrID, value)
[docs] def SetAttributeString(attrID, value): """SetAttributeString(std::string const & attrID, std::string const & value)""" return _vsp.SetAttributeString(attrID, value)
[docs] def SetAttributeParmID(attrID, value): """SetAttributeParmID(std::string const & attrID, std::string const & value)""" return _vsp.SetAttributeParmID(attrID, value)
[docs] def SetAttributeVec3d(attrID, value): """SetAttributeVec3d(std::string const & attrID, Vec3dVec value)""" return _vsp.SetAttributeVec3d(attrID, value)
[docs] def SetAttributeIntMatrix(attrID, value): """SetAttributeIntMatrix(std::string const & attrID, IntVecVec value)""" return _vsp.SetAttributeIntMatrix(attrID, value)
[docs] def SetAttributeDoubleMatrix(attrID, value): """SetAttributeDoubleMatrix(std::string const & attrID, DoubleVecVec value)""" return _vsp.SetAttributeDoubleMatrix(attrID, value)
[docs] def DeleteAttribute(attrID): """DeleteAttribute(std::string const & attrID)""" return _vsp.DeleteAttribute(attrID)
[docs] def AddAttributeBool(collID, attributeName, value): """AddAttributeBool(std::string const & collID, std::string const & attributeName, bool value) -> std::string""" return _vsp.AddAttributeBool(collID, attributeName, value)
[docs] def AddAttributeInt(collID, attributeName, value): """AddAttributeInt(std::string const & collID, std::string const & attributeName, int value) -> std::string""" return _vsp.AddAttributeInt(collID, attributeName, value)
[docs] def AddAttributeDouble(collID, attributeName, value): """AddAttributeDouble(std::string const & collID, std::string const & attributeName, double value) -> std::string""" return _vsp.AddAttributeDouble(collID, attributeName, value)
[docs] def AddAttributeString(collID, attributeName, value): """AddAttributeString(std::string const & collID, std::string const & attributeName, std::string const & value) -> std::string""" return _vsp.AddAttributeString(collID, attributeName, value)
[docs] def AddAttributeParm(collID, attributeName, parmID): """AddAttributeParm(std::string const & collID, std::string const & attributeName, std::string const & parmID) -> std::string""" return _vsp.AddAttributeParm(collID, attributeName, parmID)
[docs] def AddAttributeVec3d(collID, attributeName, value): """AddAttributeVec3d(std::string const & collID, std::string const & attributeName, Vec3dVec value) -> std::string""" return _vsp.AddAttributeVec3d(collID, attributeName, value)
[docs] def AddAttributeIntMatrix(collID, attributeName, value): """AddAttributeIntMatrix(std::string const & collID, std::string const & attributeName, IntVecVec value) -> std::string""" return _vsp.AddAttributeIntMatrix(collID, attributeName, value)
[docs] def AddAttributeDoubleMatrix(collID, attributeName, value): """AddAttributeDoubleMatrix(std::string const & collID, std::string const & attributeName, DoubleVecVec value) -> std::string""" return _vsp.AddAttributeDoubleMatrix(collID, attributeName, value)
[docs] def AddAttributeGroup(collID, attributeName): """AddAttributeGroup(std::string const & collID, std::string const & attributeName) -> std::string""" return _vsp.AddAttributeGroup(collID, attributeName)
[docs] def CopyAttribute(attrID): """CopyAttribute(std::string const & attrID) -> int""" return _vsp.CopyAttribute(attrID)
[docs] def CutAttribute(attrID): """CutAttribute(std::string const & attrID)""" return _vsp.CutAttribute(attrID)
[docs] def PasteAttribute(coll_id): """PasteAttribute(std::string const & coll_id) -> StringVector""" return _vsp.PasteAttribute(coll_id)
[docs] def GetAllResultsNames(): """GetAllResultsNames() -> StringVector""" return _vsp.GetAllResultsNames()
[docs] def GetAllDataNames(results_id): """GetAllDataNames(std::string const & results_id) -> StringVector""" return _vsp.GetAllDataNames(results_id)
[docs] def GetNumResults(name): """GetNumResults(std::string const & name) -> int""" return _vsp.GetNumResults(name)
[docs] def GetResultsName(results_id): """GetResultsName(std::string const & results_id) -> std::string""" return _vsp.GetResultsName(results_id)
[docs] def GetResultsSetDoc(results_id): """GetResultsSetDoc(std::string const & results_id) -> std::string""" return _vsp.GetResultsSetDoc(results_id)
[docs] def GetResultsEntryDoc(results_id, data_name): """GetResultsEntryDoc(std::string const & results_id, std::string const & data_name) -> std::string""" return _vsp.GetResultsEntryDoc(results_id, data_name)
[docs] def FindResultsID(name, index=0): """ FindResultsID(std::string const & name, int index=0) -> std::string FindResultsID(std::string const & name) -> std::string """ return _vsp.FindResultsID(name, index)
[docs] def FindLatestResultsID(name): """FindLatestResultsID(std::string const & name) -> std::string""" return _vsp.FindLatestResultsID(name)
[docs] def GetNumData(results_id, data_name): """GetNumData(std::string const & results_id, std::string const & data_name) -> int""" return _vsp.GetNumData(results_id, data_name)
[docs] def GetResultsType(results_id, data_name): """GetResultsType(std::string const & results_id, std::string const & data_name) -> int""" return _vsp.GetResultsType(results_id, data_name)
[docs] def GetIntResults(id, name, index=0): """ GetIntResults(std::string const & id, std::string const & name, int index=0) -> IntVector GetIntResults(std::string const & id, std::string const & name) -> IntVector """ return _vsp.GetIntResults(id, name, index)
[docs] def GetDoubleResults(id, name, index=0): """ GetDoubleResults(std::string const & id, std::string const & name, int index=0) -> DoubleVector GetDoubleResults(std::string const & id, std::string const & name) -> DoubleVector """ return _vsp.GetDoubleResults(id, name, index)
[docs] def GetDoubleMatResults(id, name, index=0): """ GetDoubleMatResults(std::string const & id, std::string const & name, int index=0) -> DoubleVecVec GetDoubleMatResults(std::string const & id, std::string const & name) -> DoubleVecVec """ return _vsp.GetDoubleMatResults(id, name, index)
[docs] def GetStringResults(id, name, index=0): """ GetStringResults(std::string const & id, std::string const & name, int index=0) -> StringVector GetStringResults(std::string const & id, std::string const & name) -> StringVector """ return _vsp.GetStringResults(id, name, index)
[docs] def GetVec3dResults(id, name, index=0): """ GetVec3dResults(std::string const & id, std::string const & name, int index=0) -> Vec3dVec GetVec3dResults(std::string const & id, std::string const & name) -> Vec3dVec """ return _vsp.GetVec3dResults(id, name, index)
[docs] def CreateGeomResults(geom_id, name): """CreateGeomResults(std::string const & geom_id, std::string const & name) -> std::string""" return _vsp.CreateGeomResults(geom_id, name)
[docs] def DeleteAllResults(): """DeleteAllResults()""" return _vsp.DeleteAllResults()
[docs] def DeleteResult(id): """DeleteResult(std::string const & id)""" return _vsp.DeleteResult(id)
[docs] def WriteResultsCSVFile(id, file_name): """WriteResultsCSVFile(std::string const & id, std::string const & file_name)""" return _vsp.WriteResultsCSVFile(id, file_name)
[docs] def PrintResults(results_id): """PrintResults(std::string const & results_id)""" return _vsp.PrintResults(results_id)
[docs] def PrintResultsDocs(results_id): """PrintResultsDocs(std::string const & results_id)""" return _vsp.PrintResultsDocs(results_id)
[docs] def WriteTestResults(): """WriteTestResults()""" return _vsp.WriteTestResults()
[docs] def InitGUI(): """InitGUI()""" return _vsp.InitGUI()
[docs] def StartGUI(): """StartGUI()""" return _vsp.StartGUI()
[docs] def EnableStopGUIMenuItem(): """EnableStopGUIMenuItem()""" return _vsp.EnableStopGUIMenuItem()
[docs] def DisableStopGUIMenuItem(): """DisableStopGUIMenuItem()""" return _vsp.DisableStopGUIMenuItem()
[docs] def StopGUI(): """StopGUI()""" return _vsp.StopGUI()
[docs] def PopupMsg(msg): """PopupMsg(std::string const & msg)""" return _vsp.PopupMsg(msg)
[docs] def UpdateGUI(): """UpdateGUI()""" return _vsp.UpdateGUI()
[docs] def IsGUIBuild(): """IsGUIBuild() -> bool""" return _vsp.IsGUIBuild()
[docs] def Lock(): """Lock()""" return _vsp.Lock()
[docs] def Unlock(): """Unlock()""" return _vsp.Unlock()
[docs] def IsEventLoopRunning(): """IsEventLoopRunning() -> bool""" return _vsp.IsEventLoopRunning()
[docs] def ScreenGrab(fname, w, h, transparentBG, autocrop=False): """ ScreenGrab(std::string const & fname, int w, int h, bool transparentBG, bool autocrop=False) ScreenGrab(std::string const & fname, int w, int h, bool transparentBG) """ return _vsp.ScreenGrab(fname, w, h, transparentBG, autocrop)
[docs] def SetViewAxis(vaxis): """SetViewAxis(bool vaxis)""" return _vsp.SetViewAxis(vaxis)
[docs] def SetShowBorders(brdr): """SetShowBorders(bool brdr)""" return _vsp.SetShowBorders(brdr)
[docs] def SetGeomDrawType(geom_id, type): """SetGeomDrawType(std::string const & geom_id, int type)""" return _vsp.SetGeomDrawType(geom_id, type)
[docs] def SetGeomWireColor(geom_id, r, g, b): """SetGeomWireColor(std::string const & geom_id, int r, int g, int b)""" return _vsp.SetGeomWireColor(geom_id, r, g, b)
[docs] def SetGeomDisplayType(geom_id, type): """SetGeomDisplayType(std::string const & geom_id, int type)""" return _vsp.SetGeomDisplayType(geom_id, type)
[docs] def GetGeomDrawType(geom_id): """GetGeomDrawType(std::string const & geom_id) -> int""" return _vsp.GetGeomDrawType(geom_id)
[docs] def GetGeomDisplayType(geom_id): """GetGeomDisplayType(std::string const & geom_id) -> int""" return _vsp.GetGeomDisplayType(geom_id)
[docs] def GetGeomWireColor(geom_id): """GetGeomWireColor(std::string const & geom_id) -> vec3d""" return _vsp.GetGeomWireColor(geom_id)
[docs] def GetGeomMaterialName(geom_id): """GetGeomMaterialName(std::string const & geom_id) -> std::string""" return _vsp.GetGeomMaterialName(geom_id)
[docs] def SetGeomMaterialName(geom_id, name): """SetGeomMaterialName(std::string const & geom_id, std::string const & name)""" return _vsp.SetGeomMaterialName(geom_id, name)
[docs] def AddMaterial(name, ambient, diffuse, specular, emissive, alpha, shininess): """AddMaterial(std::string const & name, vec3d ambient, vec3d diffuse, vec3d specular, vec3d emissive, double const & alpha, double const & shininess)""" return _vsp.AddMaterial(name, ambient, diffuse, specular, emissive, alpha, shininess)
[docs] def GetMaterialNames(): """GetMaterialNames() -> StringVector""" return _vsp.GetMaterialNames()
[docs] def GetNumLights(): """GetNumLights() -> int""" return _vsp.GetNumLights()
[docs] def FindLight(index): """FindLight(int index) -> std::string""" return _vsp.FindLight(index)
[docs] def SetBackground(r, g, b): """SetBackground(double r, double g, double b)""" return _vsp.SetBackground(r, g, b)
[docs] def SetAllViews(view): """SetAllViews(int view)""" return _vsp.SetAllViews(view)
[docs] def SetView(viewport, view): """SetView(int viewport, int view)""" return _vsp.SetView(viewport, view)
[docs] def FitAllViews(): """FitAllViews()""" return _vsp.FitAllViews()
[docs] def ResetViews(): """ResetViews()""" return _vsp.ResetViews()
[docs] def SetWindowLayout(r, c): """SetWindowLayout(int r, int c)""" return _vsp.SetWindowLayout(r, c)
[docs] def SetGUIElementDisable(e, state): """SetGUIElementDisable(int e, bool state)""" return _vsp.SetGUIElementDisable(e, state)
[docs] def SetGUIScreenDisable(s, state): """SetGUIScreenDisable(int s, bool state)""" return _vsp.SetGUIScreenDisable(s, state)
[docs] def SetGeomScreenDisable(s, state): """SetGeomScreenDisable(int s, bool state)""" return _vsp.SetGeomScreenDisable(s, state)
[docs] def HideScreen(s): """HideScreen(int s)""" return _vsp.HideScreen(s)
[docs] def ShowScreen(s): """ShowScreen(int s)""" return _vsp.ShowScreen(s)
[docs] def GetGeomTypes(): """GetGeomTypes() -> StringVector""" return _vsp.GetGeomTypes()
[docs] def AddGeom(*args): """ AddGeom(std::string const & type, std::string const & parent) -> std::string AddGeom(std::string const & type) -> std::string """ return _vsp.AddGeom(*args)
[docs] def UpdateGeom(geom_id): """UpdateGeom(std::string const & geom_id)""" return _vsp.UpdateGeom(geom_id)
[docs] def DeleteGeom(geom_id): """DeleteGeom(std::string const & geom_id)""" return _vsp.DeleteGeom(geom_id)
[docs] def DeleteGeomVec(del_vec): """DeleteGeomVec(StringVector del_vec)""" return _vsp.DeleteGeomVec(del_vec)
[docs] def CutGeomToClipboard(geom_id): """CutGeomToClipboard(std::string const & geom_id)""" return _vsp.CutGeomToClipboard(geom_id)
[docs] def CopyGeomToClipboard(geom_id): """CopyGeomToClipboard(std::string const & geom_id)""" return _vsp.CopyGeomToClipboard(geom_id)
[docs] def PasteGeomClipboard(*args): """ PasteGeomClipboard(std::string const & parent) -> StringVector PasteGeomClipboard() -> StringVector """ return _vsp.PasteGeomClipboard(*args)
[docs] def FindGeoms(): """FindGeoms() -> StringVector""" return _vsp.FindGeoms()
[docs] def FindGeomsWithName(name): """FindGeomsWithName(std::string const & name) -> StringVector""" return _vsp.FindGeomsWithName(name)
[docs] def FindGeom(name, index): """FindGeom(std::string const & name, int index) -> std::string""" return _vsp.FindGeom(name, index)
[docs] def SetGeomName(geom_id, name): """SetGeomName(std::string const & geom_id, std::string const & name)""" return _vsp.SetGeomName(geom_id, name)
[docs] def GetGeomName(geom_id): """GetGeomName(std::string const & geom_id) -> std::string""" return _vsp.GetGeomName(geom_id)
[docs] def GetGeomParmIDs(geom_id): """GetGeomParmIDs(std::string const & geom_id) -> StringVector""" return _vsp.GetGeomParmIDs(geom_id)
[docs] def GetGeomTypeName(geom_id): """GetGeomTypeName(std::string const & geom_id) -> std::string""" return _vsp.GetGeomTypeName(geom_id)
[docs] def GetParm(geom_id, name, group): """GetParm(std::string const & geom_id, std::string const & name, std::string const & group) -> std::string""" return _vsp.GetParm(geom_id, name, group)
[docs] def SetGeomParent(geom_id, parent_id): """SetGeomParent(std::string const & geom_id, std::string const & parent_id)""" return _vsp.SetGeomParent(geom_id, parent_id)
[docs] def ReorderGeom(geom_id, reorder_type): """ReorderGeom(std::string const & geom_id, int reorder_type)""" return _vsp.ReorderGeom(geom_id, reorder_type)
[docs] def AttachGeomTexture(geom_id, file_name): """AttachGeomTexture(std::string const & geom_id, std::string const & file_name) -> std::string""" return _vsp.AttachGeomTexture(geom_id, file_name)
[docs] def RemoveGeomTexture(geom_id, texture_id): """RemoveGeomTexture(std::string const & geom_id, std::string const & texture_id)""" return _vsp.RemoveGeomTexture(geom_id, texture_id)
[docs] def GetGeomTextureIDVec(geom_id): """GetGeomTextureIDVec(std::string const & geom_id) -> StringVector""" return _vsp.GetGeomTextureIDVec(geom_id)
[docs] def GetGeomTextureFileName(geom_id, texture_id): """GetGeomTextureFileName(std::string const & geom_id, std::string const & texture_id) -> std::string""" return _vsp.GetGeomTextureFileName(geom_id, texture_id)
[docs] def GetGeomParent(geom_id): """GetGeomParent(std::string const & geom_id) -> std::string""" return _vsp.GetGeomParent(geom_id)
[docs] def GetGeomChildren(geom_id): """GetGeomChildren(std::string const & geom_id) -> StringVector""" return _vsp.GetGeomChildren(geom_id)
[docs] def GetNumXSecSurfs(geom_id): """GetNumXSecSurfs(std::string const & geom_id) -> int""" return _vsp.GetNumXSecSurfs(geom_id)
[docs] def GetNumMainSurfs(geom_id): """GetNumMainSurfs(std::string const & geom_id) -> int""" return _vsp.GetNumMainSurfs(geom_id)
[docs] def GetTotalNumSurfs(geom_id): """GetTotalNumSurfs(std::string const & geom_id) -> int""" return _vsp.GetTotalNumSurfs(geom_id)
[docs] def GetGeomVSPSurfType(geom_id, main_surf_ind=0): """ GetGeomVSPSurfType(std::string const & geom_id, int main_surf_ind=0) -> int GetGeomVSPSurfType(std::string const & geom_id) -> int """ return _vsp.GetGeomVSPSurfType(geom_id, main_surf_ind)
[docs] def GetGeomVSPSurfCfdType(geom_id, main_surf_ind=0): """ GetGeomVSPSurfCfdType(std::string const & geom_id, int main_surf_ind=0) -> int GetGeomVSPSurfCfdType(std::string const & geom_id) -> int """ return _vsp.GetGeomVSPSurfCfdType(geom_id, main_surf_ind)
[docs] def GetGeomBBoxMax(geom_id, main_surf_ind=0, ref_frame_is_absolute=True): """ GetGeomBBoxMax(std::string const & geom_id, int main_surf_ind=0, bool ref_frame_is_absolute=True) -> vec3d GetGeomBBoxMax(std::string const & geom_id, int main_surf_ind=0) -> vec3d GetGeomBBoxMax(std::string const & geom_id) -> vec3d """ return _vsp.GetGeomBBoxMax(geom_id, main_surf_ind, ref_frame_is_absolute)
[docs] def GetGeomBBoxMin(geom_id, main_surf_ind=0, ref_frame_is_absolute=True): """ GetGeomBBoxMin(std::string const & geom_id, int main_surf_ind=0, bool ref_frame_is_absolute=True) -> vec3d GetGeomBBoxMin(std::string const & geom_id, int main_surf_ind=0) -> vec3d GetGeomBBoxMin(std::string const & geom_id) -> vec3d """ return _vsp.GetGeomBBoxMin(geom_id, main_surf_ind, ref_frame_is_absolute)
[docs] def AddSubSurf(geom_id, type, surfindex=0): """ AddSubSurf(std::string const & geom_id, int type, int surfindex=0) -> std::string AddSubSurf(std::string const & geom_id, int type) -> std::string """ return _vsp.AddSubSurf(geom_id, type, surfindex)
[docs] def GetSubSurf(*args): """ GetSubSurf(std::string const & geom_id, int index) -> std::string GetSubSurf(std::string const & geom_id, std::string const & name) -> StringVector """ return _vsp.GetSubSurf(*args)
[docs] def ReorderSubSurf(geom_id, sub_id, reorder_type): """ReorderSubSurf(std::string const & geom_id, std::string const & sub_id, int reorder_type)""" return _vsp.ReorderSubSurf(geom_id, sub_id, reorder_type)
[docs] def DeleteSubSurf(*args): """ DeleteSubSurf(std::string const & geom_id, std::string const & sub_id) DeleteSubSurf(std::string const & sub_id) """ return _vsp.DeleteSubSurf(*args)
[docs] def SetSubSurfName(*args): """ 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.SetSubSurfName(*args)
[docs] def GetSubSurfName(*args): """ GetSubSurfName(std::string const & geom_id, std::string const & sub_id) -> std::string GetSubSurfName(std::string const & sub_id) -> std::string """ return _vsp.GetSubSurfName(*args)
[docs] def GetSubSurfIndex(sub_id): """GetSubSurfIndex(std::string const & sub_id) -> int""" return _vsp.GetSubSurfIndex(sub_id)
[docs] def GetSubSurfIDVec(geom_id): """GetSubSurfIDVec(std::string const & geom_id) -> StringVector""" return _vsp.GetSubSurfIDVec(geom_id)
[docs] def GetAllSubSurfIDs(): """GetAllSubSurfIDs() -> StringVector""" return _vsp.GetAllSubSurfIDs()
[docs] def GetNumSubSurf(geom_id): """GetNumSubSurf(std::string const & geom_id) -> int""" return _vsp.GetNumSubSurf(geom_id)
[docs] def GetSubSurfType(sub_id): """GetSubSurfType(std::string const & sub_id) -> int""" return _vsp.GetSubSurfType(sub_id)
[docs] def GetSubSurfParmIDs(sub_id): """GetSubSurfParmIDs(std::string const & sub_id) -> StringVector""" return _vsp.GetSubSurfParmIDs(sub_id)
[docs] def IntersectSubSurf(sub_id): """IntersectSubSurf(std::string const & sub_id)""" return _vsp.IntersectSubSurf(sub_id)
[docs] def GetIntersectSubSurfGeomID(sub_id): """GetIntersectSubSurfGeomID(std::string const & sub_id) -> std::string""" return _vsp.GetIntersectSubSurfGeomID(sub_id)
[docs] def SetIntersectSubSurfGeomID(sub_id, geom_id): """SetIntersectSubSurfGeomID(std::string const & sub_id, std::string const & geom_id)""" return _vsp.SetIntersectSubSurfGeomID(sub_id, geom_id)
[docs] def AddFeaStruct(geom_id, init_skin=True, surfindex=0): """ AddFeaStruct(std::string const & geom_id, bool init_skin=True, int surfindex=0) -> int AddFeaStruct(std::string const & geom_id, bool init_skin=True) -> int AddFeaStruct(std::string const & geom_id) -> int """ return _vsp.AddFeaStruct(geom_id, init_skin, surfindex)
[docs] def GetFeaMeshStructIndex(): """GetFeaMeshStructIndex() -> int""" return _vsp.GetFeaMeshStructIndex()
[docs] def SetFeaMeshStructIndex(struct_index): """SetFeaMeshStructIndex(int struct_index)""" return _vsp.SetFeaMeshStructIndex(struct_index)
[docs] def DeleteFeaStruct(geom_id, fea_struct_ind): """DeleteFeaStruct(std::string const & geom_id, int fea_struct_ind)""" return _vsp.DeleteFeaStruct(geom_id, fea_struct_ind)
[docs] def GetFeaStructID(geom_id, fea_struct_ind): """GetFeaStructID(std::string const & geom_id, int fea_struct_ind) -> std::string""" return _vsp.GetFeaStructID(geom_id, fea_struct_ind)
[docs] def GetFeaStructIndex(struct_id): """GetFeaStructIndex(std::string const & struct_id) -> int""" return _vsp.GetFeaStructIndex(struct_id)
[docs] def GetFeaStructParentGeomID(struct_id): """GetFeaStructParentGeomID(std::string const & struct_id) -> std::string""" return _vsp.GetFeaStructParentGeomID(struct_id)
[docs] def GetFeaStructName(geom_id, fea_struct_ind): """GetFeaStructName(std::string const & geom_id, int fea_struct_ind) -> std::string""" return _vsp.GetFeaStructName(geom_id, fea_struct_ind)
[docs] def SetFeaStructName(geom_id, fea_struct_ind, name): """SetFeaStructName(std::string const & geom_id, int fea_struct_ind, std::string const & name)""" return _vsp.SetFeaStructName(geom_id, fea_struct_ind, name)
[docs] def GetFeaStructIDVec(): """GetFeaStructIDVec() -> StringVector""" return _vsp.GetFeaStructIDVec()
[docs] def SetFeaPartName(part_id, name): """SetFeaPartName(std::string const & part_id, std::string const & name)""" return _vsp.SetFeaPartName(part_id, name)
[docs] def AddFeaPart(geom_id, fea_struct_ind, type): """AddFeaPart(std::string const & geom_id, int fea_struct_ind, int type) -> std::string""" return _vsp.AddFeaPart(geom_id, fea_struct_ind, type)
[docs] def DeleteFeaPart(geom_id, fea_struct_ind, part_id): """DeleteFeaPart(std::string const & geom_id, int fea_struct_ind, std::string const & part_id)""" return _vsp.DeleteFeaPart(geom_id, fea_struct_ind, part_id)
[docs] def ReorderFeaPart(geom_id, fea_struct_ind, part_id, reorder_type): """ReorderFeaPart(std::string const & geom_id, int fea_struct_ind, std::string const & part_id, int reorder_type)""" return _vsp.ReorderFeaPart(geom_id, fea_struct_ind, part_id, reorder_type)
[docs] def IndividualizeFeaPart(geom_id, fea_struct_ind, part_id): """IndividualizeFeaPart(std::string const & geom_id, int fea_struct_ind, std::string const & part_id)""" return _vsp.IndividualizeFeaPart(geom_id, fea_struct_ind, part_id)
[docs] def GetFeaPartID(fea_struct_id, fea_part_index): """GetFeaPartID(std::string const & fea_struct_id, int fea_part_index) -> std::string""" return _vsp.GetFeaPartID(fea_struct_id, fea_part_index)
[docs] def GetFeaPartName(part_id): """GetFeaPartName(std::string const & part_id) -> std::string""" return _vsp.GetFeaPartName(part_id)
[docs] def GetFeaPartType(part_id): """GetFeaPartType(std::string const & part_id) -> int""" return _vsp.GetFeaPartType(part_id)
[docs] def GetFeaPartIDVec(fea_struct_id): """GetFeaPartIDVec(std::string const & fea_struct_id) -> StringVector""" return _vsp.GetFeaPartIDVec(fea_struct_id)
[docs] def GetFeaSubSurfIDVec(fea_struct_id): """GetFeaSubSurfIDVec(std::string const & fea_struct_id) -> StringVector""" return _vsp.GetFeaSubSurfIDVec(fea_struct_id)
[docs] def SetFeaPartPerpendicularSparID(part_id, perpendicular_spar_id): """SetFeaPartPerpendicularSparID(std::string const & part_id, std::string const & perpendicular_spar_id)""" return _vsp.SetFeaPartPerpendicularSparID(part_id, perpendicular_spar_id)
[docs] def GetFeaPartPerpendicularSparID(part_id): """GetFeaPartPerpendicularSparID(std::string const & part_id) -> std::string""" return _vsp.GetFeaPartPerpendicularSparID(part_id)
[docs] def SetFeaSubSurfName(subsurf_id, name): """SetFeaSubSurfName(std::string const & subsurf_id, std::string const & name)""" return _vsp.SetFeaSubSurfName(subsurf_id, name)
[docs] def GetFeaSubSurfName(subsurf_id): """GetFeaSubSurfName(std::string const & subsurf_id) -> std::string""" return _vsp.GetFeaSubSurfName(subsurf_id)
[docs] def AddFeaSubSurf(geom_id, fea_struct_ind, type): """AddFeaSubSurf(std::string const & geom_id, int fea_struct_ind, int type) -> std::string""" return _vsp.AddFeaSubSurf(geom_id, fea_struct_ind, type)
[docs] def DeleteFeaSubSurf(geom_id, fea_struct_ind, ss_id): """DeleteFeaSubSurf(std::string const & geom_id, int fea_struct_ind, std::string const & ss_id)""" return _vsp.DeleteFeaSubSurf(geom_id, fea_struct_ind, ss_id)
[docs] def GetFeaSubSurfIndex(ss_id): """GetFeaSubSurfIndex(std::string const & ss_id) -> int""" return _vsp.GetFeaSubSurfIndex(ss_id)
[docs] def GetFeaPolySparNumPt(pspar_id): """GetFeaPolySparNumPt(std::string const & pspar_id) -> int""" return _vsp.GetFeaPolySparNumPt(pspar_id)
[docs] def AddFeaPolySparPt(pspar_id): """AddFeaPolySparPt(std::string const & pspar_id) -> std::string""" return _vsp.AddFeaPolySparPt(pspar_id)
[docs] def InsertFeaPolySparPt(pspar_id, index): """InsertFeaPolySparPt(std::string const & pspar_id, int index) -> std::string""" return _vsp.InsertFeaPolySparPt(pspar_id, index)
[docs] def DelFeaPolySparPt(pspar_id, index): """DelFeaPolySparPt(std::string const & pspar_id, int index)""" return _vsp.DelFeaPolySparPt(pspar_id, index)
[docs] def DelAllFeaPolySparPt(pspar_id): """DelAllFeaPolySparPt(std::string const & pspar_id)""" return _vsp.DelAllFeaPolySparPt(pspar_id)
[docs] def MoveFeaPolySparPt(pspar_id, index, reorder_type): """MoveFeaPolySparPt(std::string const & pspar_id, int index, int reorder_type) -> int""" return _vsp.MoveFeaPolySparPt(pspar_id, index, reorder_type)
[docs] def SetFeaPolySparPtName(pspar_id, index, name): """SetFeaPolySparPtName(std::string const & pspar_id, int index, std::string const & name)""" return _vsp.SetFeaPolySparPtName(pspar_id, index, name)
[docs] def GetFeaPolySparPtName(pspar_id, index): """GetFeaPolySparPtName(std::string const & pspar_id, int index) -> std::string""" return _vsp.GetFeaPolySparPtName(pspar_id, index)
[docs] def GetFeaPolySparPtID(pspar_id, index): """GetFeaPolySparPtID(std::string const & pspar_id, int index) -> std::string""" return _vsp.GetFeaPolySparPtID(pspar_id, index)
[docs] def GetAllFeaPolySparPtIDVec(pspar_id): """GetAllFeaPolySparPtIDVec(std::string const & pspar_id) -> StringVector""" return _vsp.GetAllFeaPolySparPtIDVec(pspar_id)
[docs] def AddFeaTrimPart(trim_id, part_id): """AddFeaTrimPart(std::string const & trim_id, std::string const & part_id)""" return _vsp.AddFeaTrimPart(trim_id, part_id)
[docs] def DeleteFeaTrimPart(trim_id, index): """DeleteFeaTrimPart(std::string const & trim_id, int index)""" return _vsp.DeleteFeaTrimPart(trim_id, index)
[docs] def GetFeaTrimPartIDVec(trim_id): """GetFeaTrimPartIDVec(std::string const & trim_id) -> StringVector""" return _vsp.GetFeaTrimPartIDVec(trim_id)
[docs] def AddFeaAssembly(): """AddFeaAssembly() -> std::string""" return _vsp.AddFeaAssembly()
[docs] def DeleteFeaAssembly(assembly_id): """DeleteFeaAssembly(std::string const & assembly_id)""" return _vsp.DeleteFeaAssembly(assembly_id)
[docs] def NumFeaAssemblies(): """NumFeaAssemblies() -> int""" return _vsp.NumFeaAssemblies()
[docs] def GetFeaAssemblyIDVec(): """GetFeaAssemblyIDVec() -> StringVector""" return _vsp.GetFeaAssemblyIDVec()
[docs] def GetFeaAssemblyName(assembly_id): """GetFeaAssemblyName(std::string const & assembly_id) -> std::string""" return _vsp.GetFeaAssemblyName(assembly_id)
[docs] def SetFeaAssemblyName(assembly_id, name): """SetFeaAssemblyName(std::string const & assembly_id, std::string const & name)""" return _vsp.SetFeaAssemblyName(assembly_id, name)
[docs] def AddFeaStructureToAssembly(assembly_id, struct_id): """AddFeaStructureToAssembly(std::string const & assembly_id, std::string const & struct_id)""" return _vsp.AddFeaStructureToAssembly(assembly_id, struct_id)
[docs] def DeleteFeaStructureFromAssembly(assembly_id, struct_id): """DeleteFeaStructureFromAssembly(std::string const & assembly_id, std::string const & struct_id)""" return _vsp.DeleteFeaStructureFromAssembly(assembly_id, struct_id)
[docs] def AddFeaAssemblyStructure(assembly_id, struct_id): """AddFeaAssemblyStructure(std::string const & assembly_id, std::string const & struct_id)""" return _vsp.AddFeaAssemblyStructure(assembly_id, struct_id)
[docs] def DeleteFeaAssemblyStructure(assembly_id, struct_id): """DeleteFeaAssemblyStructure(std::string const & assembly_id, std::string const & struct_id)""" return _vsp.DeleteFeaAssemblyStructure(assembly_id, struct_id)
[docs] def GetFeaAssemblyStructureIDVec(assembly_id): """GetFeaAssemblyStructureIDVec(std::string const & assembly_id) -> StringVector""" return _vsp.GetFeaAssemblyStructureIDVec(assembly_id)
[docs] def AddFeaAssemblyConnection(assembly_id, start_fix_pt_id, start_struct_id, start_index, end_fix_pt_id, end_struct_id, end_index): """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.AddFeaAssemblyConnection(assembly_id, start_fix_pt_id, start_struct_id, start_index, end_fix_pt_id, end_struct_id, end_index)
[docs] def DeleteFeaAssemblyConnection(assembly_id, connection_index): """DeleteFeaAssemblyConnection(std::string const & assembly_id, int connection_index)""" return _vsp.DeleteFeaAssemblyConnection(assembly_id, connection_index)
[docs] def NumFeaAssemblyConnections(assembly_id): """NumFeaAssemblyConnections(std::string const & assembly_id) -> int""" return _vsp.NumFeaAssemblyConnections(assembly_id)
[docs] def GetFeaAssemblyConnectionID(assembly_id, connection_index): """GetFeaAssemblyConnectionID(std::string const & assembly_id, int connection_index) -> std::string""" return _vsp.GetFeaAssemblyConnectionID(assembly_id, connection_index)
[docs] def GetFeaAssemblyFileName(assembly_id, file_type): """GetFeaAssemblyFileName(std::string const & assembly_id, int file_type) -> std::string""" return _vsp.GetFeaAssemblyFileName(assembly_id, file_type)
[docs] def SetFeaAssemblyFileName(assembly_id, file_type, file_name): """SetFeaAssemblyFileName(std::string const & assembly_id, int file_type, std::string const & file_name)""" return _vsp.SetFeaAssemblyFileName(assembly_id, file_type, file_name)
[docs] def ComputeFeaAssemblyMesh(assembly_id): """ComputeFeaAssemblyMesh(std::string const & assembly_id)""" return _vsp.ComputeFeaAssemblyMesh(assembly_id)
[docs] def NumFeaStructures(): """NumFeaStructures() -> int""" return _vsp.NumFeaStructures()
[docs] def NumFeaParts(fea_struct_id): """NumFeaParts(std::string const & fea_struct_id) -> int""" return _vsp.NumFeaParts(fea_struct_id)
[docs] def NumFeaSubSurfs(fea_struct_id): """NumFeaSubSurfs(std::string const & fea_struct_id) -> int""" return _vsp.NumFeaSubSurfs(fea_struct_id)
[docs] def AddFeaBC(fea_struct_id, type=-1): """ AddFeaBC(std::string const & fea_struct_id, int type=-1) -> std::string AddFeaBC(std::string const & fea_struct_id) -> std::string """ return _vsp.AddFeaBC(fea_struct_id, type)
[docs] def DelFeaBC(fea_struct_id, bc_id): """DelFeaBC(std::string const & fea_struct_id, std::string const & bc_id)""" return _vsp.DelFeaBC(fea_struct_id, bc_id)
[docs] def GetFeaBCIDVec(fea_struct_id): """GetFeaBCIDVec(std::string const & fea_struct_id) -> StringVector""" return _vsp.GetFeaBCIDVec(fea_struct_id)
[docs] def NumFeaBCs(fea_struct_id): """NumFeaBCs(std::string const & fea_struct_id) -> int""" return _vsp.NumFeaBCs(fea_struct_id)
[docs] def AddFeaLayer(material_id): """AddFeaLayer(std::string const & material_id) -> std::string""" return _vsp.AddFeaLayer(material_id)
[docs] def DeleteFeaLayer(material_id, layer_id): """DeleteFeaLayer(std::string const & material_id, std::string const & layer_id)""" return _vsp.DeleteFeaLayer(material_id, layer_id)
[docs] def ReorderFeaLayer(material_id, layer_id, reorder_type): """ReorderFeaLayer(std::string const & material_id, std::string const & layer_id, int reorder_type)""" return _vsp.ReorderFeaLayer(material_id, layer_id, reorder_type)
[docs] def NumFeaLayers(material_id): """NumFeaLayers(std::string const & material_id) -> int""" return _vsp.NumFeaLayers(material_id)
[docs] def GetFeaLayerIDVec(material_id): """GetFeaLayerIDVec(std::string const & material_id) -> StringVector""" return _vsp.GetFeaLayerIDVec(material_id)
[docs] def GetFeaMaterialIDVec(): """GetFeaMaterialIDVec() -> StringVector""" return _vsp.GetFeaMaterialIDVec()
[docs] def DeleteFeaMaterial(id): """DeleteFeaMaterial(std::string const & id)""" return _vsp.DeleteFeaMaterial(id)
[docs] def AddFeaMaterial(): """AddFeaMaterial() -> std::string""" return _vsp.AddFeaMaterial()
[docs] def GetFeaPropertyIDVec(): """GetFeaPropertyIDVec() -> StringVector""" return _vsp.GetFeaPropertyIDVec()
[docs] def DeleteFeaProperty(id): """DeleteFeaProperty(std::string const & id)""" return _vsp.DeleteFeaProperty(id)
[docs] def AddFeaProperty(property_type=0): """ AddFeaProperty(int property_type=0) -> std::string AddFeaProperty() -> std::string """ return _vsp.AddFeaProperty(property_type)
[docs] def GetFeaMeshVal(geom_id, fea_struct_ind, type): """GetFeaMeshVal(std::string const & geom_id, int fea_struct_ind, int type) -> double""" return _vsp.GetFeaMeshVal(geom_id, fea_struct_ind, type)
[docs] def SetFeaMeshVal(geom_id, fea_struct_ind, type, val): """SetFeaMeshVal(std::string const & geom_id, int fea_struct_ind, int type, double val)""" return _vsp.SetFeaMeshVal(geom_id, fea_struct_ind, type, val)
[docs] def GetFeaMeshFileName(geom_id, fea_struct_ind, file_type): """GetFeaMeshFileName(std::string const & geom_id, int fea_struct_ind, int file_type) -> std::string""" return _vsp.GetFeaMeshFileName(geom_id, fea_struct_ind, file_type)
[docs] def SetFeaMeshFileName(geom_id, fea_struct_ind, file_type, file_name): """SetFeaMeshFileName(std::string const & geom_id, int fea_struct_ind, int file_type, std::string const & file_name)""" return _vsp.SetFeaMeshFileName(geom_id, fea_struct_ind, file_type, file_name)
[docs] def ComputeFeaMesh(*args): """ ComputeFeaMesh(std::string const & geom_id, int fea_struct_ind, int file_type) ComputeFeaMesh(std::string const & struct_id, int file_type) """ return _vsp.ComputeFeaMesh(*args)
[docs] def SetXSecAlias(id, alias): """SetXSecAlias(std::string const & id, std::string const & alias)""" return _vsp.SetXSecAlias(id, alias)
[docs] def GetXSecAlias(id): """GetXSecAlias(std::string const & id) -> std::string""" return _vsp.GetXSecAlias(id)
[docs] def SetXSecCurveAlias(id, alias): """SetXSecCurveAlias(std::string const & id, std::string const & alias)""" return _vsp.SetXSecCurveAlias(id, alias)
[docs] def GetXSecCurveAlias(id): """GetXSecCurveAlias(std::string const & id) -> std::string""" return _vsp.GetXSecCurveAlias(id)
[docs] def CutXSec(geom_id, index): """CutXSec(std::string const & geom_id, int index)""" return _vsp.CutXSec(geom_id, index)
[docs] def CopyXSec(geom_id, index): """CopyXSec(std::string const & geom_id, int index)""" return _vsp.CopyXSec(geom_id, index)
[docs] def PasteXSec(geom_id, index): """PasteXSec(std::string const & geom_id, int index)""" return _vsp.PasteXSec(geom_id, index)
[docs] def InsertXSec(geom_id, index, type): """InsertXSec(std::string const & geom_id, int index, int type)""" return _vsp.InsertXSec(geom_id, index, type)
[docs] def SplitWingXSec(wing_id, section_index): """SplitWingXSec(std::string const & wing_id, int section_index)""" return _vsp.SplitWingXSec(wing_id, section_index)
[docs] def GetDriverGroup(geom_id, section_index): """GetDriverGroup(std::string const & geom_id, int section_index) -> IntVector""" return _vsp.GetDriverGroup(geom_id, section_index)
[docs] def SetDriverGroup(geom_id, section_index, driver_0, driver_1=-1, driver_2=-1): """ SetDriverGroup(std::string const & geom_id, int section_index, int driver_0, int driver_1=-1, int driver_2=-1) SetDriverGroup(std::string const & geom_id, int section_index, int driver_0, int driver_1=-1) SetDriverGroup(std::string const & geom_id, int section_index, int driver_0) """ return _vsp.SetDriverGroup(geom_id, section_index, driver_0, driver_1, driver_2)
[docs] def GetXSecSurf(geom_id, index): """GetXSecSurf(std::string const & geom_id, int index) -> std::string""" return _vsp.GetXSecSurf(geom_id, index)
[docs] def GetNumXSec(xsec_surf_id): """GetNumXSec(std::string const & xsec_surf_id) -> int""" return _vsp.GetNumXSec(xsec_surf_id)
[docs] def GetXSec(xsec_surf_id, xsec_index): """GetXSec(std::string const & xsec_surf_id, int xsec_index) -> std::string""" return _vsp.GetXSec(xsec_surf_id, xsec_index)
[docs] def ChangeXSecShape(xsec_surf_id, xsec_index, type): """ChangeXSecShape(std::string const & xsec_surf_id, int xsec_index, int type)""" return _vsp.ChangeXSecShape(xsec_surf_id, xsec_index, type)
[docs] def FitCSTAirfoil(xsec_surf_id, xsec_index, deg): """FitCSTAirfoil(std::string const & xsec_surf_id, int xsec_index, int deg)""" return _vsp.FitCSTAirfoil(xsec_surf_id, xsec_index, deg)
[docs] def SetXSecSurfGlobalXForm(xsec_surf_id, mat): """SetXSecSurfGlobalXForm(std::string const & xsec_surf_id, Matrix4d mat)""" return _vsp.SetXSecSurfGlobalXForm(xsec_surf_id, mat)
[docs] def GetXSecSurfGlobalXForm(xsec_surf_id): """GetXSecSurfGlobalXForm(std::string const & xsec_surf_id) -> Matrix4d""" return _vsp.GetXSecSurfGlobalXForm(xsec_surf_id)
[docs] def GetXSecShape(xsec_id): """GetXSecShape(std::string const & xsec_id) -> int""" return _vsp.GetXSecShape(xsec_id)
[docs] def GetXSecWidth(xsec_id): """GetXSecWidth(std::string const & xsec_id) -> double""" return _vsp.GetXSecWidth(xsec_id)
[docs] def GetXSecHeight(xsec_id): """GetXSecHeight(std::string const & xsec_id) -> double""" return _vsp.GetXSecHeight(xsec_id)
[docs] def SetXSecWidthHeight(xsec_id, w, h): """SetXSecWidthHeight(std::string const & xsec_id, double w, double h)""" return _vsp.SetXSecWidthHeight(xsec_id, w, h)
[docs] def SetXSecWidth(xsec_id, w): """SetXSecWidth(std::string const & xsec_id, double w)""" return _vsp.SetXSecWidth(xsec_id, w)
[docs] def SetXSecHeight(xsec_id, h): """SetXSecHeight(std::string const & xsec_id, double h)""" return _vsp.SetXSecHeight(xsec_id, h)
[docs] def GetXSecParmIDs(xsec_id): """GetXSecParmIDs(std::string const & xsec_id) -> StringVector""" return _vsp.GetXSecParmIDs(xsec_id)
[docs] def GetXSecParm(xsec_id, name): """GetXSecParm(std::string const & xsec_id, std::string const & name) -> std::string""" return _vsp.GetXSecParm(xsec_id, name)
[docs] def ReadFileXSec(xsec_id, file_name): """ReadFileXSec(std::string const & xsec_id, std::string const & file_name) -> Vec3dVec""" return _vsp.ReadFileXSec(xsec_id, file_name)
[docs] def GetXSecPnts(xsec_id): """GetXSecPnts(std::string const & xsec_id) -> Vec3dVec""" return _vsp.GetXSecPnts(xsec_id)
[docs] def CopyXSecCurve(geom_id, index): """CopyXSecCurve(std::string const & geom_id, int index)""" return _vsp.CopyXSecCurve(geom_id, index)
[docs] def PasteXSecCurve(geom_id, index): """PasteXSecCurve(std::string const & geom_id, int index)""" return _vsp.PasteXSecCurve(geom_id, index)
[docs] def SetXSecPnts(xsec_id, pnt_vec): """SetXSecPnts(std::string const & xsec_id, Vec3dVec pnt_vec)""" return _vsp.SetXSecPnts(xsec_id, pnt_vec)
[docs] def ComputeXSecPnt(xsec_id, fract): """ComputeXSecPnt(std::string const & xsec_id, double fract) -> vec3d""" return _vsp.ComputeXSecPnt(xsec_id, fract)
[docs] def ComputeXSecTan(xsec_id, fract): """ComputeXSecTan(std::string const & xsec_id, double fract) -> vec3d""" return _vsp.ComputeXSecTan(xsec_id, fract)
[docs] def ResetXSecSkinParms(xsec_id): """ResetXSecSkinParms(std::string const & xsec_id)""" return _vsp.ResetXSecSkinParms(xsec_id)
[docs] def GetXSecContinuity(xsec_id): """GetXSecContinuity(std::string const & xsec_id) -> int""" return _vsp.GetXSecContinuity(xsec_id)
[docs] def SetXSecContinuity(xsec_id, cx): """SetXSecContinuity(std::string const & xsec_id, int cx)""" return _vsp.SetXSecContinuity(xsec_id, cx)
[docs] def GetXSecTanAngles(xsec_id, side): """GetXSecTanAngles(std::string const & xsec_id, int side) -> DoubleVector""" return _vsp.GetXSecTanAngles(xsec_id, side)
[docs] def SetXSecTanAngles(xsec_id, side, top, right, bottom, left): """SetXSecTanAngles(std::string const & xsec_id, int side, double top, double right, double bottom, double left)""" return _vsp.SetXSecTanAngles(xsec_id, side, top, right, bottom, left)
[docs] def GetXSecTanSlews(xsec_id, side): """GetXSecTanSlews(std::string const & xsec_id, int side) -> DoubleVector""" return _vsp.GetXSecTanSlews(xsec_id, side)
[docs] def SetXSecTanSlews(xsec_id, side, top, right, bottom, left): """SetXSecTanSlews(std::string const & xsec_id, int side, double top, double right, double bottom, double left)""" return _vsp.SetXSecTanSlews(xsec_id, side, top, right, bottom, left)
[docs] def GetXSecTanStrengths(xsec_id, side): """GetXSecTanStrengths(std::string const & xsec_id, int side) -> DoubleVector""" return _vsp.GetXSecTanStrengths(xsec_id, side)
[docs] def SetXSecTanStrengths(xsec_id, side, top, right, bottom, left): """SetXSecTanStrengths(std::string const & xsec_id, int side, double top, double right, double bottom, double left)""" return _vsp.SetXSecTanStrengths(xsec_id, side, top, right, bottom, left)
[docs] def GetXSecCurvatures(xsec_id, side): """GetXSecCurvatures(std::string const & xsec_id, int side) -> DoubleVector""" return _vsp.GetXSecCurvatures(xsec_id, side)
[docs] def SetXSecCurvatures(xsec_id, side, top, right, bottom, left): """SetXSecCurvatures(std::string const & xsec_id, int side, double top, double right, double bottom, double left)""" return _vsp.SetXSecCurvatures(xsec_id, side, top, right, bottom, left)
[docs] def ReadFileAirfoil(xsec_id, file_name): """ReadFileAirfoil(std::string const & xsec_id, std::string const & file_name)""" return _vsp.ReadFileAirfoil(xsec_id, file_name)
[docs] def SetAirfoilUpperPnts(xsec_id, up_pnt_vec): """SetAirfoilUpperPnts(std::string const & xsec_id, Vec3dVec up_pnt_vec)""" return _vsp.SetAirfoilUpperPnts(xsec_id, up_pnt_vec)
[docs] def SetAirfoilLowerPnts(xsec_id, low_pnt_vec): """SetAirfoilLowerPnts(std::string const & xsec_id, Vec3dVec low_pnt_vec)""" return _vsp.SetAirfoilLowerPnts(xsec_id, low_pnt_vec)
[docs] def SetAirfoilPnts(xsec_id, up_pnt_vec, low_pnt_vec): """SetAirfoilPnts(std::string const & xsec_id, Vec3dVec up_pnt_vec, Vec3dVec low_pnt_vec)""" return _vsp.SetAirfoilPnts(xsec_id, up_pnt_vec, low_pnt_vec)
[docs] def GetHersheyBarLiftDist(npts, alpha, Vinf, span, full_span_flag=False): """ GetHersheyBarLiftDist(int const & npts, double const & alpha, double const & Vinf, double const & span, bool full_span_flag=False) -> Vec3dVec GetHersheyBarLiftDist(int const & npts, double const & alpha, double const & Vinf, double const & span) -> Vec3dVec """ return _vsp.GetHersheyBarLiftDist(npts, alpha, Vinf, span, full_span_flag)
[docs] def GetHersheyBarDragDist(npts, alpha, Vinf, span, full_span_flag=False): """ GetHersheyBarDragDist(int const & npts, double const & alpha, double const & Vinf, double const & span, bool full_span_flag=False) -> Vec3dVec GetHersheyBarDragDist(int const & npts, double const & alpha, double const & Vinf, double const & span) -> Vec3dVec """ return _vsp.GetHersheyBarDragDist(npts, alpha, Vinf, span, full_span_flag)
[docs] def GetVKTAirfoilPnts(npts, alpha, epsilon, kappa, tau): """GetVKTAirfoilPnts(int const & npts, double const & alpha, double const & epsilon, double const & kappa, double const & tau) -> Vec3dVec""" return _vsp.GetVKTAirfoilPnts(npts, alpha, epsilon, kappa, tau)
[docs] def GetVKTAirfoilCpDist(alpha, epsilon, kappa, tau, xyz_data): """GetVKTAirfoilCpDist(double const & alpha, double const & epsilon, double const & kappa, double const & tau, Vec3dVec xyz_data) -> DoubleVector""" return _vsp.GetVKTAirfoilCpDist(alpha, epsilon, kappa, tau, xyz_data)
[docs] def GetEllipsoidSurfPnts(center, abc_rad, u_npts=20, w_npts=20): """ GetEllipsoidSurfPnts(vec3d center, vec3d abc_rad, int u_npts=20, int w_npts=20) -> Vec3dVec GetEllipsoidSurfPnts(vec3d center, vec3d abc_rad, int u_npts=20) -> Vec3dVec GetEllipsoidSurfPnts(vec3d center, vec3d abc_rad) -> Vec3dVec """ return _vsp.GetEllipsoidSurfPnts(center, abc_rad, u_npts, w_npts)
[docs] def GetFeatureLinePnts(geom_id): """GetFeatureLinePnts(std::string const & geom_id) -> Vec3dVec""" return _vsp.GetFeatureLinePnts(geom_id)
[docs] def GetEllipsoidCpDist(surf_pnt_vec, abc_rad, V_inf): """GetEllipsoidCpDist(Vec3dVec surf_pnt_vec, vec3d abc_rad, vec3d V_inf) -> DoubleVector""" return _vsp.GetEllipsoidCpDist(surf_pnt_vec, abc_rad, V_inf)
[docs] def IntegrateEllipsoidFlow(abc_rad, abc_index): """IntegrateEllipsoidFlow(vec3d abc_rad, int const & abc_index) -> double""" return _vsp.IntegrateEllipsoidFlow(abc_rad, abc_index)
[docs] def GetAirfoilUpperPnts(xsec_id): """GetAirfoilUpperPnts(std::string const & xsec_id) -> Vec3dVec""" return _vsp.GetAirfoilUpperPnts(xsec_id)
[docs] def GetAirfoilLowerPnts(xsec_id): """GetAirfoilLowerPnts(std::string const & xsec_id) -> Vec3dVec""" return _vsp.GetAirfoilLowerPnts(xsec_id)
[docs] def GetUpperCSTCoefs(xsec_id): """GetUpperCSTCoefs(std::string const & xsec_id) -> DoubleVector""" return _vsp.GetUpperCSTCoefs(xsec_id)
[docs] def GetLowerCSTCoefs(xsec_id): """GetLowerCSTCoefs(std::string const & xsec_id) -> DoubleVector""" return _vsp.GetLowerCSTCoefs(xsec_id)
[docs] def GetUpperCSTDegree(xsec_id): """GetUpperCSTDegree(std::string const & xsec_id) -> int""" return _vsp.GetUpperCSTDegree(xsec_id)
[docs] def GetLowerCSTDegree(xsec_id): """GetLowerCSTDegree(std::string const & xsec_id) -> int""" return _vsp.GetLowerCSTDegree(xsec_id)
[docs] def SetUpperCST(xsec_id, deg, coefs): """SetUpperCST(std::string const & xsec_id, int deg, DoubleVector coefs)""" return _vsp.SetUpperCST(xsec_id, deg, coefs)
[docs] def SetLowerCST(xsec_id, deg, coefs): """SetLowerCST(std::string const & xsec_id, int deg, DoubleVector coefs)""" return _vsp.SetLowerCST(xsec_id, deg, coefs)
[docs] def PromoteCSTUpper(xsec_id): """PromoteCSTUpper(std::string const & xsec_id)""" return _vsp.PromoteCSTUpper(xsec_id)
[docs] def PromoteCSTLower(xsec_id): """PromoteCSTLower(std::string const & xsec_id)""" return _vsp.PromoteCSTLower(xsec_id)
[docs] def DemoteCSTUpper(xsec_id): """DemoteCSTUpper(std::string const & xsec_id)""" return _vsp.DemoteCSTUpper(xsec_id)
[docs] def DemoteCSTLower(xsec_id): """DemoteCSTLower(std::string const & xsec_id)""" return _vsp.DemoteCSTLower(xsec_id)
[docs] def FitAfCST(xsec_surf_id, xsec_index, deg): """FitAfCST(std::string const & xsec_surf_id, int xsec_index, int deg)""" return _vsp.FitAfCST(xsec_surf_id, xsec_index, deg)
[docs] def AddBackground3D(): """AddBackground3D() -> std::string""" return _vsp.AddBackground3D()
[docs] def GetNumBackground3Ds(): """GetNumBackground3Ds() -> int""" return _vsp.GetNumBackground3Ds()
[docs] def GetAllBackground3Ds(): """GetAllBackground3Ds() -> StringVector""" return _vsp.GetAllBackground3Ds()
[docs] def ShowAllBackground3Ds(): """ShowAllBackground3Ds()""" return _vsp.ShowAllBackground3Ds()
[docs] def HideAllBackground3Ds(): """HideAllBackground3Ds()""" return _vsp.HideAllBackground3Ds()
[docs] def DelAllBackground3Ds(): """DelAllBackground3Ds()""" return _vsp.DelAllBackground3Ds()
[docs] def DelBackground3D(id): """DelBackground3D(std::string const & id)""" return _vsp.DelBackground3D(id)
[docs] def GetAllBackground3DRelativePaths(): """GetAllBackground3DRelativePaths() -> StringVector""" return _vsp.GetAllBackground3DRelativePaths()
[docs] def GetAllBackground3DAbsolutePaths(): """GetAllBackground3DAbsolutePaths() -> StringVector""" return _vsp.GetAllBackground3DAbsolutePaths()
[docs] def GetBackground3DRelativePath(id): """GetBackground3DRelativePath(std::string const & id) -> std::string""" return _vsp.GetBackground3DRelativePath(id)
[docs] def GetBackground3DAbsolutePath(id): """GetBackground3DAbsolutePath(std::string const & id) -> std::string""" return _vsp.GetBackground3DAbsolutePath(id)
[docs] def SetBackground3DRelativePath(id, fname): """SetBackground3DRelativePath(std::string const & id, std::string const & fname)""" return _vsp.SetBackground3DRelativePath(id, fname)
[docs] def SetBackground3DAbsolutePath(id, fname): """SetBackground3DAbsolutePath(std::string const & id, std::string const & fname)""" return _vsp.SetBackground3DAbsolutePath(id, fname)
[docs] def CreateAndAddBogie(gear_id): """CreateAndAddBogie(std::string const & gear_id) -> std::string""" return _vsp.CreateAndAddBogie(gear_id)
[docs] def GetNumBogies(gear_id): """GetNumBogies(std::string const & gear_id) -> int""" return _vsp.GetNumBogies(gear_id)
[docs] def GetAllBogies(gear_id): """GetAllBogies(std::string const & gear_id) -> StringVector""" return _vsp.GetAllBogies(gear_id)
[docs] def DelBogie(gear_id, bogie_id): """DelBogie(std::string const & gear_id, std::string const & bogie_id)""" return _vsp.DelBogie(gear_id, bogie_id)
[docs] def DelAllBogies(gear_id): """DelAllBogies(std::string const & gear_id)""" return _vsp.DelAllBogies(gear_id)
[docs] def SetAuxiliaryGeomContactPtID(geom_id, index, bogie_id): """SetAuxiliaryGeomContactPtID(std::string const & geom_id, int index, std::string const & bogie_id)""" return _vsp.SetAuxiliaryGeomContactPtID(geom_id, index, bogie_id)
[docs] def GetAuxiliaryGeomContactPtID(geom_id, index): """GetAuxiliaryGeomContactPtID(std::string const & geom_id, int index) -> std::string""" return _vsp.GetAuxiliaryGeomContactPtID(geom_id, index)
[docs] def ReadAuxiliaryGeomCCEFile(geom_id, file_name): """ReadAuxiliaryGeomCCEFile(std::string const & geom_id, std::string const & file_name)""" return _vsp.ReadAuxiliaryGeomCCEFile(geom_id, file_name)
[docs] def InitStackPreset(geom_id, preset): """InitStackPreset(std::string const & geom_id, int preset)""" return _vsp.InitStackPreset(geom_id, preset)
[docs] def GetNumRoutingPts(routing_id): """GetNumRoutingPts(std::string const & routing_id) -> int""" return _vsp.GetNumRoutingPts(routing_id)
[docs] def AddRoutingPt(routing_id, geom_id, surf_index): """AddRoutingPt(std::string const & routing_id, std::string const & geom_id, int surf_index) -> std::string""" return _vsp.AddRoutingPt(routing_id, geom_id, surf_index)
[docs] def InsertRoutingPt(routing_id, index, geom_id, surf_index): """InsertRoutingPt(std::string const & routing_id, int index, std::string const & geom_id, int surf_index) -> std::string""" return _vsp.InsertRoutingPt(routing_id, index, geom_id, surf_index)
[docs] def DelRoutingPt(routing_id, index): """DelRoutingPt(std::string const & routing_id, int index)""" return _vsp.DelRoutingPt(routing_id, index)
[docs] def DelAllRoutingPt(routing_id): """DelAllRoutingPt(std::string const & routing_id)""" return _vsp.DelAllRoutingPt(routing_id)
[docs] def MoveRoutingPt(routing_id, index, reorder_type): """MoveRoutingPt(std::string const & routing_id, int index, int reorder_type) -> int""" return _vsp.MoveRoutingPt(routing_id, index, reorder_type)
[docs] def GetRoutingPtID(routing_id, index): """GetRoutingPtID(std::string const & routing_id, int index) -> std::string""" return _vsp.GetRoutingPtID(routing_id, index)
[docs] def GetAllRoutingPtIds(routing_id): """GetAllRoutingPtIds(std::string const & routing_id) -> StringVector""" return _vsp.GetAllRoutingPtIds(routing_id)
[docs] def GetRoutingPtParentID(pt_id): """GetRoutingPtParentID(std::string const & pt_id) -> std::string""" return _vsp.GetRoutingPtParentID(pt_id)
[docs] def SetRoutingPtParentID(pt_id, parent_id): """SetRoutingPtParentID(std::string const & pt_id, std::string const & parent_id)""" return _vsp.SetRoutingPtParentID(pt_id, parent_id)
[docs] def GetMainRoutingPtCoord(pt_id): """GetMainRoutingPtCoord(std::string const & pt_id) -> vec3d""" return _vsp.GetMainRoutingPtCoord(pt_id)
[docs] def GetRoutingPtCoord(routing_id, index, symm_index): """GetRoutingPtCoord(std::string const & routing_id, int index, int symm_index) -> vec3d""" return _vsp.GetRoutingPtCoord(routing_id, index, symm_index)
[docs] def GetAllRoutingPtCoords(routing_id, symm_index): """GetAllRoutingPtCoords(std::string const & routing_id, int symm_index) -> Vec3dVec""" return _vsp.GetAllRoutingPtCoords(routing_id, symm_index)
[docs] def GetRoutingCurve(routing_id, symm_index): """GetRoutingCurve(std::string const & routing_id, int symm_index) -> Vec3dVec""" return _vsp.GetRoutingCurve(routing_id, symm_index)
[docs] def ChangeBORXSecShape(bor_id, type): """ChangeBORXSecShape(std::string const & bor_id, int type)""" return _vsp.ChangeBORXSecShape(bor_id, type)
[docs] def GetBORXSecShape(bor_id): """GetBORXSecShape(std::string const & bor_id) -> int""" return _vsp.GetBORXSecShape(bor_id)
[docs] def ReadBORFileXSec(bor_id, file_name): """ReadBORFileXSec(std::string const & bor_id, std::string const & file_name) -> Vec3dVec""" return _vsp.ReadBORFileXSec(bor_id, file_name)
[docs] def GetBORXSecPnts(bor_id): """GetBORXSecPnts(std::string const & bor_id) -> Vec3dVec""" return _vsp.GetBORXSecPnts(bor_id)
[docs] def SetBORXSecPnts(bor_id, pnt_vec): """SetBORXSecPnts(std::string const & bor_id, Vec3dVec pnt_vec)""" return _vsp.SetBORXSecPnts(bor_id, pnt_vec)
[docs] def ComputeBORXSecPnt(bor_id, fract): """ComputeBORXSecPnt(std::string const & bor_id, double fract) -> vec3d""" return _vsp.ComputeBORXSecPnt(bor_id, fract)
[docs] def ComputeBORXSecTan(bor_id, fract): """ComputeBORXSecTan(std::string const & bor_id, double fract) -> vec3d""" return _vsp.ComputeBORXSecTan(bor_id, fract)
[docs] def ReadBORFileAirfoil(bor_id, file_name): """ReadBORFileAirfoil(std::string const & bor_id, std::string const & file_name)""" return _vsp.ReadBORFileAirfoil(bor_id, file_name)
[docs] def SetBORAirfoilUpperPnts(bor_id, up_pnt_vec): """SetBORAirfoilUpperPnts(std::string const & bor_id, Vec3dVec up_pnt_vec)""" return _vsp.SetBORAirfoilUpperPnts(bor_id, up_pnt_vec)
[docs] def SetBORAirfoilLowerPnts(bor_id, low_pnt_vec): """SetBORAirfoilLowerPnts(std::string const & bor_id, Vec3dVec low_pnt_vec)""" return _vsp.SetBORAirfoilLowerPnts(bor_id, low_pnt_vec)
[docs] def SetBORAirfoilPnts(bor_id, up_pnt_vec, low_pnt_vec): """SetBORAirfoilPnts(std::string const & bor_id, Vec3dVec up_pnt_vec, Vec3dVec low_pnt_vec)""" return _vsp.SetBORAirfoilPnts(bor_id, up_pnt_vec, low_pnt_vec)
[docs] def GetBORAirfoilUpperPnts(bor_id): """GetBORAirfoilUpperPnts(std::string const & bor_id) -> Vec3dVec""" return _vsp.GetBORAirfoilUpperPnts(bor_id)
[docs] def GetBORAirfoilLowerPnts(bor_id): """GetBORAirfoilLowerPnts(std::string const & bor_id) -> Vec3dVec""" return _vsp.GetBORAirfoilLowerPnts(bor_id)
[docs] def GetBORUpperCSTCoefs(bor_id): """GetBORUpperCSTCoefs(std::string const & bor_id) -> DoubleVector""" return _vsp.GetBORUpperCSTCoefs(bor_id)
[docs] def GetBORLowerCSTCoefs(bor_id): """GetBORLowerCSTCoefs(std::string const & bor_id) -> DoubleVector""" return _vsp.GetBORLowerCSTCoefs(bor_id)
[docs] def GetBORUpperCSTDegree(bor_id): """GetBORUpperCSTDegree(std::string const & bor_id) -> int""" return _vsp.GetBORUpperCSTDegree(bor_id)
[docs] def GetBORLowerCSTDegree(bor_id): """GetBORLowerCSTDegree(std::string const & bor_id) -> int""" return _vsp.GetBORLowerCSTDegree(bor_id)
[docs] def SetBORUpperCST(bor_id, deg, coefs): """SetBORUpperCST(std::string const & bor_id, int deg, DoubleVector coefs)""" return _vsp.SetBORUpperCST(bor_id, deg, coefs)
[docs] def SetBORLowerCST(bor_id, deg, coefs): """SetBORLowerCST(std::string const & bor_id, int deg, DoubleVector coefs)""" return _vsp.SetBORLowerCST(bor_id, deg, coefs)
[docs] def PromoteBORCSTUpper(bor_id): """PromoteBORCSTUpper(std::string const & bor_id)""" return _vsp.PromoteBORCSTUpper(bor_id)
[docs] def PromoteBORCSTLower(bor_id): """PromoteBORCSTLower(std::string const & bor_id)""" return _vsp.PromoteBORCSTLower(bor_id)
[docs] def DemoteBORCSTUpper(bor_id): """DemoteBORCSTUpper(std::string const & bor_id)""" return _vsp.DemoteBORCSTUpper(bor_id)
[docs] def DemoteBORCSTLower(bor_id): """DemoteBORCSTLower(std::string const & bor_id)""" return _vsp.DemoteBORCSTLower(bor_id)
[docs] def FitBORAfCST(bor_id, deg): """FitBORAfCST(std::string const & bor_id, int deg)""" return _vsp.FitBORAfCST(bor_id, deg)
[docs] def WriteBezierAirfoil(file_name, geom_id, foilsurf_u): """WriteBezierAirfoil(std::string const & file_name, std::string const & geom_id, double const & foilsurf_u)""" return _vsp.WriteBezierAirfoil(file_name, geom_id, foilsurf_u)
[docs] def WriteSeligAirfoil(file_name, geom_id, foilsurf_u): """WriteSeligAirfoil(std::string const & file_name, std::string const & geom_id, double const & foilsurf_u)""" return _vsp.WriteSeligAirfoil(file_name, geom_id, foilsurf_u)
[docs] def GetAirfoilCoordinates(geom_id, foilsurf_u): """GetAirfoilCoordinates(std::string const & geom_id, double const & foilsurf_u) -> Vec3dVec""" return _vsp.GetAirfoilCoordinates(geom_id, foilsurf_u)
[docs] def EditXSecInitShape(xsec_id): """EditXSecInitShape(std::string const & xsec_id)""" return _vsp.EditXSecInitShape(xsec_id)
[docs] def EditXSecConvertTo(xsec_id, newtype): """EditXSecConvertTo(std::string const & xsec_id, int const & newtype)""" return _vsp.EditXSecConvertTo(xsec_id, newtype)
[docs] def GetEditXSecUVec(xsec_id): """GetEditXSecUVec(std::string const & xsec_id) -> DoubleVector""" return _vsp.GetEditXSecUVec(xsec_id)
[docs] def GetEditXSecCtrlVec(xsec_id, non_dimensional=True): """ GetEditXSecCtrlVec(std::string const & xsec_id, bool non_dimensional=True) -> Vec3dVec GetEditXSecCtrlVec(std::string const & xsec_id) -> Vec3dVec """ return _vsp.GetEditXSecCtrlVec(xsec_id, non_dimensional)
[docs] def SetEditXSecPnts(xsec_id, u_vec, control_pts, r_vec): """SetEditXSecPnts(std::string const & xsec_id, DoubleVector u_vec, Vec3dVec control_pts, DoubleVector r_vec)""" return _vsp.SetEditXSecPnts(xsec_id, u_vec, control_pts, r_vec)
[docs] def EditXSecDelPnt(xsec_id, indx): """EditXSecDelPnt(std::string const & xsec_id, int const & indx)""" return _vsp.EditXSecDelPnt(xsec_id, indx)
[docs] def EditXSecSplit01(xsec_id, u): """EditXSecSplit01(std::string const & xsec_id, double const & u) -> int""" return _vsp.EditXSecSplit01(xsec_id, u)
[docs] def MoveEditXSecPnt(xsec_id, indx, new_pnt): """MoveEditXSecPnt(std::string const & xsec_id, int const & indx, vec3d new_pnt)""" return _vsp.MoveEditXSecPnt(xsec_id, indx, new_pnt)
[docs] def ConvertXSecToEdit(geom_id, indx=0): """ ConvertXSecToEdit(std::string const & geom_id, int const & indx=0) ConvertXSecToEdit(std::string const & geom_id) """ return _vsp.ConvertXSecToEdit(geom_id, indx)
[docs] def GetEditXSecFixedUVec(xsec_id): """GetEditXSecFixedUVec(std::string const & xsec_id) -> BoolVector""" return _vsp.GetEditXSecFixedUVec(xsec_id)
[docs] def SetEditXSecFixedUVec(xsec_id, fixed_u_vec): """SetEditXSecFixedUVec(std::string const & xsec_id, BoolVector fixed_u_vec)""" return _vsp.SetEditXSecFixedUVec(xsec_id, fixed_u_vec)
[docs] def ReparameterizeEditXSec(xsec_id): """ReparameterizeEditXSec(std::string const & xsec_id)""" return _vsp.ReparameterizeEditXSec(xsec_id)
[docs] def GetNumSets(): """GetNumSets() -> int""" return _vsp.GetNumSets()
[docs] def SetSetName(index, name): """SetSetName(int index, std::string const & name)""" return _vsp.SetSetName(index, name)
[docs] def GetSetName(index): """GetSetName(int index) -> std::string""" return _vsp.GetSetName(index)
[docs] def GetGeomSetAtIndex(index): """GetGeomSetAtIndex(int index) -> StringVector""" return _vsp.GetGeomSetAtIndex(index)
[docs] def GetGeomSet(name): """GetGeomSet(std::string const & name) -> StringVector""" return _vsp.GetGeomSet(name)
[docs] def GetSetIndex(name): """GetSetIndex(std::string const & name) -> int""" return _vsp.GetSetIndex(name)
[docs] def GetSetFlag(geom_id, set_index): """GetSetFlag(std::string const & geom_id, int set_index) -> bool""" return _vsp.GetSetFlag(geom_id, set_index)
[docs] def SetSetFlag(geom_id, set_index, flag): """SetSetFlag(std::string const & geom_id, int set_index, bool flag)""" return _vsp.SetSetFlag(geom_id, set_index, flag)
[docs] def CopyPasteSet(copyIndex, pasteIndex): """CopyPasteSet(int copyIndex, int pasteIndex)""" return _vsp.CopyPasteSet(copyIndex, pasteIndex)
[docs] def GetBBoxSet(set): """GetBBoxSet(int set) -> bool""" return _vsp.GetBBoxSet(set)
[docs] def GetScaleIndependentBBoxSet(set): """GetScaleIndependentBBoxSet(int set) -> bool""" return _vsp.GetScaleIndependentBBoxSet(set)
[docs] def ScaleSet(set_index, scale): """ScaleSet(int set_index, double scale)""" return _vsp.ScaleSet(set_index, scale)
[docs] def RotateSet(set_index, x_rot_deg, y_rot_deg, z_rot_deg): """RotateSet(int set_index, double x_rot_deg, double y_rot_deg, double z_rot_deg)""" return _vsp.RotateSet(set_index, x_rot_deg, y_rot_deg, z_rot_deg)
[docs] def TranslateSet(set_index, translation_vec): """TranslateSet(int set_index, vec3d translation_vec)""" return _vsp.TranslateSet(set_index, translation_vec)
[docs] def TransformSet(set_index, translation_vec, x_rot_deg, y_rot_deg, z_rot_deg, scale, scale_translations_flag): """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.TransformSet(set_index, translation_vec, x_rot_deg, y_rot_deg, z_rot_deg, scale, scale_translations_flag)
[docs] def ValidParm(id): """ValidParm(std::string const & id) -> bool""" return _vsp.ValidParm(id)
[docs] def SetParmVal(*args): """ 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.SetParmVal(*args)
[docs] def SetParmValLimits(parm_id, val, lower_limit, upper_limit): """SetParmValLimits(std::string const & parm_id, double val, double lower_limit, double upper_limit) -> double""" return _vsp.SetParmValLimits(parm_id, val, lower_limit, upper_limit)
[docs] def SetParmValUpdate(*args): """ 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.SetParmValUpdate(*args)
[docs] def GetParmVal(*args): """ GetParmVal(std::string const & parm_id) -> double GetParmVal(std::string const & geom_id, std::string const & name, std::string const & group) -> double """ return _vsp.GetParmVal(*args)
[docs] def GetIntParmVal(parm_id): """GetIntParmVal(std::string const & parm_id) -> int""" return _vsp.GetIntParmVal(parm_id)
[docs] def GetBoolParmVal(parm_id): """GetBoolParmVal(std::string const & parm_id) -> bool""" return _vsp.GetBoolParmVal(parm_id)
[docs] def SetParmUpperLimit(parm_id, val): """SetParmUpperLimit(std::string const & parm_id, double val)""" return _vsp.SetParmUpperLimit(parm_id, val)
[docs] def GetParmUpperLimit(parm_id): """GetParmUpperLimit(std::string const & parm_id) -> double""" return _vsp.GetParmUpperLimit(parm_id)
[docs] def SetParmLowerLimit(parm_id, val): """SetParmLowerLimit(std::string const & parm_id, double val)""" return _vsp.SetParmLowerLimit(parm_id, val)
[docs] def GetParmLowerLimit(parm_id): """GetParmLowerLimit(std::string const & parm_id) -> double""" return _vsp.GetParmLowerLimit(parm_id)
[docs] def GetParmType(parm_id): """GetParmType(std::string const & parm_id) -> int""" return _vsp.GetParmType(parm_id)
[docs] def GetParmName(parm_id): """GetParmName(std::string const & parm_id) -> std::string""" return _vsp.GetParmName(parm_id)
[docs] def GetParmGroupName(parm_id): """GetParmGroupName(std::string const & parm_id) -> std::string""" return _vsp.GetParmGroupName(parm_id)
[docs] def GetParmDisplayGroupName(parm_id): """GetParmDisplayGroupName(std::string const & parm_id) -> std::string""" return _vsp.GetParmDisplayGroupName(parm_id)
[docs] def GetParmContainer(parm_id): """GetParmContainer(std::string const & parm_id) -> std::string""" return _vsp.GetParmContainer(parm_id)
[docs] def SetParmDescript(parm_id, desc): """SetParmDescript(std::string const & parm_id, std::string const & desc)""" return _vsp.SetParmDescript(parm_id, desc)
[docs] def GetParmDescript(parm_id): """GetParmDescript(std::string const & parm_id) -> std::string""" return _vsp.GetParmDescript(parm_id)
[docs] def FindParm(parm_container_id, parm_name, group_name): """FindParm(std::string const & parm_container_id, std::string const & parm_name, std::string const & group_name) -> std::string""" return _vsp.FindParm(parm_container_id, parm_name, group_name)
[docs] def FindContainers(): """FindContainers() -> StringVector""" return _vsp.FindContainers()
[docs] def FindContainersWithName(name): """FindContainersWithName(std::string const & name) -> StringVector""" return _vsp.FindContainersWithName(name)
[docs] def FindContainer(name, index): """FindContainer(std::string const & name, int index) -> std::string""" return _vsp.FindContainer(name, index)
[docs] def SetContainerName(parm_container_id, name): """SetContainerName(std::string const & parm_container_id, std::string const & name)""" return _vsp.SetContainerName(parm_container_id, name)
[docs] def GetContainerName(parm_container_id): """GetContainerName(std::string const & parm_container_id) -> std::string""" return _vsp.GetContainerName(parm_container_id)
[docs] def FindContainerGroupNames(parm_container_id): """FindContainerGroupNames(std::string const & parm_container_id) -> StringVector""" return _vsp.FindContainerGroupNames(parm_container_id)
[docs] def FindContainerParmIDs(parm_container_id): """FindContainerParmIDs(std::string const & parm_container_id) -> StringVector""" return _vsp.FindContainerParmIDs(parm_container_id)
[docs] def GetVehicleID(): """GetVehicleID() -> std::string""" return _vsp.GetVehicleID()
[docs] def GetNumUserParms(): """GetNumUserParms() -> int""" return _vsp.GetNumUserParms()
[docs] def GetNumPredefinedUserParms(): """GetNumPredefinedUserParms() -> int""" return _vsp.GetNumPredefinedUserParms()
[docs] def GetAllUserParms(): """GetAllUserParms() -> StringVector""" return _vsp.GetAllUserParms()
[docs] def GetUserParmContainer(): """GetUserParmContainer() -> std::string""" return _vsp.GetUserParmContainer()
[docs] def AddUserParm(type, name, group): """AddUserParm(int type, std::string const & name, std::string const & group) -> std::string""" return _vsp.AddUserParm(type, name, group)
[docs] def DeleteUserParm(id): """DeleteUserParm(std::string const & id)""" return _vsp.DeleteUserParm(id)
[docs] def DeleteAllUserParm(): """DeleteAllUserParm()""" return _vsp.DeleteAllUserParm()
[docs] def ComputeMinClearanceDistance(*args): """ ComputeMinClearanceDistance(std::string const & geom_id, int set, bool useMode=False, std::string const & modeID) -> double ComputeMinClearanceDistance(std::string const & geom_id, int set, bool useMode=False) -> double ComputeMinClearanceDistance(std::string const & geom_id, int set) -> double ComputeMinClearanceDistance(std::string const & geom_id) -> double """ return _vsp.ComputeMinClearanceDistance(*args)
[docs] def SnapParm(*args): """ SnapParm(std::string const & parm_id, double target_min_dist, bool inc_flag, int set, bool useMode=False, std::string const & modeID) -> double SnapParm(std::string const & parm_id, double target_min_dist, bool inc_flag, int set, bool useMode=False) -> double SnapParm(std::string const & parm_id, double target_min_dist, bool inc_flag, int set) -> double SnapParm(std::string const & parm_id, double target_min_dist, bool inc_flag) -> double """ return _vsp.SnapParm(*args)
[docs] def ResetFitModel(): """ResetFitModel()""" return _vsp.ResetFitModel()
[docs] def AddFitModelTargetPt(*args): """ AddFitModelTargetPt(std::string const & geom_id, int surf_indx, vec3d pt, int u_type, int w_type, double u=0.0, double w=0.0) -> int AddFitModelTargetPt(std::string const & geom_id, int surf_indx, vec3d pt, int u_type, int w_type, double u=0.0) -> int AddFitModelTargetPt(std::string const & geom_id, int surf_indx, vec3d pt, int u_type, int w_type) -> int AddFitModelTargetPt(std::string const & geom_id, int surf_indx, vec3d pt, int u_type) -> int AddFitModelTargetPt(std::string const & geom_id, int surf_indx, vec3d pt) -> int """ return _vsp.AddFitModelTargetPt(*args)
[docs] def AddFitModelTargetPtFixedU(geom_id, surf_indx, pt, u): """AddFitModelTargetPtFixedU(std::string const & geom_id, int surf_indx, vec3d pt, double u) -> int""" return _vsp.AddFitModelTargetPtFixedU(geom_id, surf_indx, pt, u)
[docs] def AddFitModelTargetPtFixedW(geom_id, surf_indx, pt, w): """AddFitModelTargetPtFixedW(std::string const & geom_id, int surf_indx, vec3d pt, double w) -> int""" return _vsp.AddFitModelTargetPtFixedW(geom_id, surf_indx, pt, w)
[docs] def AddFitModelTargetPtFixedUW(geom_id, surf_indx, pt, u, w): """AddFitModelTargetPtFixedUW(std::string const & geom_id, int surf_indx, vec3d pt, double u, double w) -> int""" return _vsp.AddFitModelTargetPtFixedUW(geom_id, surf_indx, pt, u, w)
[docs] def AddFitModelTargetPts(geom_id, surf_indx, pt_vec): """AddFitModelTargetPts(std::string const & geom_id, int surf_indx, Vec3dVec pt_vec)""" return _vsp.AddFitModelTargetPts(geom_id, surf_indx, pt_vec)
[docs] def AddFitModelTargetPtsFixedU(geom_id, surf_indx, pt_vec, u): """AddFitModelTargetPtsFixedU(std::string const & geom_id, int surf_indx, Vec3dVec pt_vec, double u)""" return _vsp.AddFitModelTargetPtsFixedU(geom_id, surf_indx, pt_vec, u)
[docs] def AddFitModelTargetPtsFixedUs(geom_id, surf_indx, pt_vec, u_vec): """AddFitModelTargetPtsFixedUs(std::string const & geom_id, int surf_indx, Vec3dVec pt_vec, DoubleVector u_vec)""" return _vsp.AddFitModelTargetPtsFixedUs(geom_id, surf_indx, pt_vec, u_vec)
[docs] def AddFitModelTargetPtsFixedW(geom_id, surf_indx, pt_vec, w): """AddFitModelTargetPtsFixedW(std::string const & geom_id, int surf_indx, Vec3dVec pt_vec, double w)""" return _vsp.AddFitModelTargetPtsFixedW(geom_id, surf_indx, pt_vec, w)
[docs] def AddFitModelTargetPtsFixedWs(geom_id, surf_indx, pt_vec, w_vec): """AddFitModelTargetPtsFixedWs(std::string const & geom_id, int surf_indx, Vec3dVec pt_vec, DoubleVector w_vec)""" return _vsp.AddFitModelTargetPtsFixedWs(geom_id, surf_indx, pt_vec, w_vec)
[docs] def AddFitModelTargetPtsFixedUW(geom_id, surf_indx, pt_vec, u, w): """AddFitModelTargetPtsFixedUW(std::string const & geom_id, int surf_indx, Vec3dVec pt_vec, double u, double w)""" return _vsp.AddFitModelTargetPtsFixedUW(geom_id, surf_indx, pt_vec, u, w)
[docs] def AddFitModelTargetPtsFixedUWs(geom_id, surf_indx, pt_vec, u_vec, w_vec): """AddFitModelTargetPtsFixedUWs(std::string const & geom_id, int surf_indx, Vec3dVec pt_vec, DoubleVector u_vec, DoubleVector w_vec)""" return _vsp.AddFitModelTargetPtsFixedUWs(geom_id, surf_indx, pt_vec, u_vec, w_vec)
[docs] def DelFitModelTargetPt(index): """DelFitModelTargetPt(int index)""" return _vsp.DelFitModelTargetPt(index)
[docs] def DelAllFitModelTargetPts(): """DelAllFitModelTargetPts()""" return _vsp.DelAllFitModelTargetPts()
[docs] def SortFitModelTargetPtsByDist(): """SortFitModelTargetPtsByDist()""" return _vsp.SortFitModelTargetPtsByDist()
[docs] def MoveFitModelTargetPt(index, reorder_type): """MoveFitModelTargetPt(int index, int reorder_type) -> int""" return _vsp.MoveFitModelTargetPt(index, reorder_type)
[docs] def GetNumFitModelTargetPts(): """GetNumFitModelTargetPts() -> int""" return _vsp.GetNumFitModelTargetPts()
[docs] def GetFitModelTargetPt(index): """GetFitModelTargetPt(int index) -> vec3d""" return _vsp.GetFitModelTargetPt(index)
[docs] def SetFitModelTargetPt(index, pt): """SetFitModelTargetPt(int index, vec3d pt)""" return _vsp.SetFitModelTargetPt(index, pt)
[docs] def GetFitModelTargetPtGeom(index): """GetFitModelTargetPtGeom(int index) -> std::string""" return _vsp.GetFitModelTargetPtGeom(index)
[docs] def SetFitModelTargetPtGeom(index, geom_id): """SetFitModelTargetPtGeom(int index, std::string const & geom_id)""" return _vsp.SetFitModelTargetPtGeom(index, geom_id)
[docs] def GetFitModelTargetPtSurfIndx(index): """GetFitModelTargetPtSurfIndx(int index) -> int""" return _vsp.GetFitModelTargetPtSurfIndx(index)
[docs] def SetFitModelTargetPtSurfIndx(index, surf_indx): """SetFitModelTargetPtSurfIndx(int index, int surf_indx)""" return _vsp.SetFitModelTargetPtSurfIndx(index, surf_indx)
[docs] def GetFitModelTargetPtU(index): """GetFitModelTargetPtU(int index) -> double""" return _vsp.GetFitModelTargetPtU(index)
[docs] def GetFitModelTargetPtW(index): """GetFitModelTargetPtW(int index) -> double""" return _vsp.GetFitModelTargetPtW(index)
[docs] def GetFitModelTargetPtDist(index): """GetFitModelTargetPtDist(int index) -> double""" return _vsp.GetFitModelTargetPtDist(index)
[docs] def SetFitModelTargetPtUW(index, u, w): """SetFitModelTargetPtUW(int index, double u, double w)""" return _vsp.SetFitModelTargetPtUW(index, u, w)
[docs] def GetFitModelTargetPtUType(index): """GetFitModelTargetPtUType(int index) -> int""" return _vsp.GetFitModelTargetPtUType(index)
[docs] def SetFitModelTargetPtUType(index, u_type): """SetFitModelTargetPtUType(int index, int u_type)""" return _vsp.SetFitModelTargetPtUType(index, u_type)
[docs] def GetFitModelTargetPtWType(index): """GetFitModelTargetPtWType(int index) -> int""" return _vsp.GetFitModelTargetPtWType(index)
[docs] def SetFitModelTargetPtWType(index, w_type): """SetFitModelTargetPtWType(int index, int w_type)""" return _vsp.SetFitModelTargetPtWType(index, w_type)
[docs] def GetFitModelTargetPtSurfPt(index): """GetFitModelTargetPtSurfPt(int index) -> vec3d""" return _vsp.GetFitModelTargetPtSurfPt(index)
[docs] def AddFitModelVar(parm_id): """AddFitModelVar(std::string const & parm_id)""" return _vsp.AddFitModelVar(parm_id)
[docs] def DelFitModelVar(parm_id): """DelFitModelVar(std::string const & parm_id)""" return _vsp.DelFitModelVar(parm_id)
[docs] def DelAllFitModelVars(): """DelAllFitModelVars()""" return _vsp.DelAllFitModelVars()
[docs] def GetNumFitModelVars(): """GetNumFitModelVars() -> int""" return _vsp.GetNumFitModelVars()
[docs] def GetFitModelVar(index): """GetFitModelVar(int index) -> std::string""" return _vsp.GetFitModelVar(index)
[docs] def GetFitModelVarVec(): """GetFitModelVarVec() -> StringVector""" return _vsp.GetFitModelVarVec()
[docs] def SearchFitModelTargetUW(): """SearchFitModelTargetUW()""" return _vsp.SearchFitModelTargetUW()
[docs] def RefineFitModelTargetUW(): """RefineFitModelTargetUW()""" return _vsp.RefineFitModelTargetUW()
[docs] def UpdateFitModelDist(): """UpdateFitModelDist() -> double""" return _vsp.UpdateFitModelDist()
[docs] def GetFitModelDist(): """GetFitModelDist() -> double""" return _vsp.GetFitModelDist()
[docs] def GetNumFitModelOptVars(): """GetNumFitModelOptVars() -> int""" return _vsp.GetNumFitModelOptVars()
[docs] def OptimizeFitModel(): """OptimizeFitModel() -> int""" return _vsp.OptimizeFitModel()
[docs] def CanUndoFitModel(): """CanUndoFitModel() -> bool""" return _vsp.CanUndoFitModel()
[docs] def UndoFitModel(): """UndoFitModel() -> bool""" return _vsp.UndoFitModel()
[docs] def SaveFitModelFile(file_name): """SaveFitModelFile(std::string const & file_name)""" return _vsp.SaveFitModelFile(file_name)
[docs] def LoadFitModelFile(file_name): """LoadFitModelFile(std::string const & file_name) -> int""" return _vsp.LoadFitModelFile(file_name)
[docs] def CreatePtCloudGeomFromPts(pt_vec, name): """CreatePtCloudGeomFromPts(Vec3dVec pt_vec, std::string const & name) -> std::string""" return _vsp.CreatePtCloudGeomFromPts(pt_vec, name)
[docs] def KeepPtsInBBox(pt_vec, min_pt, max_pt): """KeepPtsInBBox(Vec3dVec pt_vec, vec3d min_pt, vec3d max_pt) -> Vec3dVec""" return _vsp.KeepPtsInBBox(pt_vec, min_pt, max_pt)
[docs] def RemovePtsInBBox(pt_vec, min_pt, max_pt): """RemovePtsInBBox(Vec3dVec pt_vec, vec3d min_pt, vec3d max_pt) -> Vec3dVec""" return _vsp.RemovePtsInBBox(pt_vec, min_pt, max_pt)
[docs] def KeepPtsInRange(pt_vec, dir_index, low, high): """KeepPtsInRange(Vec3dVec pt_vec, int dir_index, double low, double high) -> Vec3dVec""" return _vsp.KeepPtsInRange(pt_vec, dir_index, low, high)
[docs] def RemovePtsInRange(pt_vec, dir_index, low, high): """RemovePtsInRange(Vec3dVec pt_vec, int dir_index, double low, double high) -> Vec3dVec""" return _vsp.RemovePtsInRange(pt_vec, dir_index, low, high)
[docs] def KeepPtsAbove(pt_vec, dir_index, val): """KeepPtsAbove(Vec3dVec pt_vec, int dir_index, double val) -> Vec3dVec""" return _vsp.KeepPtsAbove(pt_vec, dir_index, val)
[docs] def KeepPtsBelow(pt_vec, dir_index, val): """KeepPtsBelow(Vec3dVec pt_vec, int dir_index, double val) -> Vec3dVec""" return _vsp.KeepPtsBelow(pt_vec, dir_index, val)
[docs] def KeepPtsNearPt(pt_vec, center, radius): """KeepPtsNearPt(Vec3dVec pt_vec, vec3d center, double radius) -> Vec3dVec""" return _vsp.KeepPtsNearPt(pt_vec, center, radius)
[docs] def RemovePtsNearPt(pt_vec, center, radius): """RemovePtsNearPt(Vec3dVec pt_vec, vec3d center, double radius) -> Vec3dVec""" return _vsp.RemovePtsNearPt(pt_vec, center, radius)
[docs] def KeepPtsNearGeom(pt_vec, geom_id, surf_indx, tol): """KeepPtsNearGeom(Vec3dVec pt_vec, std::string const & geom_id, int surf_indx, double tol) -> Vec3dVec""" return _vsp.KeepPtsNearGeom(pt_vec, geom_id, surf_indx, tol)
[docs] def RemovePtsNearGeom(pt_vec, geom_id, surf_indx, tol): """RemovePtsNearGeom(Vec3dVec pt_vec, std::string const & geom_id, int surf_indx, double tol) -> Vec3dVec""" return _vsp.RemovePtsNearGeom(pt_vec, geom_id, surf_indx, tol)
[docs] def UniquePts(pt_vec, tol): """UniquePts(Vec3dVec pt_vec, double tol) -> Vec3dVec""" return _vsp.UniquePts(pt_vec, tol)
[docs] def UnionPts(pt_vec_a, pt_vec_b, tol): """UnionPts(Vec3dVec pt_vec_a, Vec3dVec pt_vec_b, double tol) -> Vec3dVec""" return _vsp.UnionPts(pt_vec_a, pt_vec_b, tol)
[docs] def IntersectPts(pt_vec_a, pt_vec_b, tol): """IntersectPts(Vec3dVec pt_vec_a, Vec3dVec pt_vec_b, double tol) -> Vec3dVec""" return _vsp.IntersectPts(pt_vec_a, pt_vec_b, tol)
[docs] def SubtractPts(pt_vec_a, pt_vec_b, tol): """SubtractPts(Vec3dVec pt_vec_a, Vec3dVec pt_vec_b, double tol) -> Vec3dVec""" return _vsp.SubtractPts(pt_vec_a, pt_vec_b, tol)
[docs] def AddVarPresetGroup(group_name): """AddVarPresetGroup(std::string const & group_name) -> std::string""" return _vsp.AddVarPresetGroup(group_name)
[docs] def AddVarPresetSetting(group_id, setting_name): """AddVarPresetSetting(std::string const & group_id, std::string const & setting_name) -> std::string""" return _vsp.AddVarPresetSetting(group_id, setting_name)
[docs] def AddVarPresetParm(group_id, parm_id): """AddVarPresetParm(std::string const & group_id, std::string const & parm_id)""" return _vsp.AddVarPresetParm(group_id, parm_id)
[docs] def DeleteAllVarPresetGroups(): """DeleteAllVarPresetGroups()""" return _vsp.DeleteAllVarPresetGroups()
[docs] def DeleteVarPresetGroup(group_id): """DeleteVarPresetGroup(std::string const & group_id)""" return _vsp.DeleteVarPresetGroup(group_id)
[docs] def DeleteAllVarPresetSettings(group_id): """DeleteAllVarPresetSettings(std::string const & group_id)""" return _vsp.DeleteAllVarPresetSettings(group_id)
[docs] def DeleteVarPresetSetting(group_id, setting_id): """DeleteVarPresetSetting(std::string const & group_id, std::string const & setting_id)""" return _vsp.DeleteVarPresetSetting(group_id, setting_id)
[docs] def DeleteVarPresetParm(group_id, parm_id): """DeleteVarPresetParm(std::string const & group_id, std::string const & parm_id)""" return _vsp.DeleteVarPresetParm(group_id, parm_id)
[docs] def SetVarPresetParmVal(group_id, setting_id, parm_id, parm_val): """SetVarPresetParmVal(std::string const & group_id, std::string const & setting_id, std::string const & parm_id, double parm_val)""" return _vsp.SetVarPresetParmVal(group_id, setting_id, parm_id, parm_val)
[docs] def GetVarPresetParmVal(group_id, setting_id, parm_id): """GetVarPresetParmVal(std::string const & group_id, std::string const & setting_id, std::string const & parm_id) -> double""" return _vsp.GetVarPresetParmVal(group_id, setting_id, parm_id)
[docs] def GetGroupName(group_id): """GetGroupName(std::string const & group_id) -> std::string""" return _vsp.GetGroupName(group_id)
[docs] def GetSettingName(setting_id): """GetSettingName(std::string const & setting_id) -> std::string""" return _vsp.GetSettingName(setting_id)
[docs] def SetGroupName(group_id, group_name): """SetGroupName(std::string const & group_id, std::string const & group_name)""" return _vsp.SetGroupName(group_id, group_name)
[docs] def SetSettingName(setting_id, setting_name): """SetSettingName(std::string const & setting_id, std::string const & setting_name)""" return _vsp.SetSettingName(setting_id, setting_name)
[docs] def GetVarPresetGroups(): """GetVarPresetGroups() -> StringVector""" return _vsp.GetVarPresetGroups()
[docs] def GetVarPresetSettings(group_id): """GetVarPresetSettings(std::string const & group_id) -> StringVector""" return _vsp.GetVarPresetSettings(group_id)
[docs] def GetVarPresetParmIDs(group_id): """GetVarPresetParmIDs(std::string const & group_id) -> StringVector""" return _vsp.GetVarPresetParmIDs(group_id)
[docs] def GetVarPresetParmVals(setting_id): """GetVarPresetParmVals(std::string const & setting_id) -> DoubleVector""" return _vsp.GetVarPresetParmVals(setting_id)
[docs] def SetVarPresetParmVals(setting_id, parm_vals): """SetVarPresetParmVals(std::string const & setting_id, DoubleVector parm_vals)""" return _vsp.SetVarPresetParmVals(setting_id, parm_vals)
[docs] def SaveVarPresetParmVals(group_id, setting_id): """SaveVarPresetParmVals(std::string const & group_id, std::string const & setting_id)""" return _vsp.SaveVarPresetParmVals(group_id, setting_id)
[docs] def ApplyVarPresetSetting(group_id, setting_id): """ApplyVarPresetSetting(std::string const & group_id, std::string const & setting_id)""" return _vsp.ApplyVarPresetSetting(group_id, setting_id)
[docs] def CreateAndAddMode(name, normal_set, degen_set): """CreateAndAddMode(std::string const & name, int normal_set, int degen_set) -> std::string""" return _vsp.CreateAndAddMode(name, normal_set, degen_set)
[docs] def GetNumModes(): """GetNumModes() -> int""" return _vsp.GetNumModes()
[docs] def GetAllModes(): """GetAllModes() -> StringVector""" return _vsp.GetAllModes()
[docs] def DelMode(mid): """DelMode(std::string const & mid)""" return _vsp.DelMode(mid)
[docs] def DelAllModes(): """DelAllModes()""" return _vsp.DelAllModes()
[docs] def GetModeName(mid): """GetModeName(std::string const & mid) -> std::string""" return _vsp.GetModeName(mid)
[docs] def SetModeName(mid, name): """SetModeName(std::string const & mid, std::string const & name)""" return _vsp.SetModeName(mid, name)
[docs] def ApplyModeSettings(mid): """ApplyModeSettings(std::string const & mid)""" return _vsp.ApplyModeSettings(mid)
[docs] def ShowOnlyMode(mid): """ShowOnlyMode(std::string const & mid)""" return _vsp.ShowOnlyMode(mid)
[docs] def ModeAddGroupSetting(mid, gid, sid): """ModeAddGroupSetting(std::string const & mid, std::string const & gid, std::string const & sid)""" return _vsp.ModeAddGroupSetting(mid, gid, sid)
[docs] def ModeGetGroup(mid, indx): """ModeGetGroup(std::string const & mid, int indx) -> std::string""" return _vsp.ModeGetGroup(mid, indx)
[docs] def ModeGetSetting(mid, indx): """ModeGetSetting(std::string const & mid, int indx) -> std::string""" return _vsp.ModeGetSetting(mid, indx)
[docs] def ModeGetAllGroups(mid): """ModeGetAllGroups(std::string const & mid) -> StringVector""" return _vsp.ModeGetAllGroups(mid)
[docs] def ModeGetAllSettings(mid): """ModeGetAllSettings(std::string const & mid) -> StringVector""" return _vsp.ModeGetAllSettings(mid)
[docs] def RemoveGroupSetting(mid, indx): """RemoveGroupSetting(std::string const & mid, int indx)""" return _vsp.RemoveGroupSetting(mid, indx)
[docs] def RemoveAllGroupSettings(mid): """RemoveAllGroupSettings(std::string const & mid)""" return _vsp.RemoveAllGroupSettings(mid)
[docs] def SetPCurve(geom_id, pcurveid, tvec, valvec, newtype): """SetPCurve(std::string const & geom_id, int const & pcurveid, DoubleVector tvec, DoubleVector valvec, int const & newtype)""" return _vsp.SetPCurve(geom_id, pcurveid, tvec, valvec, newtype)
[docs] def PCurveConvertTo(geom_id, pcurveid, newtype): """PCurveConvertTo(std::string const & geom_id, int const & pcurveid, int const & newtype)""" return _vsp.PCurveConvertTo(geom_id, pcurveid, newtype)
[docs] def PCurveGetType(geom_id, pcurveid): """PCurveGetType(std::string const & geom_id, int const & pcurveid) -> int""" return _vsp.PCurveGetType(geom_id, pcurveid)
[docs] def PCurveGetTVec(geom_id, pcurveid): """PCurveGetTVec(std::string const & geom_id, int const & pcurveid) -> DoubleVector""" return _vsp.PCurveGetTVec(geom_id, pcurveid)
[docs] def PCurveGetValVec(geom_id, pcurveid): """PCurveGetValVec(std::string const & geom_id, int const & pcurveid) -> DoubleVector""" return _vsp.PCurveGetValVec(geom_id, pcurveid)
[docs] def PCurveDeletePt(geom_id, pcurveid, indx): """PCurveDeletePt(std::string const & geom_id, int const & pcurveid, int const & indx)""" return _vsp.PCurveDeletePt(geom_id, pcurveid, indx)
[docs] def PCurveSplit(geom_id, pcurveid, tsplit): """PCurveSplit(std::string const & geom_id, int const & pcurveid, double const & tsplit) -> int""" return _vsp.PCurveSplit(geom_id, pcurveid, tsplit)
[docs] def ApproximateAllPropellerPCurves(geom_id): """ApproximateAllPropellerPCurves(std::string const & geom_id)""" return _vsp.ApproximateAllPropellerPCurves(geom_id)
[docs] def ResetPropellerThickness(geom_id): """ResetPropellerThickness(std::string const & geom_id)""" return _vsp.ResetPropellerThickness(geom_id)
[docs] def ResetPropellerThicknessCurve(geom_id): """ResetPropellerThicknessCurve(std::string const & geom_id)""" return _vsp.ResetPropellerThicknessCurve(geom_id)
[docs] def AutoGroupVSPAEROControlSurfaces(): """AutoGroupVSPAEROControlSurfaces()""" return _vsp.AutoGroupVSPAEROControlSurfaces()
[docs] def AddCpSlice(cut_type, location): """AddCpSlice(int cut_type, double location) -> std::string""" return _vsp.AddCpSlice(cut_type, location)
[docs] def GetNumCpSlices(): """GetNumCpSlices() -> int""" return _vsp.GetNumCpSlices()
[docs] def GetCpSliceID(slice_index): """GetCpSliceID(int slice_index) -> std::string""" return _vsp.GetCpSliceID(slice_index)
[docs] def DelCpSlice(slice_index): """DelCpSlice(int slice_index)""" return _vsp.DelCpSlice(slice_index)
[docs] def DeleteAllCpSlices(): """DeleteAllCpSlices()""" return _vsp.DeleteAllCpSlices()
[docs] def DeleteVSPAEROControlSurfaceGroup(CSGroupIndex): """DeleteVSPAEROControlSurfaceGroup(int CSGroupIndex)""" return _vsp.DeleteVSPAEROControlSurfaceGroup(CSGroupIndex)
[docs] def CreateVSPAEROControlSurfaceGroup(): """CreateVSPAEROControlSurfaceGroup() -> int""" return _vsp.CreateVSPAEROControlSurfaceGroup()
[docs] def AddAllToVSPAEROControlSurfaceGroup(CSGroupIndex): """AddAllToVSPAEROControlSurfaceGroup(int CSGroupIndex)""" return _vsp.AddAllToVSPAEROControlSurfaceGroup(CSGroupIndex)
[docs] def RemoveAllFromVSPAEROControlSurfaceGroup(CSGroupIndex): """RemoveAllFromVSPAEROControlSurfaceGroup(int CSGroupIndex)""" return _vsp.RemoveAllFromVSPAEROControlSurfaceGroup(CSGroupIndex)
[docs] def GetActiveCSNameVec(CSGroupIndex): """GetActiveCSNameVec(int CSGroupIndex) -> StringVector""" return _vsp.GetActiveCSNameVec(CSGroupIndex)
[docs] def GetCompleteCSNameVec(): """GetCompleteCSNameVec() -> StringVector""" return _vsp.GetCompleteCSNameVec()
[docs] def GetAvailableCSNameVec(CSGroupIndex): """GetAvailableCSNameVec(int CSGroupIndex) -> StringVector""" return _vsp.GetAvailableCSNameVec(CSGroupIndex)
[docs] def SetVSPAEROControlGroupName(name, CSGroupIndex): """SetVSPAEROControlGroupName(std::string const & name, int CSGroupIndex)""" return _vsp.SetVSPAEROControlGroupName(name, CSGroupIndex)
[docs] def GetVSPAEROControlGroupName(CSGroupIndex): """GetVSPAEROControlGroupName(int CSGroupIndex) -> std::string""" return _vsp.GetVSPAEROControlGroupName(CSGroupIndex)
[docs] def AddSelectedToCSGroup(selected, CSGroupIndex): """AddSelectedToCSGroup(IntVector selected, int CSGroupIndex)""" return _vsp.AddSelectedToCSGroup(selected, CSGroupIndex)
[docs] def RemoveSelectedFromCSGroup(selected, CSGroupIndex): """RemoveSelectedFromCSGroup(IntVector selected, int CSGroupIndex)""" return _vsp.RemoveSelectedFromCSGroup(selected, CSGroupIndex)
[docs] def GetNumControlSurfaceGroups(): """GetNumControlSurfaceGroups() -> int""" return _vsp.GetNumControlSurfaceGroups()
[docs] def FindControlSurfaceGroup(group_index): """FindControlSurfaceGroup(int group_index) -> std::string""" return _vsp.FindControlSurfaceGroup(group_index)
[docs] def FindActuatorDisk(disk_index): """FindActuatorDisk(int disk_index) -> std::string""" return _vsp.FindActuatorDisk(disk_index)
[docs] def GetNumActuatorDisks(): """GetNumActuatorDisks() -> int""" return _vsp.GetNumActuatorDisks()
[docs] def FindUnsteadyGroup(group_index): """FindUnsteadyGroup(int group_index) -> std::string""" return _vsp.FindUnsteadyGroup(group_index)
[docs] def GetUnsteadyGroupName(group_index): """GetUnsteadyGroupName(int group_index) -> std::string""" return _vsp.GetUnsteadyGroupName(group_index)
[docs] def GetUnsteadyGroupCompIDs(group_index): """GetUnsteadyGroupCompIDs(int group_index) -> StringVector""" return _vsp.GetUnsteadyGroupCompIDs(group_index)
[docs] def GetUnsteadyGroupSurfIndexes(group_index): """GetUnsteadyGroupSurfIndexes(int group_index) -> IntVector""" return _vsp.GetUnsteadyGroupSurfIndexes(group_index)
[docs] def GetNumUnsteadyGroups(): """GetNumUnsteadyGroups() -> int""" return _vsp.GetNumUnsteadyGroups()
[docs] def GetNumUnsteadyRotorGroups(): """GetNumUnsteadyRotorGroups() -> int""" return _vsp.GetNumUnsteadyRotorGroups()
[docs] def AddExcrescence(excresName, excresType, excresVal): """AddExcrescence(std::string const & excresName, int const & excresType, double const & excresVal)""" return _vsp.AddExcrescence(excresName, excresType, excresVal)
[docs] def GetNumExcrescences(): """GetNumExcrescences() -> int""" return _vsp.GetNumExcrescences()
[docs] def DeleteAllExcrescences(): """DeleteAllExcrescences()""" return _vsp.DeleteAllExcrescences()
[docs] def DeleteExcrescence(index): """DeleteExcrescence(int const & index)""" return _vsp.DeleteExcrescence(index)
[docs] def UpdateParasiteDrag(): """UpdateParasiteDrag()""" return _vsp.UpdateParasiteDrag()
[docs] def ExportParasiteDragToCSV(file_name): """ExportParasiteDragToCSV(std::string const & file_name) -> std::string""" return _vsp.ExportParasiteDragToCSV(file_name)
[docs] def WriteAtmosphereCSVFile(file_name, atmos_type): """WriteAtmosphereCSVFile(std::string const & file_name, int const & atmos_type)""" return _vsp.WriteAtmosphereCSVFile(file_name, atmos_type)
[docs] def CalcAtmosphere(alt, delta_temp, atmos_type): """CalcAtmosphere(double const & alt, double const & delta_temp, int const & atmos_type)""" return _vsp.CalcAtmosphere(alt, delta_temp, atmos_type)
[docs] def WriteBodyFFCSVFile(file_name): """WriteBodyFFCSVFile(std::string const & file_name)""" return _vsp.WriteBodyFFCSVFile(file_name)
[docs] def WriteWingFFCSVFile(file_name): """WriteWingFFCSVFile(std::string const & file_name)""" return _vsp.WriteWingFFCSVFile(file_name)
[docs] def WriteCfEqnCSVFile(file_name): """WriteCfEqnCSVFile(std::string const & file_name)""" return _vsp.WriteCfEqnCSVFile(file_name)
[docs] def WritePartialCfMethodCSVFile(file_name): """WritePartialCfMethodCSVFile(std::string const & file_name)""" return _vsp.WritePartialCfMethodCSVFile(file_name)
[docs] def CompPnt01(geom_id, surf_indx, u, w): """CompPnt01(std::string const & geom_id, int const & surf_indx, double const & u, double const & w) -> vec3d""" return _vsp.CompPnt01(geom_id, surf_indx, u, w)
[docs] def CompNorm01(geom_id, surf_indx, u, w): """CompNorm01(std::string const & geom_id, int const & surf_indx, double const & u, double const & w) -> vec3d""" return _vsp.CompNorm01(geom_id, surf_indx, u, w)
[docs] def CompTanU01(geom_id, surf_indx, u, w): """CompTanU01(std::string const & geom_id, int const & surf_indx, double const & u, double const & w) -> vec3d""" return _vsp.CompTanU01(geom_id, surf_indx, u, w)
[docs] def CompTanW01(geom_id, surf_indx, u, w): """CompTanW01(std::string const & geom_id, int const & surf_indx, double const & u, double const & w) -> vec3d""" return _vsp.CompTanW01(geom_id, surf_indx, u, w)
[docs] def CompCurvature01(geom_id, surf_indx, u, w): """CompCurvature01(std::string const & geom_id, int const & surf_indx, double const & u, double const & w)""" return _vsp.CompCurvature01(geom_id, surf_indx, u, w)
[docs] def ProjPnt01(geom_id, surf_indx, pt): """ProjPnt01(std::string const & geom_id, int const & surf_indx, vec3d pt) -> double""" return _vsp.ProjPnt01(geom_id, surf_indx, pt)
[docs] def ProjPnt01I(geom_id, pt): """ProjPnt01I(std::string const & geom_id, vec3d pt) -> double""" return _vsp.ProjPnt01I(geom_id, pt)
[docs] def ProjPnt01Guess(geom_id, surf_indx, pt, u0, w0): """ProjPnt01Guess(std::string const & geom_id, int const & surf_indx, vec3d pt, double const & u0, double const & w0) -> double""" return _vsp.ProjPnt01Guess(geom_id, surf_indx, pt, u0, w0)
[docs] def AxisProjPnt01(geom_id, surf_indx, iaxis, pt): """AxisProjPnt01(std::string const & geom_id, int const & surf_indx, int const & iaxis, vec3d pt) -> double""" return _vsp.AxisProjPnt01(geom_id, surf_indx, iaxis, pt)
[docs] def AxisProjPnt01I(geom_id, iaxis, pt): """AxisProjPnt01I(std::string const & geom_id, int const & iaxis, vec3d pt) -> double""" return _vsp.AxisProjPnt01I(geom_id, iaxis, pt)
[docs] def AxisProjPnt01Guess(geom_id, surf_indx, iaxis, pt, u0, w0): """AxisProjPnt01Guess(std::string const & geom_id, int const & surf_indx, int const & iaxis, vec3d pt, double const & u0, double const & w0) -> double""" return _vsp.AxisProjPnt01Guess(geom_id, surf_indx, iaxis, pt, u0, w0)
[docs] def InsideSurf(geom_id, surf_indx, pt): """InsideSurf(std::string const & geom_id, int const & surf_indx, vec3d pt) -> bool""" return _vsp.InsideSurf(geom_id, surf_indx, pt)
[docs] def CompPntRST(geom_id, surf_indx, r, s, t): """CompPntRST(std::string const & geom_id, int const & surf_indx, double const & r, double const & s, double const & t) -> vec3d""" return _vsp.CompPntRST(geom_id, surf_indx, r, s, t)
[docs] def FindRST(geom_id, surf_indx, pt): """FindRST(std::string const & geom_id, int const & surf_indx, vec3d pt) -> double""" return _vsp.FindRST(geom_id, surf_indx, pt)
[docs] def FindRSTGuess(geom_id, surf_indx, pt, r0, s0, t0): """FindRSTGuess(std::string const & geom_id, int const & surf_indx, vec3d pt, double const & r0, double const & s0, double const & t0) -> double""" return _vsp.FindRSTGuess(geom_id, surf_indx, pt, r0, s0, t0)
[docs] def ConvertRSTtoLMN(geom_id, surf_indx, r, s, t): """ConvertRSTtoLMN(std::string const & geom_id, int const & surf_indx, double const & r, double const & s, double const & t)""" return _vsp.ConvertRSTtoLMN(geom_id, surf_indx, r, s, t)
[docs] def ConvertRtoL(geom_id, surf_indx, r): """ConvertRtoL(std::string const & geom_id, int const & surf_indx, double const & r)""" return _vsp.ConvertRtoL(geom_id, surf_indx, r)
[docs] def ConvertLMNtoRST(geom_id, surf_indx, l, m, n): """ConvertLMNtoRST(std::string const & geom_id, int const & surf_indx, double const & l, double const & m, double const & n)""" return _vsp.ConvertLMNtoRST(geom_id, surf_indx, l, m, n)
[docs] def ConvertLtoR(geom_id, surf_indx, l): """ConvertLtoR(std::string const & geom_id, int const & surf_indx, double const & l)""" return _vsp.ConvertLtoR(geom_id, surf_indx, l)
[docs] def ConvertUtoEta(geom_id, u): """ConvertUtoEta(std::string const & geom_id, double const & u)""" return _vsp.ConvertUtoEta(geom_id, u)
[docs] def ConvertEtatoU(geom_id, eta): """ConvertEtatoU(std::string const & geom_id, double const & eta)""" return _vsp.ConvertEtatoU(geom_id, eta)
[docs] def CompVecPnt01(geom_id, surf_indx, u_in_vec, w_in_vec): """CompVecPnt01(std::string const & geom_id, int const & surf_indx, DoubleVector u_in_vec, DoubleVector w_in_vec) -> Vec3dVec""" return _vsp.CompVecPnt01(geom_id, surf_indx, u_in_vec, w_in_vec)
[docs] def CompVecDegenPnt01(geom_id, surf_indx, degen_type, u_in_vec, w_in_vec): """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.CompVecDegenPnt01(geom_id, surf_indx, degen_type, u_in_vec, w_in_vec)
[docs] def CompVecNorm01(geom_id, surf_indx, us, ws): """CompVecNorm01(std::string const & geom_id, int const & surf_indx, DoubleVector us, DoubleVector ws) -> Vec3dVec""" return _vsp.CompVecNorm01(geom_id, surf_indx, us, ws)
[docs] def CompVecCurvature01(geom_id, surf_indx, us, ws): """CompVecCurvature01(std::string const & geom_id, int const & surf_indx, DoubleVector us, DoubleVector ws)""" return _vsp.CompVecCurvature01(geom_id, surf_indx, us, ws)
[docs] def ProjVecPnt01(geom_id, surf_indx, pts): """ProjVecPnt01(std::string const & geom_id, int const & surf_indx, Vec3dVec pts)""" return _vsp.ProjVecPnt01(geom_id, surf_indx, pts)
[docs] def ProjVecPnt01Guess(geom_id, surf_indx, pts, u0s, w0s): """ProjVecPnt01Guess(std::string const & geom_id, int const & surf_indx, Vec3dVec pts, DoubleVector u0s, DoubleVector w0s)""" return _vsp.ProjVecPnt01Guess(geom_id, surf_indx, pts, u0s, w0s)
[docs] def AxisProjVecPnt01(geom_id, surf_indx, iaxis, pts): """AxisProjVecPnt01(std::string const & geom_id, int const & surf_indx, int const & iaxis, Vec3dVec pts)""" return _vsp.AxisProjVecPnt01(geom_id, surf_indx, iaxis, pts)
[docs] def AxisProjVecPnt01Guess(geom_id, surf_indx, iaxis, pts, u0s, w0s): """AxisProjVecPnt01Guess(std::string const & geom_id, int const & surf_indx, int const & iaxis, Vec3dVec pts, DoubleVector u0s, DoubleVector w0s)""" return _vsp.AxisProjVecPnt01Guess(geom_id, surf_indx, iaxis, pts, u0s, w0s)
[docs] def VecInsideSurf(geom_id, surf_indx, pts): """VecInsideSurf(std::string const & geom_id, int const & surf_indx, Vec3dVec pts) -> BoolVector""" return _vsp.VecInsideSurf(geom_id, surf_indx, pts)
[docs] def CompVecPntRST(geom_id, surf_indx, r_in_vec, s_in_vec, t_in_vec): """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.CompVecPntRST(geom_id, surf_indx, r_in_vec, s_in_vec, t_in_vec)
[docs] def FindRSTVec(geom_id, surf_indx, pts): """FindRSTVec(std::string const & geom_id, int const & surf_indx, Vec3dVec pts)""" return _vsp.FindRSTVec(geom_id, surf_indx, pts)
[docs] def FindRSTVecGuess(geom_id, surf_indx, pts, r0s, s0s, t0s): """FindRSTVecGuess(std::string const & geom_id, int const & surf_indx, Vec3dVec pts, DoubleVector r0s, DoubleVector s0s, DoubleVector t0s)""" return _vsp.FindRSTVecGuess(geom_id, surf_indx, pts, r0s, s0s, t0s)
[docs] def ConvertRSTtoLMNVec(geom_id, surf_indx, r_vec, s_vec, t_vec): """ConvertRSTtoLMNVec(std::string const & geom_id, int const & surf_indx, DoubleVector r_vec, DoubleVector s_vec, DoubleVector t_vec)""" return _vsp.ConvertRSTtoLMNVec(geom_id, surf_indx, r_vec, s_vec, t_vec)
[docs] def ConvertLMNtoRSTVec(geom_id, surf_indx, l_vec, m_vec, n_vec): """ConvertLMNtoRSTVec(std::string const & geom_id, int const & surf_indx, DoubleVector l_vec, DoubleVector m_vec, DoubleVector n_vec)""" return _vsp.ConvertLMNtoRSTVec(geom_id, surf_indx, l_vec, m_vec, n_vec)
[docs] def GetUWTess01(geom_id, surf_indx): """GetUWTess01(std::string const & geom_id, int const & surf_indx)""" return _vsp.GetUWTess01(geom_id, surf_indx)
[docs] def ShowAllRulers(): """ShowAllRulers()""" return _vsp.ShowAllRulers()
[docs] def HideAllRulers(): """HideAllRulers()""" return _vsp.HideAllRulers()
[docs] def ShowAllProbes(): """ShowAllProbes()""" return _vsp.ShowAllProbes()
[docs] def HideAllProbes(): """HideAllProbes()""" return _vsp.HideAllProbes()
[docs] def ShowAllProtractors(): """ShowAllProtractors()""" return _vsp.ShowAllProtractors()
[docs] def HideAllProtractors(): """HideAllProtractors()""" return _vsp.HideAllProtractors()
[docs] def ShowAllRSTProbes(): """ShowAllRSTProbes()""" return _vsp.ShowAllRSTProbes()
[docs] def HideAllRSTProbes(): """HideAllRSTProbes()""" return _vsp.HideAllRSTProbes()
[docs] def AddProtractor(startgeomid, startsurfindx, startu, startw, midgeomid, midsurfindx, midu, midw, endgeomid, endsurfindx, endu, endw, name): """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.AddProtractor(startgeomid, startsurfindx, startu, startw, midgeomid, midsurfindx, midu, midw, endgeomid, endsurfindx, endu, endw, name)
[docs] def GetAllProtractors(): """GetAllProtractors() -> StringVector""" return _vsp.GetAllProtractors()
[docs] def DelProtractor(id): """DelProtractor(std::string const & id)""" return _vsp.DelProtractor(id)
[docs] def DeleteAllProtractors(): """DeleteAllProtractors()""" return _vsp.DeleteAllProtractors()
[docs] def AddRSTProbe(geomid, surfindx, r, s, t, name): """AddRSTProbe(std::string const & geomid, int surfindx, double r, double s, double t, std::string const & name) -> std::string""" return _vsp.AddRSTProbe(geomid, surfindx, r, s, t, name)
[docs] def GetAllRSTProbes(): """GetAllRSTProbes() -> StringVector""" return _vsp.GetAllRSTProbes()
[docs] def DelRSTProbe(id): """DelRSTProbe(std::string const & id)""" return _vsp.DelRSTProbe(id)
[docs] def DeleteAllRSTProbes(): """DeleteAllRSTProbes()""" return _vsp.DeleteAllRSTProbes()
[docs] def AddRuler(startgeomid, startsurfindx, startu, startw, endgeomid, endsurfindx, endu, endw, name): """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.AddRuler(startgeomid, startsurfindx, startu, startw, endgeomid, endsurfindx, endu, endw, name)
[docs] def GetAllRulers(): """GetAllRulers() -> StringVector""" return _vsp.GetAllRulers()
[docs] def DelRuler(id): """DelRuler(std::string const & id)""" return _vsp.DelRuler(id)
[docs] def DeleteAllRulers(): """DeleteAllRulers()""" return _vsp.DeleteAllRulers()
[docs] def AddProbe(geomid, surfindx, u, w, name): """AddProbe(std::string const & geomid, int surfindx, double u, double w, std::string const & name) -> std::string""" return _vsp.AddProbe(geomid, surfindx, u, w, name)
[docs] def GetAllProbes(): """GetAllProbes() -> StringVector""" return _vsp.GetAllProbes()
[docs] def DelProbe(id): """DelProbe(std::string const & id)""" return _vsp.DelProbe(id)
[docs] def DeleteAllProbes(): """DeleteAllProbes()""" return _vsp.DeleteAllProbes()
[docs] def CopyAirfoil(geom_id, index): """CopyAirfoil(std::string const & geom_id, int index)""" return _vsp.CopyAirfoil(geom_id, index)
[docs] def PasteAirfoil(geom_id, index): """PasteAirfoil(std::string const & geom_id, int index)""" return _vsp.PasteAirfoil(geom_id, index)
[docs] def ClearSkinning(geom_id, index=-1): """ ClearSkinning(std::string const & geom_id, int index=-1) ClearSkinning(std::string const & geom_id) """ return _vsp.ClearSkinning(geom_id, index)
[docs] def ResetGeomScale(geom_id): """ResetGeomScale(std::string const & geom_id)""" return _vsp.ResetGeomScale(geom_id)
[docs] def AcceptGeomScale(geom_id): """AcceptGeomScale(std::string const & geom_id)""" return _vsp.AcceptGeomScale(geom_id)
[docs] def GetPtCloudPnts(geom_id): """GetPtCloudPnts(std::string const & geom_id) -> Vec3dVec""" return _vsp.GetPtCloudPnts(geom_id)
[docs] def CreatePtCloudGeom(geom_id): """CreatePtCloudGeom(std::string const & geom_id) -> std::string""" return _vsp.CreatePtCloudGeom(geom_id)
[docs] def CreateNGonMeshGeom(geom_id): """CreateNGonMeshGeom(std::string const & geom_id) -> std::string""" return _vsp.CreateNGonMeshGeom(geom_id)
[docs] def CreateConvexHull(geom_id): """CreateConvexHull(std::string const & geom_id) -> std::string""" return _vsp.CreateConvexHull(geom_id)
[docs] def ProjectPtCloudPts(geom_id, target_geom_id, surf_index, dir_index): """ProjectPtCloudPts(std::string const & geom_id, std::string const & target_geom_id, int surf_index, int dir_index)""" return _vsp.ProjectPtCloudPts(geom_id, target_geom_id, surf_index, dir_index)
[docs] def ShowSet(set_index): """ShowSet(int set_index)""" return _vsp.ShowSet(set_index)
[docs] def NoShowSet(set_index): """NoShowSet(int set_index)""" return _vsp.NoShowSet(set_index)
[docs] def ShowOnlySet(set_index): """ShowOnlySet(int set_index)""" return _vsp.ShowOnlySet(set_index)
[docs] def GetParmLinkID(index): """GetParmLinkID(int index) -> std::string""" return _vsp.GetParmLinkID(index)
[docs] def GetParmLinkAParm(link_id): """GetParmLinkAParm(std::string const & link_id) -> std::string""" return _vsp.GetParmLinkAParm(link_id)
[docs] def GetParmLinkBParm(link_id): """GetParmLinkBParm(std::string const & link_id) -> std::string""" return _vsp.GetParmLinkBParm(link_id)
[docs] def SetParmLinkAParm(link_id, parm_id): """SetParmLinkAParm(std::string const & link_id, std::string const & parm_id)""" return _vsp.SetParmLinkAParm(link_id, parm_id)
[docs] def SetParmLinkBParm(link_id, parm_id): """SetParmLinkBParm(std::string const & link_id, std::string const & parm_id)""" return _vsp.SetParmLinkBParm(link_id, parm_id)
[docs] def SortParmLinksByA(): """SortParmLinksByA()""" return _vsp.SortParmLinksByA()
[docs] def SortParmLinksByB(): """SortParmLinksByB()""" return _vsp.SortParmLinksByB()
[docs] def LinkAllComp(parm_a_id, parm_b_id): """LinkAllComp(std::string const & parm_a_id, std::string const & parm_b_id) -> bool""" return _vsp.LinkAllComp(parm_a_id, parm_b_id)
[docs] def LinkAllGroup(parm_a_id, parm_b_id): """LinkAllGroup(std::string const & parm_a_id, std::string const & parm_b_id) -> bool""" return _vsp.LinkAllGroup(parm_a_id, parm_b_id)
[docs] def GetParmLinkOffsetFlag(link_id): """GetParmLinkOffsetFlag(std::string const & link_id) -> bool""" return _vsp.GetParmLinkOffsetFlag(link_id)
[docs] def SetParmLinkOffsetFlag(link_id, flag): """SetParmLinkOffsetFlag(std::string const & link_id, bool flag)""" return _vsp.SetParmLinkOffsetFlag(link_id, flag)
[docs] def GetParmLinkScaleFlag(link_id): """GetParmLinkScaleFlag(std::string const & link_id) -> bool""" return _vsp.GetParmLinkScaleFlag(link_id)
[docs] def SetParmLinkScaleFlag(link_id, flag): """SetParmLinkScaleFlag(std::string const & link_id, bool flag)""" return _vsp.SetParmLinkScaleFlag(link_id, flag)
[docs] def GetParmLinkLowerLimitFlag(link_id): """GetParmLinkLowerLimitFlag(std::string const & link_id) -> bool""" return _vsp.GetParmLinkLowerLimitFlag(link_id)
[docs] def SetParmLinkLowerLimitFlag(link_id, flag): """SetParmLinkLowerLimitFlag(std::string const & link_id, bool flag)""" return _vsp.SetParmLinkLowerLimitFlag(link_id, flag)
[docs] def GetParmLinkUpperLimitFlag(link_id): """GetParmLinkUpperLimitFlag(std::string const & link_id) -> bool""" return _vsp.GetParmLinkUpperLimitFlag(link_id)
[docs] def SetParmLinkUpperLimitFlag(link_id, flag): """SetParmLinkUpperLimitFlag(std::string const & link_id, bool flag)""" return _vsp.SetParmLinkUpperLimitFlag(link_id, flag)
[docs] def GetAdvLinkNames(): """GetAdvLinkNames() -> StringVector""" return _vsp.GetAdvLinkNames()
[docs] def GetLinkIndex(name): """GetLinkIndex(std::string const & name) -> int""" return _vsp.GetLinkIndex(name)
[docs] def GetAdvLinkName(index): """GetAdvLinkName(int index) -> std::string""" return _vsp.GetAdvLinkName(index)
[docs] def SetAdvLinkName(index, name): """SetAdvLinkName(int index, std::string const & name)""" return _vsp.SetAdvLinkName(index, name)
[docs] def AddAdvLinkInput(index, parm_id, var_name): """AddAdvLinkInput(int index, std::string const & parm_id, std::string const & var_name)""" return _vsp.AddAdvLinkInput(index, parm_id, var_name)
[docs] def AddAdvLinkOutput(index, parm_id, var_name): """AddAdvLinkOutput(int index, std::string const & parm_id, std::string const & var_name)""" return _vsp.AddAdvLinkOutput(index, parm_id, var_name)
[docs] def DelAllAdvLinkInputs(index): """DelAllAdvLinkInputs(int index)""" return _vsp.DelAllAdvLinkInputs(index)
[docs] def DelAllAdvLinkOutputs(index): """DelAllAdvLinkOutputs(int index)""" return _vsp.DelAllAdvLinkOutputs(index)
[docs] def DelAdvLinkInput(index, var_name): """DelAdvLinkInput(int index, std::string const & var_name)""" return _vsp.DelAdvLinkInput(index, var_name)
[docs] def DelAdvLinkOutput(index, var_name): """DelAdvLinkOutput(int index, std::string const & var_name)""" return _vsp.DelAdvLinkOutput(index, var_name)
[docs] def GetAdvLinkInputNames(index): """GetAdvLinkInputNames(int index) -> StringVector""" return _vsp.GetAdvLinkInputNames(index)
[docs] def GetAdvLinkInputParms(index): """GetAdvLinkInputParms(int index) -> StringVector""" return _vsp.GetAdvLinkInputParms(index)
[docs] def GetAdvLinkOutputNames(index): """GetAdvLinkOutputNames(int index) -> StringVector""" return _vsp.GetAdvLinkOutputNames(index)
[docs] def GetAdvLinkOutputParms(index): """GetAdvLinkOutputParms(int index) -> StringVector""" return _vsp.GetAdvLinkOutputParms(index)
[docs] def ValidateAdvLinkParms(index): """ValidateAdvLinkParms(int index) -> bool""" return _vsp.ValidateAdvLinkParms(index)
[docs] def SetAdvLinkCode(index, code): """SetAdvLinkCode(int index, std::string const & code)""" return _vsp.SetAdvLinkCode(index, code)
[docs] def GetAdvLinkCode(index): """GetAdvLinkCode(int index) -> std::string""" return _vsp.GetAdvLinkCode(index)
[docs] def SearchReplaceAdvLinkCode(index, arg2, to): """SearchReplaceAdvLinkCode(int index, std::string const & arg2, std::string const & to)""" return _vsp.SearchReplaceAdvLinkCode(index, arg2, to)
[docs] def BuildAdvLinkScript(index): """BuildAdvLinkScript(int index) -> bool""" return _vsp.BuildAdvLinkScript(index)
[docs] def WriteAdvLinkCodeFile(index, file_name): """WriteAdvLinkCodeFile(int index, std::string const & file_name)""" return _vsp.WriteAdvLinkCodeFile(index, file_name)
[docs] def ReorderAdvLinkInput(index, var_name, reorder_type): """ReorderAdvLinkInput(int index, std::string const & var_name, int reorder_type)""" return _vsp.ReorderAdvLinkInput(index, var_name, reorder_type)
[docs] def ReorderAdvLinkOutput(index, var_name, reorder_type): """ReorderAdvLinkOutput(int index, std::string const & var_name, int reorder_type)""" return _vsp.ReorderAdvLinkOutput(index, var_name, reorder_type)
[docs] def ReadAdvLinkCodeFile(index, file_name): """ReadAdvLinkCodeFile(int index, std::string const & file_name)""" return _vsp.ReadAdvLinkCodeFile(index, file_name)
[docs] def SortAdvLinkInputsVar(index): """SortAdvLinkInputsVar(int index)""" return _vsp.SortAdvLinkInputsVar(index)
[docs] def SortAdvLinkInputsCGP(index): """SortAdvLinkInputsCGP(int index)""" return _vsp.SortAdvLinkInputsCGP(index)
[docs] def SortAdvLinkOutputsVar(index): """SortAdvLinkOutputsVar(int index)""" return _vsp.SortAdvLinkOutputsVar(index)
[docs] def SortAdvLinkOutputsCGP(index): """SortAdvLinkOutputsCGP(int index)""" return _vsp.SortAdvLinkOutputsCGP(index)
def AddVec3D(INOUT, x, y, z): """AddVec3D(Vec3dVec INOUT, double x, double y, double z)""" return _vsp.AddVec3D(INOUT, x, y, z)
[docs] class vec3d(_object): """Proxy of C++ vec3d class.""" __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, vec3d, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, vec3d, name) __swig_setmethods__["v"] = _vsp.vec3d_v_set __swig_getmethods__["v"] = _vsp.vec3d_v_get if _newclass: v = _swig_property(_vsp.vec3d_v_get, _vsp.vec3d_v_set) def __init__(self, *args): """ __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 """ this = _vsp.new_vec3d(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this
[docs] def as_vec2d_xy(self): """as_vec2d_xy(vec3d self) -> vec2d""" return _vsp.vec3d_as_vec2d_xy(self)
[docs] def set_xyz(self, xx, yy, zz): """set_xyz(vec3d self, double xx, double yy, double zz) -> vec3d""" return _vsp.vec3d_set_xyz(self, xx, yy, zz)
[docs] def set_vec(self, a): """set_vec(vec3d self, DoubleVector a) -> vec3d""" return _vsp.vec3d_set_vec(self, a)
[docs] def set_arr(self, *args): """ set_arr(vec3d self, double const [] a) -> vec3d set_arr(vec3d self, float const [] a) -> vec3d """ return _vsp.vec3d_set_arr(self, *args)
[docs] def set_x(self, xx): """set_x(vec3d self, double xx) -> vec3d""" return _vsp.vec3d_set_x(self, xx)
[docs] def set_y(self, yy): """set_y(vec3d self, double yy) -> vec3d""" return _vsp.vec3d_set_y(self, yy)
[docs] def set_z(self, zz): """set_z(vec3d self, double zz) -> vec3d""" return _vsp.vec3d_set_z(self, zz)
[docs] def set_refx(self, a): """set_refx(vec3d self, vec3d a) -> vec3d""" return _vsp.vec3d_set_refx(self, a)
[docs] def set_refy(self, a): """set_refy(vec3d self, vec3d a) -> vec3d""" return _vsp.vec3d_set_refy(self, a)
[docs] def set_refz(self, a): """set_refz(vec3d self, vec3d a) -> vec3d""" return _vsp.vec3d_set_refz(self, a)
[docs] def get_pnt(self, *args): """ get_pnt(vec3d self, double [3] pnt) get_pnt(vec3d self, float [3] pnt) get_pnt(vec3d self, threed_point_type & pnt) """ return _vsp.vec3d_get_pnt(self, *args)
[docs] def x(self): """x(vec3d self) -> double""" return _vsp.vec3d_x(self)
[docs] def y(self): """y(vec3d self) -> double""" return _vsp.vec3d_y(self)
[docs] def z(self): """z(vec3d self) -> double""" return _vsp.vec3d_z(self)
[docs] def data(self): """data(vec3d self) -> double *""" return _vsp.vec3d_data(self)
[docs] def Transform(self, m): """Transform(vec3d self, Matrix4d m)""" return _vsp.vec3d_Transform(self, m)
[docs] def FlipNormal(self): """FlipNormal(vec3d self)""" return _vsp.vec3d_FlipNormal(self)
[docs] def rotate_x(self, theta): """rotate_x(vec3d self, double theta)""" return _vsp.vec3d_rotate_x(self, theta)
[docs] def rotate_y(self, theta): """rotate_y(vec3d self, double theta)""" return _vsp.vec3d_rotate_y(self, theta)
[docs] def rotate_z(self, theta): """rotate_z(vec3d self, double theta)""" return _vsp.vec3d_rotate_z(self, theta)
[docs] def scale_x(self, scale): """scale_x(vec3d self, double scale)""" return _vsp.vec3d_scale_x(self, scale)
[docs] def scale_y(self, scale): """scale_y(vec3d self, double scale)""" return _vsp.vec3d_scale_y(self, scale)
[docs] def scale_z(self, scale): """scale_z(vec3d self, double scale)""" return _vsp.vec3d_scale_z(self, scale)
[docs] def offset_x(self, offset): """offset_x(vec3d self, double offset)""" return _vsp.vec3d_offset_x(self, offset)
[docs] def offset_y(self, offset): """offset_y(vec3d self, double offset)""" return _vsp.vec3d_offset_y(self, offset)
[docs] def offset_z(self, offset): """offset_z(vec3d self, double offset)""" return _vsp.vec3d_offset_z(self, offset)
[docs] def offset_i(self, offset, idir): """offset_i(vec3d self, double offset, int idir)""" return _vsp.vec3d_offset_i(self, offset, idir)
[docs] def reflect_xy(self): """reflect_xy(vec3d self) -> vec3d""" return _vsp.vec3d_reflect_xy(self)
[docs] def reflect_xz(self): """reflect_xz(vec3d self) -> vec3d""" return _vsp.vec3d_reflect_xz(self)
[docs] def reflect_yz(self): """reflect_yz(vec3d self) -> vec3d""" return _vsp.vec3d_reflect_yz(self)
[docs] def swap_xy(self): """swap_xy(vec3d self) -> vec3d""" return _vsp.vec3d_swap_xy(self)
[docs] def swap_xz(self): """swap_xz(vec3d self) -> vec3d""" return _vsp.vec3d_swap_xz(self)
[docs] def swap_yz(self): """swap_yz(vec3d self) -> vec3d""" return _vsp.vec3d_swap_yz(self)
def __imul__(self, b): """__imul__(vec3d self, double b) -> vec3d""" return _vsp.vec3d___imul__(self, b) def __iadd__(self, *args): """ __iadd__(vec3d self, vec3d b) -> vec3d __iadd__(vec3d self, double [] b) -> vec3d __iadd__(vec3d self, float [] b) -> vec3d """ return _vsp.vec3d___iadd__(self, *args) def __isub__(self, *args): """ __isub__(vec3d self, vec3d b) -> vec3d __isub__(vec3d self, double [] b) -> vec3d __isub__(vec3d self, float [] b) -> vec3d """ return _vsp.vec3d___isub__(self, *args)
[docs] def mag(self): """mag(vec3d self) -> double""" return _vsp.vec3d_mag(self)
[docs] def magsq(self): """magsq(vec3d self) -> double""" return _vsp.vec3d_magsq(self)
[docs] def normalize(self): """normalize(vec3d self)""" return _vsp.vec3d_normalize(self)
[docs] def major_comp(self): """major_comp(vec3d self) -> int""" return _vsp.vec3d_major_comp(self)
[docs] def minor_comp(self): """minor_comp(vec3d self) -> int""" return _vsp.vec3d_minor_comp(self)
[docs] def isnan(self): """isnan(vec3d self) -> bool""" return _vsp.vec3d_isnan(self)
[docs] def isinf(self): """isinf(vec3d self) -> bool""" return _vsp.vec3d_isinf(self)
[docs] def isfinite(self): """isfinite(vec3d self) -> bool""" return _vsp.vec3d_isfinite(self)
def _print(self, *args): """ _print(vec3d self, char const * label) _print(vec3d self) """ return _vsp.vec3d__print(self, *args)
[docs] def as_numpy(self): return _vsp.vec3d_as_numpy(self)
[docs] def __add__(self, b): """__add__(vec3d self, vec3d b) -> vec3d""" return _vsp.vec3d___add__(self, b)
[docs] def __sub__(self, b): """__sub__(vec3d self, vec3d b) -> vec3d""" return _vsp.vec3d___sub__(self, b)
[docs] def __mul__(self, *args): """ __mul__(vec3d self, double b) -> vec3d __mul__(vec3d self, vec3d b) -> vec3d """ return _vsp.vec3d___mul__(self, *args)
[docs] def __rmul__(self, b): """__rmul__(vec3d self, double b) -> vec3d""" return _vsp.vec3d___rmul__(self, b)
[docs] def __truediv__(self, b): """__truediv__(vec3d self, double b) -> vec3d""" return _vsp.vec3d___truediv__(self, b)
[docs] def __neg__(self): """__neg__(vec3d self) -> vec3d""" return _vsp.vec3d___neg__(self)
def __eq__(self, b): """__eq__(vec3d self, vec3d b) -> bool""" return _vsp.vec3d___eq__(self, b) def __ne__(self, b): """__ne__(vec3d self, vec3d b) -> bool""" return _vsp.vec3d___ne__(self, b) def _getitem(self, i): """_getitem(vec3d self, int i) -> double""" return _vsp.vec3d__getitem(self, i) def _setitem(self, i, val): """_setitem(vec3d self, int i, double val)""" return _vsp.vec3d__setitem(self, i, val)
[docs] def __len__(self): """__len__(vec3d self) -> int""" return _vsp.vec3d___len__(self)
[docs] def __getitem__( self, i ): if i < 0: i += 3 if i < 0 or i > 2: raise IndexError( "vec3d index out of range" ) return self._getitem( i )
[docs] def __setitem__( self, i, val ): if i < 0: i += 3 if i < 0 or i > 2: raise IndexError( "vec3d index out of range" ) self._setitem( i, val )
[docs] def __repr__(self): """__repr__(vec3d self) -> std::string""" return _vsp.vec3d___repr__(self)
__hash__ = object.__hash__ __swig_destroy__ = _vsp.delete_vec3d __del__ = lambda self: None
vec3d_swigregister = _vsp.vec3d_swigregister vec3d_swigregister(vec3d) cvar = _vsp.cvar cstdout = cvar.cstdout
[docs] def signed_angle(a, b, ref): """signed_angle(vec3d a, vec3d b, vec3d ref) -> double""" return _vsp.signed_angle(a, b, ref)
def radius_of_circle(p1, p2, p3): """radius_of_circle(vec3d p1, vec3d p2, vec3d p3) -> double""" return _vsp.radius_of_circle(p1, p2, p3) def center_of_circle(p1, p2, p3, center): """center_of_circle(vec3d p1, vec3d p2, vec3d p3, vec3d center)""" return _vsp.center_of_circle(p1, p2, p3, center) def triangle_plane_intersect_test(org, norm, p1, p2, p3): """triangle_plane_intersect_test(vec3d org, vec3d norm, vec3d p1, vec3d p2, vec3d p3) -> bool""" return _vsp.triangle_plane_intersect_test(org, norm, p1, p2, p3) def triangle_plane_minimum_dist(org, norm, p1, p2, p3, pa, pb): """triangle_plane_minimum_dist(vec3d org, vec3d norm, vec3d p1, vec3d p2, vec3d p3, vec3d pa, vec3d pb) -> double""" return _vsp.triangle_plane_minimum_dist(org, norm, p1, p2, p3, pa, pb) def triangle_plane_maximum_dist(org, norm, p1, p2, p3, pa, pb): """triangle_plane_maximum_dist(vec3d org, vec3d norm, vec3d p1, vec3d p2, vec3d p3, vec3d pa, vec3d pb) -> double""" return _vsp.triangle_plane_maximum_dist(org, norm, p1, p2, p3, pa, pb) def plane_plane_intersection(p0, n0, p1, n1, p, v): """plane_plane_intersection(vec3d p0, vec3d n0, vec3d p1, vec3d n1, vec3d p, vec3d v) -> bool""" return _vsp.plane_plane_intersection(p0, n0, p1, n1, p, v) def angle_pnt_2_plane(*args): """ 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.angle_pnt_2_plane(*args) def signed_dist_pnt_2_plane(org, norm, pnt): """signed_dist_pnt_2_plane(vec3d org, vec3d norm, vec3d pnt) -> double""" return _vsp.signed_dist_pnt_2_plane(org, norm, pnt) def dist_pnt_2_plane(org, norm, pnt): """dist_pnt_2_plane(vec3d org, vec3d norm, vec3d pnt) -> double""" return _vsp.dist_pnt_2_plane(org, norm, pnt) def dist_pnt_2_line(line_pt1, line_pt2, pnt): """dist_pnt_2_line(vec3d line_pt1, vec3d line_pt2, vec3d pnt) -> double""" return _vsp.dist_pnt_2_line(line_pt1, line_pt2, pnt) def dist_pnt_2_ray(line_pt1, dir_unit_vec, pnt): """dist_pnt_2_ray(vec3d line_pt1, vec3d dir_unit_vec, vec3d pnt) -> double""" return _vsp.dist_pnt_2_ray(line_pt1, dir_unit_vec, pnt) def proj_u_on_v(u, v): """proj_u_on_v(vec3d u, vec3d v) -> vec3d""" return _vsp.proj_u_on_v(u, v) def proj_pnt_on_ray(*args): """ 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.proj_pnt_on_ray(*args) def proj_pnt_on_line(line_pt1, line_pt2, pnt): """proj_pnt_on_line(vec3d line_pt1, vec3d line_pt2, vec3d pnt) -> vec3d""" return _vsp.proj_pnt_on_line(line_pt1, line_pt2, pnt) def proj_pnt_to_plane(org, plane_ln1, plane_ln2, pnt): """proj_pnt_to_plane(vec3d org, vec3d plane_ln1, vec3d plane_ln2, vec3d pnt) -> vec3d""" return _vsp.proj_pnt_to_plane(org, plane_ln1, plane_ln2, pnt) def proj_vec_to_plane(vec, norm): """proj_vec_to_plane(vec3d vec, vec3d norm) -> vec3d""" return _vsp.proj_vec_to_plane(vec, norm) def tri_seg_intersect(A, B, C, D, E, u, w, t): """tri_seg_intersect(vec3d A, vec3d B, vec3d C, vec3d D, vec3d E, double & u, double & w, double & t) -> int""" return _vsp.tri_seg_intersect(A, B, C, D, E, u, w, t) def tri_ray_intersect(A, B, C, D, E, u, w, t): """tri_ray_intersect(vec3d A, vec3d B, vec3d C, vec3d D, vec3d E, double & u, double & w, double & t) -> int""" return _vsp.tri_ray_intersect(A, B, C, D, E, u, w, t) def plane_ray_intersect(*args): """ 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.plane_ray_intersect(*args) def ray_ray_intersect(A, B, C, D, int_pnt1, int_pnt2): """ray_ray_intersect(vec3d A, vec3d B, vec3d C, vec3d D, vec3d int_pnt1, vec3d int_pnt2) -> int""" return _vsp.ray_ray_intersect(A, B, C, D, int_pnt1, int_pnt2) def tetra_volume(A, B, C): """tetra_volume(vec3d A, vec3d B, vec3d C) -> double""" return _vsp.tetra_volume(A, B, C) def area(A, B, C): """area(vec3d A, vec3d B, vec3d C) -> double""" return _vsp.area(A, B, C) def dist3D_Segment_to_Segment(*args): """ 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.dist3D_Segment_to_Segment(*args) def nearSegSeg(L0, L1, S0, S1, Lt, Ln, St, Sn): """nearSegSeg(vec3d L0, vec3d L1, vec3d S0, vec3d S1, double * Lt, vec3d Ln, double * St, vec3d Sn) -> double""" return _vsp.nearSegSeg(L0, L1, S0, S1, Lt, Ln, St, Sn) def pointLineDistSquared(p, lp0, lp1, t, pon): """pointLineDistSquared(vec3d p, vec3d lp0, vec3d lp1, double & t, vec3d pon) -> double""" return _vsp.pointLineDistSquared(p, lp0, lp1, t, pon) def pointSegDistSquared(p, sp0, sp1, t, pon): """pointSegDistSquared(vec3d p, vec3d sp0, vec3d sp1, double & t, vec3d pon) -> double""" return _vsp.pointSegDistSquared(p, sp0, sp1, t, pon) def point_on_line(lp0, lp1, t): """point_on_line(vec3d lp0, vec3d lp1, double const & t) -> vec3d""" return _vsp.point_on_line(lp0, lp1, t) def MapToPlane(p, planeOrig, planeVec1, planeVec2): """MapToPlane(vec3d p, vec3d planeOrig, vec3d planeVec1, vec3d planeVec2) -> vec2d""" return _vsp.MapToPlane(p, planeOrig, planeVec1, planeVec2) def MapFromPlane(uw, planeOrig, planeVec1, planeVec2): """MapFromPlane(vec2d uw, vec3d planeOrig, vec3d planeVec1, vec3d planeVec2) -> vec3d""" return _vsp.MapFromPlane(uw, planeOrig, planeVec1, planeVec2) def plane_half_space(planeOrig, planeNorm, pnt): """plane_half_space(vec3d planeOrig, vec3d planeNorm, vec3d pnt) -> int""" return _vsp.plane_half_space(planeOrig, planeNorm, pnt) def line_line_intersect(p1, p2, p3, p4, s, t): """line_line_intersect(vec3d p1, vec3d p2, vec3d p3, vec3d p4, double * s, double * t) -> bool""" return _vsp.line_line_intersect(p1, p2, p3, p4, s, t)
[docs] def RotateArbAxis(p, theta, r): """RotateArbAxis(vec3d p, double theta, vec3d r) -> vec3d""" return _vsp.RotateArbAxis(p, theta, r)
def PtInTri(v0, v1, v2, p): """PtInTri(vec3d v0, vec3d v1, vec3d v2, vec3d p) -> bool""" return _vsp.PtInTri(v0, v1, v2, p) def BarycentricWeights(v0, v1, v2, p): """BarycentricWeights(vec3d v0, vec3d v1, vec3d v2, vec3d p) -> vec3d""" return _vsp.BarycentricWeights(v0, v1, v2, p) def BilinearWeights(p0, p1, p, weights): """BilinearWeights(vec3d p0, vec3d p1, vec3d p, DoubleVector weights)""" return _vsp.BilinearWeights(p0, p1, p, weights) def tri_tri_min_dist(v0, v1, v2, v3, v4, v5, p1, p2): """tri_tri_min_dist(vec3d v0, vec3d v1, vec3d v2, vec3d v3, vec3d v4, vec3d v5, vec3d p1, vec3d p2) -> double""" return _vsp.tri_tri_min_dist(v0, v1, v2, v3, v4, v5, p1, p2) def pnt_tri_min_dist(v0, v1, v2, pnt, pnearest): """pnt_tri_min_dist(vec3d v0, vec3d v1, vec3d v2, vec3d pnt, vec3d pnearest) -> double""" return _vsp.pnt_tri_min_dist(v0, v1, v2, pnt, pnearest) def slerp(a, b, t): """slerp(vec3d a, vec3d b, double const & t) -> vec3d""" return _vsp.slerp(a, b, t) def printpt(v): """printpt(vec3d v)""" return _vsp.printpt(v) def ToSpherical(v): """ToSpherical(vec3d v) -> vec3d""" return _vsp.ToSpherical(v) def ToSpherical2(v, vdet): """ToSpherical2(vec3d v, vec3d vdet) -> vec3d""" return _vsp.ToSpherical2(v, vdet) def ToCartesian(v): """ToCartesian(vec3d v) -> vec3d""" return _vsp.ToCartesian(v)
[docs] def FitPlane(pts, cen, norm): """FitPlane(Vec3dVec pts, vec3d cen, vec3d norm)""" return _vsp.FitPlane(pts, cen, norm)
[docs] def to_string(v): """to_string(vec3d v) -> std::string""" return _vsp.to_string(v)
[docs] def compsum(x): """compsum(Vec3dVec x) -> vec3d""" return _vsp.compsum(x)
def raySphereIntersectionFromInside(p, v, c, r, x): """raySphereIntersectionFromInside(vec3d p, vec3d v, vec3d c, double r, vec3d x) -> bool""" return _vsp.raySphereIntersectionFromInside(p, v, c, r, x)
[docs] def dist(*args): """ dist(vec3d a, vec3d b) -> double dist(vec2d a, vec2d b) -> double """ return _vsp.dist(*args)
[docs] def dist_squared(*args): """ dist_squared(vec3d a, vec3d b) -> double dist_squared(vec2d a, vec2d b) -> double """ return _vsp.dist_squared(*args)
[docs] def cross(*args): """ cross(vec3d a, vec3d b) -> vec3d cross(vec2d a, vec2d b) -> double """ return _vsp.cross(*args)
[docs] def dot(*args): """ dot(vec3d a, vec3d b) -> double dot(vec2d a, vec2d b) -> double """ return _vsp.dot(*args)
[docs] def angle(*args): """ angle(vec3d a, vec3d b) -> double angle(vec2d a, vec2d b) -> double """ return _vsp.angle(*args)
[docs] def cos_angle(*args): """ cos_angle(vec3d a, vec3d b) -> double cos_angle(vec2d a, vec2d b) -> double """ return _vsp.cos_angle(*args)
[docs] def seg_seg_intersect(pnt_A, pnt_B, pnt_C, pnt_D): """seg_seg_intersect(vec2d pnt_A, vec2d pnt_B, vec2d pnt_C, vec2d pnt_D) -> int""" return _vsp.seg_seg_intersect(pnt_A, pnt_B, pnt_C, pnt_D)
[docs] def proj_pnt_on_line_seg(*args): """ 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.proj_pnt_on_line_seg(*args)
[docs] def proj_pnt_on_line_u(line_A, line_B, pnt): """proj_pnt_on_line_u(vec2d line_A, vec2d line_B, vec2d pnt) -> double""" return _vsp.proj_pnt_on_line_u(line_A, line_B, pnt)
[docs] def PointInPolygon(R, pnts): """PointInPolygon(vec2d R, Vec2dVec pnts) -> bool""" return _vsp.PointInPolygon(R, pnts)
[docs] def det(p0, p1, offset): """det(vec2d p0, vec2d p1, vec2d offset) -> double""" return _vsp.det(p0, p1, offset)
[docs] def poly_area(*args): """ poly_area(Vec3dVec pnt_vec) -> double poly_area(Vec2dVec pnt_vec) -> double """ return _vsp.poly_area(*args)
[docs] def poly_centroid(pnt_vec): """poly_centroid(Vec2dVec pnt_vec) -> vec2d""" return _vsp.poly_centroid(pnt_vec)
[docs] def orient2d(p0, p1, p): """orient2d(vec2d p0, vec2d p1, vec2d p) -> double""" return _vsp.orient2d(p0, p1, p)
[docs] def bi_lin_interp(p0, p1, p2, p3, s, t): """bi_lin_interp(vec2d p0, vec2d p1, vec2d p2, vec2d p3, double s, double t)""" return _vsp.bi_lin_interp(p0, p1, p2, p3, s, t)
[docs] def inverse_bi_lin_interp(p0, p1, p2, p3, p): """inverse_bi_lin_interp(vec2d p0, vec2d p1, vec2d p2, vec2d p3, vec2d p) -> int""" return _vsp.inverse_bi_lin_interp(p0, p1, p2, p3, p)
[docs] class vec2d(_object): """Proxy of C++ vec2d class.""" __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, vec2d, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, vec2d, name) __swig_setmethods__["v"] = _vsp.vec2d_v_set __swig_getmethods__["v"] = _vsp.vec2d_v_get if _newclass: v = _swig_property(_vsp.vec2d_v_get, _vsp.vec2d_v_set) def __init__(self, *args): """ __init__(vec2d self) -> vec2d __init__(vec2d self, vec2d a) -> vec2d __init__(vec2d self, double xx, double yy) -> vec2d """ this = _vsp.new_vec2d(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this
[docs] def set_xy(self, xx, yy): """set_xy(vec2d self, double xx, double yy) -> vec2d""" return _vsp.vec2d_set_xy(self, xx, yy)
[docs] def set_x(self, xx): """set_x(vec2d self, double xx) -> vec2d""" return _vsp.vec2d_set_x(self, xx)
[docs] def set_y(self, yy): """set_y(vec2d self, double yy) -> vec2d""" return _vsp.vec2d_set_y(self, yy)
[docs] def x(self): """x(vec2d self) -> double""" return _vsp.vec2d_x(self)
[docs] def y(self): """y(vec2d self) -> double""" return _vsp.vec2d_y(self)
def __iadd__(self, b): """__iadd__(vec2d self, vec2d b) -> vec2d""" return _vsp.vec2d___iadd__(self, b) def __isub__(self, b): """__isub__(vec2d self, vec2d b) -> vec2d""" return _vsp.vec2d___isub__(self, b) def __imul__(self, b): """__imul__(vec2d self, double b) -> vec2d""" return _vsp.vec2d___imul__(self, b)
[docs] def mag(self): """mag(vec2d self) -> double""" return _vsp.vec2d_mag(self)
[docs] def normalize(self): """normalize(vec2d self)""" return _vsp.vec2d_normalize(self)
[docs] def __add__(self, b): """__add__(vec2d self, vec2d b) -> vec2d""" return _vsp.vec2d___add__(self, b)
[docs] def __sub__(self, b): """__sub__(vec2d self, vec2d b) -> vec2d""" return _vsp.vec2d___sub__(self, b)
[docs] def __mul__(self, *args): """ __mul__(vec2d self, double b) -> vec2d __mul__(vec2d self, vec2d b) -> vec2d """ return _vsp.vec2d___mul__(self, *args)
[docs] def __rmul__(self, b): """__rmul__(vec2d self, double b) -> vec2d""" return _vsp.vec2d___rmul__(self, b)
[docs] def __truediv__(self, b): """__truediv__(vec2d self, double b) -> vec2d""" return _vsp.vec2d___truediv__(self, b)
def _getitem(self, i): """_getitem(vec2d self, int i) -> double""" return _vsp.vec2d__getitem(self, i) def _setitem(self, i, val): """_setitem(vec2d self, int i, double val)""" return _vsp.vec2d__setitem(self, i, val)
[docs] def __len__(self): """__len__(vec2d self) -> int""" return _vsp.vec2d___len__(self)
[docs] def __getitem__( self, i ): if i < 0: i += 2 if i < 0 or i > 1: raise IndexError( "vec2d index out of range" ) return self._getitem( i )
[docs] def __setitem__( self, i, val ): if i < 0: i += 2 if i < 0 or i > 1: raise IndexError( "vec2d index out of range" ) self._setitem( i, val )
[docs] def __repr__(self): """__repr__(vec2d self) -> std::string""" return _vsp.vec2d___repr__(self)
__swig_destroy__ = _vsp.delete_vec2d __del__ = lambda self: None
vec2d_swigregister = _vsp.vec2d_swigregister vec2d_swigregister(vec2d)
[docs] class Matrix4d(_object): """Proxy of C++ Matrix4d class.""" __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, Matrix4d, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, Matrix4d, name) __repr__ = _swig_repr def __init__(self): """__init__(Matrix4d self) -> Matrix4d""" this = _vsp.new_Matrix4d() try: self.this.append(this) except __builtin__.Exception: self.this = this
[docs] def loadIdentity(self): """loadIdentity(Matrix4d self)""" return _vsp.Matrix4d_loadIdentity(self)
def _print(self, *args): """ _print(Matrix4d self, std::string const & header) _print(Matrix4d self) """ return _vsp.Matrix4d__print(self, *args)
[docs] def setIdentity(m): """setIdentity(double * m)""" return _vsp.Matrix4d_setIdentity(m)
setIdentity = staticmethod(setIdentity)
[docs] def translatef(self, x, y, z): """translatef(Matrix4d self, double const & x, double const & y, double const & z)""" return _vsp.Matrix4d_translatef(self, x, y, z)
[docs] def translatev(self, v): """translatev(Matrix4d self, vec3d v)""" return _vsp.Matrix4d_translatev(self, v)
[docs] def rotateX(self, ang): """rotateX(Matrix4d self, double const & ang)""" return _vsp.Matrix4d_rotateX(self, ang)
[docs] def rotateY(self, ang): """rotateY(Matrix4d self, double const & ang)""" return _vsp.Matrix4d_rotateY(self, ang)
[docs] def rotateZ(self, ang): """rotateZ(Matrix4d self, double const & ang)""" return _vsp.Matrix4d_rotateZ(self, ang)
[docs] def rotate(self, angle, axis): """rotate(Matrix4d self, double const & angle, vec3d axis)""" return _vsp.Matrix4d_rotate(self, angle, axis)
[docs] def rotatealongX(self, dir1): """rotatealongX(Matrix4d self, vec3d dir1)""" return _vsp.Matrix4d_rotatealongX(self, dir1)
[docs] def zeroTranslations(self): """zeroTranslations(Matrix4d self)""" return _vsp.Matrix4d_zeroTranslations(self)
[docs] def affineInverse(self): """affineInverse(Matrix4d self)""" return _vsp.Matrix4d_affineInverse(self)
[docs] def scale(self, scale): """scale(Matrix4d self, double const & scale)""" return _vsp.Matrix4d_scale(self, scale)
[docs] def scalex(self, scalex): """scalex(Matrix4d self, double const & scalex)""" return _vsp.Matrix4d_scalex(self, scalex)
[docs] def scaley(self, scaley): """scaley(Matrix4d self, double const & scaley)""" return _vsp.Matrix4d_scaley(self, scaley)
[docs] def scalez(self, scalez): """scalez(Matrix4d self, double const & scalez)""" return _vsp.Matrix4d_scalez(self, scalez)
[docs] def flipx(self): """flipx(Matrix4d self)""" return _vsp.Matrix4d_flipx(self)
[docs] def getMat(self, m): """getMat(Matrix4d self, double * m)""" return _vsp.Matrix4d_getMat(self, m)
[docs] def matMult(self, *args): """ matMult(Matrix4d self, double const * m) matMult(Matrix4d self, Matrix4d m) """ return _vsp.Matrix4d_matMult(self, *args)
[docs] def postMult(self, *args): """ postMult(Matrix4d self, double const * m) postMult(Matrix4d self, Matrix4d m) """ return _vsp.Matrix4d_postMult(self, *args)
[docs] def initMat(self, *args): """ initMat(Matrix4d self, double const * m) initMat(Matrix4d self, Matrix4d m) """ return _vsp.Matrix4d_initMat(self, *args)
[docs] def mult(self, arg2, out): """mult(Matrix4d self, double const [4] arg2, double [4] out)""" return _vsp.Matrix4d_mult(self, arg2, out)
[docs] def data(self): """data(Matrix4d self) -> double *""" return _vsp.Matrix4d_data(self)
[docs] def const_data(self): """const_data(Matrix4d self) -> double const *""" return _vsp.Matrix4d_const_data(self)
[docs] def loadXZRef(self): """loadXZRef(Matrix4d self)""" return _vsp.Matrix4d_loadXZRef(self)
[docs] def loadXYRef(self): """loadXYRef(Matrix4d self)""" return _vsp.Matrix4d_loadXYRef(self)
[docs] def loadYZRef(self): """loadYZRef(Matrix4d self)""" return _vsp.Matrix4d_loadYZRef(self)
[docs] def mirrory(self): """mirrory(Matrix4d self)""" return _vsp.Matrix4d_mirrory(self)
[docs] def xform(self, arg2): """xform(Matrix4d self, vec3d arg2) -> vec3d""" return _vsp.Matrix4d_xform(self, arg2)
[docs] def xformvec(self, arg2): """xformvec(Matrix4d self, Vec3dVec arg2)""" return _vsp.Matrix4d_xformvec(self, arg2)
[docs] def xformmat(self, arg2): """xformmat(Matrix4d self, Vec3dVecVec arg2)""" return _vsp.Matrix4d_xformmat(self, arg2)
[docs] def xformnorm(self, arg2): """xformnorm(Matrix4d self, vec3d arg2) -> vec3d""" return _vsp.Matrix4d_xformnorm(self, arg2)
[docs] def xformnormvec(self, arg2): """xformnormvec(Matrix4d self, Vec3dVec arg2)""" return _vsp.Matrix4d_xformnormvec(self, arg2)
[docs] def xformnormmat(self, arg2): """xformnormmat(Matrix4d self, Vec3dVecVec arg2)""" return _vsp.Matrix4d_xformnormmat(self, arg2)
[docs] def getAngles(self): """getAngles(Matrix4d self) -> vec3d""" return _vsp.Matrix4d_getAngles(self)
[docs] def getArcballAngles(self): """getArcballAngles(Matrix4d self) -> vec3d""" return _vsp.Matrix4d_getArcballAngles(self)
[docs] def getTranslation(self): """getTranslation(Matrix4d self) -> vec3d""" return _vsp.Matrix4d_getTranslation(self)
[docs] def buildXForm(self, pos, rot, cent_rot): """buildXForm(Matrix4d self, vec3d pos, vec3d rot, vec3d cent_rot)""" return _vsp.Matrix4d_buildXForm(self, pos, rot, cent_rot)
[docs] def getBasis(self, xdir, ydir, zdir): """getBasis(Matrix4d self, vec3d xdir, vec3d ydir, vec3d zdir)""" return _vsp.Matrix4d_getBasis(self, xdir, ydir, zdir)
[docs] def setBasis(self, xdir, ydir, zdir): """setBasis(Matrix4d self, vec3d xdir, vec3d ydir, vec3d zdir)""" return _vsp.Matrix4d_setBasis(self, xdir, ydir, zdir)
[docs] def getRotationAxis(self, axis_dir, axis_pnt): """getRotationAxis(Matrix4d self, vec3d axis_dir, vec3d axis_pnt)""" return _vsp.Matrix4d_getRotationAxis(self, axis_dir, axis_pnt)
[docs] def toQuat(self): """toQuat(Matrix4d self)""" return _vsp.Matrix4d_toQuat(self)
__swig_destroy__ = _vsp.delete_Matrix4d __del__ = lambda self: None
Matrix4d_swigregister = _vsp.Matrix4d_swigregister Matrix4d_swigregister(Matrix4d) def Matrix4d_setIdentity(m): """Matrix4d_setIdentity(double * m)""" return _vsp.Matrix4d_setIdentity(m) # This file is compatible with both classic and new-style classes. # **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