
# Facade Code
# **********************************************************************************
import os
import sys
import socket
from time import sleep
import subprocess
import pickle
from openvsp.facade_server import pack_data, unpack_data
from traceback import format_exception
import openvsp_config
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _vsp
else:
    import _vsp
# decorator for wrapping every function
def client_wrap(func):
    def wrapper(self, *args, **kwargs):
        return self._send_recieve(func.__name__, args, kwargs)
    return wrapper
def _exception_hook(exc_type, exc_value, tb):
    regular_traceback = []
    facade_traceback = []
    for line in exc_value.args[0].split("\n")[:3]:
        facade_traceback.append(line)

    for line in format_exception(exc_type, exc_value, tb)[:-1]:
        if "facade.py" in line or "facade_server.py" in line:
            facade_traceback.append(line.strip("\n"))
        else:
            regular_traceback.append(line.strip("\n"))
    for line in exc_value.args[0].split("\n")[3:]:
        regular_traceback.append(line)

    print("This error occurred while using the facade API")
    print("Facade Traceback:")
    for line in facade_traceback:
        print(line)
    print("")
    print("Regular Traceback:")
    for line in regular_traceback:
        print(line)

class _vsp_server():
    def __init__(self, name):
        self.server_name = name
        sock = socket.socket()
        sock.bind(('', 0))
        HOST = 'localhost'
        PORT = sock.getsockname()[1]
        sock.close()

        python_exe = None
        if "python" in sys.executable:
            python_exe = sys.executable
        elif "python" in os.__file__:
            python_exe = os.__file__
        else:
            python_exe = "python"

        server_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'facade_server.py')
        proc = subprocess.Popen([python_exe, server_file, str(PORT), str(openvsp_config.LOAD_GRAPHICS)])

        sleep(1)

        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.connect((HOST, PORT))
        self.ABS = _vsp.ABS
        r""" Absolute position"""
        self.REL = _vsp.REL
        r""" Relative position"""
        self.SELIG_AF_EXPORT = _vsp.SELIG_AF_EXPORT
        r""" Selig airfoil file format"""
        self.BEZIER_AF_EXPORT = _vsp.BEZIER_AF_EXPORT
        r""" Bezier airfoil file format"""
        self.ALIGN_LEFT = _vsp.ALIGN_LEFT
        r""" Align to left"""
        self.ALIGN_CENTER = _vsp.ALIGN_CENTER
        r""" Align to center"""
        self.ALIGN_RIGHT = _vsp.ALIGN_RIGHT
        r""" Align to right"""
        self.ALIGN_PIXEL = _vsp.ALIGN_PIXEL
        r""" Align to specified pixel"""
        self.ALIGN_TOP = _vsp.ALIGN_TOP
        r""" Align to top"""
        self.ALIGN_MIDDLE = _vsp.ALIGN_MIDDLE
        r""" Align to middle"""
        self.ALIGN_BOTTOM = _vsp.ALIGN_BOTTOM
        r""" Align to bottom"""
        self.NUM_ALIGN_TYPE = _vsp.NUM_ALIGN_TYPE
        r""" Number of alignment types"""
        self.ANG_RAD = _vsp.ANG_RAD
        r""" Radians"""
        self.ANG_DEG = _vsp.ANG_DEG
        r""" Degrees"""
        self.ANG_0 = _vsp.ANG_0
        r""" Zero deg"""
        self.ANG_90 = _vsp.ANG_90
        r""" 90 deg"""
        self.ANG_180 = _vsp.ANG_180
        r""" 180 deg"""
        self.ANG_270 = _vsp.ANG_270
        r""" 270 deg"""
        self.NUM_ANG = _vsp.NUM_ANG
        r""" Number of angle choices"""
        self.ATMOS_TYPE_US_STANDARD_1976 = _vsp.ATMOS_TYPE_US_STANDARD_1976
        r""" US Standard Atmosphere 1976 (default)"""
        self.ATMOS_TYPE_HERRINGTON_1966 = _vsp.ATMOS_TYPE_HERRINGTON_1966
        r""" USAF 1966"""
        self.ATMOS_TYPE_MANUAL_P_R = _vsp.ATMOS_TYPE_MANUAL_P_R
        r""" Manual: pressure and density control"""
        self.ATMOS_TYPE_MANUAL_P_T = _vsp.ATMOS_TYPE_MANUAL_P_T
        r""" Manual: pressure and temperature control"""
        self.ATMOS_TYPE_MANUAL_R_T = _vsp.ATMOS_TYPE_MANUAL_R_T
        r""" Manual: density and temperature control"""
        self.ATMOS_TYPE_MANUAL_RE_L = _vsp.ATMOS_TYPE_MANUAL_RE_L
        r""" Manual: Reynolds number and length control"""
        self.ATTACH_TRANS_NONE = _vsp.ATTACH_TRANS_NONE
        r""" No parent attachment for translations"""
        self.ATTACH_TRANS_COMP = _vsp.ATTACH_TRANS_COMP
        r""" Translation relative to parent body axes"""
        self.ATTACH_TRANS_UV = _vsp.ATTACH_TRANS_UV
        r""" Translation relative to parent surface coordinate frame"""
        self.ATTACH_TRANS_RST = _vsp.ATTACH_TRANS_RST
        r""" Translation relative to parent per-section volume coordinate frame"""
        self.ATTACH_TRANS_LMN = _vsp.ATTACH_TRANS_LMN
        r""" Translation relative to parent uniform volume coordinate frame"""
        self.ATTACH_TRANS_EtaMN = _vsp.ATTACH_TRANS_EtaMN
        r""" Translation relative to wing parent uniform eta volume coordinate frame"""
        self.ATTACH_TRANS_NUM_TYPES = _vsp.ATTACH_TRANS_NUM_TYPES
        r""" Number of translation attachment types"""
        self.ATTACH_ROT_NONE = _vsp.ATTACH_ROT_NONE
        r""" No parent attachment for rotations"""
        self.ATTACH_ROT_COMP = _vsp.ATTACH_ROT_COMP
        r""" Rotation relative to parent body axes"""
        self.ATTACH_ROT_UV = _vsp.ATTACH_ROT_UV
        r""" Rotation relative to parent surface coordinate frame"""
        self.ATTACH_ROT_RST = _vsp.ATTACH_ROT_RST
        r""" Rotation relative to parent per-section volume coordinate frame"""
        self.ATTACH_ROT_LMN = _vsp.ATTACH_ROT_LMN
        r""" Rotation relative to parent uniform volume coordinate frame"""
        self.ATTACH_ROT_EtaMN = _vsp.ATTACH_ROT_EtaMN
        r""" Rotation relative to wing parent eta volume coordinate frame"""
        self.ATTACH_ROT_NUM_TYPES = _vsp.ATTACH_ROT_NUM_TYPES
        r""" Number of rotation attachment types"""
        self.ATTROBJ_PARM = _vsp.ATTROBJ_PARM
        r""" Parm"""
        self.ATTROBJ_GEOM = _vsp.ATTROBJ_GEOM
        r""" Geom"""
        self.ATTROBJ_VEH = _vsp.ATTROBJ_VEH
        r""" Vehicle"""
        self.ATTROBJ_SUBSURF = _vsp.ATTROBJ_SUBSURF
        r""" SubSurf"""
        self.ATTROBJ_MEASURE = _vsp.ATTROBJ_MEASURE
        r""" Measure"""
        self.ATTROBJ_LINK = _vsp.ATTROBJ_LINK
        r""" Link"""
        self.ATTROBJ_ADVLINK = _vsp.ATTROBJ_ADVLINK
        r""" Adv Link"""
        self.ATTROBJ_ATTR = _vsp.ATTROBJ_ATTR
        r""" Attribute"""
        self.ATTROBJ_COLLECTION = _vsp.ATTROBJ_COLLECTION
        r""" Attribute Collection"""
        self.ATTROBJ_XSEC = _vsp.ATTROBJ_XSEC
        r""" Cross Section"""
        self.ATTROBJ_SEC = _vsp.ATTROBJ_SEC
        r""" Wing Section"""
        self.ATTROBJ_MODE = _vsp.ATTROBJ_MODE
        r""" Mode"""
        self.ATTROBJ_SET = _vsp.ATTROBJ_SET
        r""" Geom Set"""
        self.ATTROBJ_VARGROUP = _vsp.ATTROBJ_VARGROUP
        r""" Var Preset Group"""
        self.ATTROBJ_VARSETTING = _vsp.ATTROBJ_VARSETTING
        r""" Var Preset Setting"""
        self.ATTROBJ_FREE = _vsp.ATTROBJ_FREE
        r""" Unattached attribute"""
        self.ATTR_GROUP_NONE = _vsp.ATTR_GROUP_NONE
        r""" No event (user attributes)"""
        self.ATTR_GROUP_WATERMARK = _vsp.ATTR_GROUP_WATERMARK
        r""" Watermark group"""
        self.NUM_ATTR_EVENT_GROUPS = _vsp.NUM_ATTR_EVENT_GROUPS
        r""" Number attribute event groups"""
        self.BOR_FLOWTHROUGH = _vsp.BOR_FLOWTHROUGH
        r""" Flowthrough mode (default)"""
        self.BOR_UPPER = _vsp.BOR_UPPER
        r""" Upper surface mode"""
        self.BOR_LOWER = _vsp.BOR_LOWER
        r""" Lower surface mode"""
        self.BOR_NUM_MODES = _vsp.BOR_NUM_MODES
        r""" Number of Body of Revolution modes"""
        self.MAX_CAMB = _vsp.MAX_CAMB
        r""" Input maximum camber, calculate ideal lift coefficient"""
        self.DESIGN_CL = _vsp.DESIGN_CL
        r""" Input ideal lift coefficient, calculate maximum camber"""
        self.CAM_TOP = _vsp.CAM_TOP
        r""" Camera top view"""
        self.CAM_FRONT = _vsp.CAM_FRONT
        r""" Camera front view"""
        self.CAM_FRONT_YUP = _vsp.CAM_FRONT_YUP
        r""" Camera front Y-up view"""
        self.CAM_LEFT = _vsp.CAM_LEFT
        r""" Camera left view"""
        self.CAM_LEFT_ISO = _vsp.CAM_LEFT_ISO
        r""" Camera left isometric view"""
        self.CAM_BOTTOM = _vsp.CAM_BOTTOM
        r""" Camera bottom view"""
        self.CAM_REAR = _vsp.CAM_REAR
        r""" Camera rear view"""
        self.CAM_RIGHT = _vsp.CAM_RIGHT
        r""" Camera right view"""
        self.CAM_RIGHT_ISO = _vsp.CAM_RIGHT_ISO
        r""" Camera right isometric view"""
        self.CAM_CENTER = _vsp.CAM_CENTER
        r""" Camera center view"""
        self.NO_END_CAP = _vsp.NO_END_CAP
        r""" No end cap"""
        self.FLAT_END_CAP = _vsp.FLAT_END_CAP
        r""" Flat end cap"""
        self.ROUND_END_CAP = _vsp.ROUND_END_CAP
        r""" Round end cap"""
        self.EDGE_END_CAP = _vsp.EDGE_END_CAP
        r""" Edge end cap"""
        self.SHARP_END_CAP = _vsp.SHARP_END_CAP
        r""" Sharp end cap"""
        self.POINT_END_CAP = _vsp.POINT_END_CAP
        r""" Point end cap"""
        self.ROUND_EXT_END_CAP_NONE = _vsp.ROUND_EXT_END_CAP_NONE
        r""" Extended round end cap, but not extended"""
        self.ROUND_EXT_END_CAP_LE = _vsp.ROUND_EXT_END_CAP_LE
        r""" Extended round end cap, extend LE"""
        self.ROUND_EXT_END_CAP_TE = _vsp.ROUND_EXT_END_CAP_TE
        r""" Extended round end cap, extend TE"""
        self.ROUND_EXT_END_CAP_BOTH = _vsp.ROUND_EXT_END_CAP_BOTH
        r""" Extended round end cap, extend both"""
        self.NUM_END_CAP_OPTIONS = _vsp.NUM_END_CAP_OPTIONS
        r""" Number of end cap options"""
        self.CFD_MIN_EDGE_LEN = _vsp.CFD_MIN_EDGE_LEN
        r""" Minimum mesh edge length"""
        self.CFD_MAX_EDGE_LEN = _vsp.CFD_MAX_EDGE_LEN
        r""" Maximum mesh edge length"""
        self.CFD_MAX_GAP = _vsp.CFD_MAX_GAP
        r""" Maximum mesh edge gap"""
        self.CFD_NUM_CIRCLE_SEGS = _vsp.CFD_NUM_CIRCLE_SEGS
        r""" Number of edge segments to resolve circle"""
        self.CFD_GROWTH_RATIO = _vsp.CFD_GROWTH_RATIO
        r""" Maximum allowed edge growth ratio"""
        self.CFD_LIMIT_GROWTH_FLAG = _vsp.CFD_LIMIT_GROWTH_FLAG
        r""" Rigorous 3D growth limiting flag"""
        self.CFD_INTERSECT_SUBSURFACE_FLAG = _vsp.CFD_INTERSECT_SUBSURFACE_FLAG
        r""" Flag to intersect sub-surfaces"""
        self.CFD_HALF_MESH_FLAG = _vsp.CFD_HALF_MESH_FLAG
        r""" Flag to generate a half mesh"""
        self.CFD_FAR_FIELD_FLAG = _vsp.CFD_FAR_FIELD_FLAG
        r""" Flag to generate a far field mesh"""
        self.CFD_FAR_MAX_EDGE_LEN = _vsp.CFD_FAR_MAX_EDGE_LEN
        r""" Maximum far field mesh edge length"""
        self.CFD_FAR_MAX_GAP = _vsp.CFD_FAR_MAX_GAP
        r""" Maximum far field mesh edge gap"""
        self.CFD_FAR_NUM_CIRCLE_SEGS = _vsp.CFD_FAR_NUM_CIRCLE_SEGS
        r""" Number of far field edge segments to resolve circle"""
        self.CFD_FAR_SIZE_ABS_FLAG = _vsp.CFD_FAR_SIZE_ABS_FLAG
        r""" Relative or absolute size flag"""
        self.CFD_FAR_LENGTH = _vsp.CFD_FAR_LENGTH
        r""" Far field length"""
        self.CFD_FAR_WIDTH = _vsp.CFD_FAR_WIDTH
        r""" Far field width"""
        self.CFD_FAR_HEIGHT = _vsp.CFD_FAR_HEIGHT
        r""" Far field height"""
        self.CFD_FAR_X_SCALE = _vsp.CFD_FAR_X_SCALE
        r"""  Far field X scale"""
        self.CFD_FAR_Y_SCALE = _vsp.CFD_FAR_Y_SCALE
        r"""  Far field Y scale"""
        self.CFD_FAR_Z_SCALE = _vsp.CFD_FAR_Z_SCALE
        r"""  Far field Z scale"""
        self.CFD_FAR_LOC_MAN_FLAG = _vsp.CFD_FAR_LOC_MAN_FLAG
        r""" Far field location flag: centered or manual"""
        self.CFD_FAR_LOC_X = _vsp.CFD_FAR_LOC_X
        r""" Far field X location"""
        self.CFD_FAR_LOC_Y = _vsp.CFD_FAR_LOC_Y
        r""" Far field Y location"""
        self.CFD_FAR_LOC_Z = _vsp.CFD_FAR_LOC_Z
        r""" Far field Z location"""
        self.CFD_SRF_XYZ_FLAG = _vsp.CFD_SRF_XYZ_FLAG
        r""" Flag to include X,Y,Z intersection curves in export files"""
        self.CFD_STL_FILE_NAME = _vsp.CFD_STL_FILE_NAME
        r""" STL export type"""
        self.CFD_POLY_FILE_NAME = _vsp.CFD_POLY_FILE_NAME
        r""" POLY export type"""
        self.CFD_TRI_FILE_NAME = _vsp.CFD_TRI_FILE_NAME
        r""" TRI export type"""
        self.CFD_OBJ_FILE_NAME = _vsp.CFD_OBJ_FILE_NAME
        r""" OBJ export type"""
        self.CFD_DAT_FILE_NAME = _vsp.CFD_DAT_FILE_NAME
        r""" DAT export type"""
        self.CFD_KEY_FILE_NAME = _vsp.CFD_KEY_FILE_NAME
        r""" KEY export type"""
        self.CFD_GMSH_FILE_NAME = _vsp.CFD_GMSH_FILE_NAME
        r""" GMSH export type"""
        self.CFD_TKEY_FILE_NAME = _vsp.CFD_TKEY_FILE_NAME
        r""" TKEY export type"""
        self.CFD_FACET_FILE_NAME = _vsp.CFD_FACET_FILE_NAME
        r""" FACET export type"""
        self.CFD_VSPGEOM_FILE_NAME = _vsp.CFD_VSPGEOM_FILE_NAME
        r""" VSPGEOM export type"""
        self.CFD_NUM_FILE_NAMES = _vsp.CFD_NUM_FILE_NAMES
        r""" Number of CFD Mesh export file types"""
        self.POINT_SOURCE = _vsp.POINT_SOURCE
        r""" Point source"""
        self.LINE_SOURCE = _vsp.LINE_SOURCE
        r""" Line source"""
        self.BOX_SOURCE = _vsp.BOX_SOURCE
        r""" Box source"""
        self.ULINE_SOURCE = _vsp.ULINE_SOURCE
        r""" Constant U Line source"""
        self.WLINE_SOURCE = _vsp.WLINE_SOURCE
        r""" Constant W Line source"""
        self.NUM_SOURCE_TYPES = _vsp.NUM_SOURCE_TYPES
        r""" Number of CFD Mesh source types"""
        self.TAG = _vsp.TAG
        r""" Color mesh by tag value (component, subsurface, part, etc)"""
        self.REASON = _vsp.REASON
        r""" Color mesh by local edge length reason"""
        self.CF_LAM_BLASIUS = _vsp.CF_LAM_BLASIUS
        r""" Blasius laminar Cf equation"""
        self.CF_LAM_BLASIUS_W_HEAT = _vsp.CF_LAM_BLASIUS_W_HEAT
        r""" Blasius laminar Cf equation with heat (NOT IMPLEMENTED)"""
        self.CF_TURB_EXPLICIT_FIT_SPALDING = _vsp.CF_TURB_EXPLICIT_FIT_SPALDING
        r""" Explicit Fit of Spalding turbulent Cf equation"""
        self.CF_TURB_EXPLICIT_FIT_SPALDING_CHI = _vsp.CF_TURB_EXPLICIT_FIT_SPALDING_CHI
        r""" Explicit Fit of Spalding and Chi turbulent Cf equation"""
        self.CF_TURB_EXPLICIT_FIT_SCHOENHERR = _vsp.CF_TURB_EXPLICIT_FIT_SCHOENHERR
        r""" Explicit Fit of Schoenherr turbulent Cf equation"""
        self.DO_NOT_USE_CF_TURB_IMPLICIT_KARMAN = _vsp.DO_NOT_USE_CF_TURB_IMPLICIT_KARMAN
        r""" Implicit Karman turbulent Cf equation (DO NOT USE)"""
        self.CF_TURB_IMPLICIT_SCHOENHERR = _vsp.CF_TURB_IMPLICIT_SCHOENHERR
        r""" Implicit Schoenherr turbulent Cf equation"""
        self.CF_TURB_IMPLICIT_KARMAN_SCHOENHERR = _vsp.CF_TURB_IMPLICIT_KARMAN_SCHOENHERR
        r""" Implicit Karman-Schoenherr turbulent Cf equation"""
        self.CF_TURB_POWER_LAW_BLASIUS = _vsp.CF_TURB_POWER_LAW_BLASIUS
        r""" Power Law Blasius turbulent Cf equation"""
        self.CF_TURB_POWER_LAW_PRANDTL_LOW_RE = _vsp.CF_TURB_POWER_LAW_PRANDTL_LOW_RE
        r"""Power Law Prandtl Low Re turbulent Cf equation"""
        self.CF_TURB_POWER_LAW_PRANDTL_MEDIUM_RE = _vsp.CF_TURB_POWER_LAW_PRANDTL_MEDIUM_RE
        r""" Power Law Prandtl Medium Re turbulent Cf equation"""
        self.CF_TURB_POWER_LAW_PRANDTL_HIGH_RE = _vsp.CF_TURB_POWER_LAW_PRANDTL_HIGH_RE
        r""" Power Law Prandtl High Re turbulent Cf equation"""
        self.CF_TURB_SCHLICHTING_COMPRESSIBLE = _vsp.CF_TURB_SCHLICHTING_COMPRESSIBLE
        r""" Schlichting Compressible turbulent Cf equation"""
        self.DO_NOT_USE_CF_TURB_SCHLICHTING_INCOMPRESSIBLE = _vsp.DO_NOT_USE_CF_TURB_SCHLICHTING_INCOMPRESSIBLE
        r""" Schlichting Incompressible turbulent Cf equation (DO NOT USE)"""
        self.DO_NOT_USE_CF_TURB_SCHLICHTING_PRANDTL = _vsp.DO_NOT_USE_CF_TURB_SCHLICHTING_PRANDTL
        r""" Schlichting-Prandtl turbulent Cf equation (DO NOT USE)"""
        self.DO_NOT_USE_CF_TURB_SCHULTZ_GRUNOW_HIGH_RE = _vsp.DO_NOT_USE_CF_TURB_SCHULTZ_GRUNOW_HIGH_RE
        r""" Schultz-Grunow High Re turbulent Cf equation (DO NOT USE)"""
        self.CF_TURB_SCHULTZ_GRUNOW_SCHOENHERR = _vsp.CF_TURB_SCHULTZ_GRUNOW_SCHOENHERR
        r""" Schultz-Grunow Estimate of Schoenherr turbulent Cf equation."""
        self.DO_NOT_USE_CF_TURB_WHITE_CHRISTOPH_COMPRESSIBLE = _vsp.DO_NOT_USE_CF_TURB_WHITE_CHRISTOPH_COMPRESSIBLE
        r""" White-Christoph Compressible turbulent Cf equation (DO NOT USE)"""
        self.CF_TURB_ROUGHNESS_SCHLICHTING_AVG = _vsp.CF_TURB_ROUGHNESS_SCHLICHTING_AVG
        r""" Roughness Schlichting Avg turbulent Cf equation."""
        self.DO_NOT_USE_CF_TURB_ROUGHNESS_SCHLICHTING_LOCAL = _vsp.DO_NOT_USE_CF_TURB_ROUGHNESS_SCHLICHTING_LOCAL
        r""" Roughness Schlichting Local turbulent Cf equation (DO NOT USE)"""
        self.DO_NOT_USE_CF_TURB_ROUGHNESS_WHITE = _vsp.DO_NOT_USE_CF_TURB_ROUGHNESS_WHITE
        r""" Roughness White turbulent Cf equation (DO NOT USE)"""
        self.CF_TURB_ROUGHNESS_SCHLICHTING_AVG_FLOW_CORRECTION = _vsp.CF_TURB_ROUGHNESS_SCHLICHTING_AVG_FLOW_CORRECTION
        r""" Roughness Schlichting Avg Compressible turbulent Cf equation."""
        self.CF_TURB_HEATTRANSFER_WHITE_CHRISTOPH = _vsp.CF_TURB_HEATTRANSFER_WHITE_CHRISTOPH
        r""" Heat Transfer White-Christoph turbulent Cf equation."""
        self.CHEVRON_NONE = _vsp.CHEVRON_NONE
        r""" No chevron."""
        self.CHEVRON_PARTIAL = _vsp.CHEVRON_PARTIAL
        r""" One or more chevrons of limited extent."""
        self.CHEVRON_FULL = _vsp.CHEVRON_FULL
        r""" Full period of chevrons."""
        self.CHEVRON_NUM_TYPES = _vsp.CHEVRON_NUM_TYPES
        r""" Number of chevron types."""
        self.CHEVRON_W01_SE = _vsp.CHEVRON_W01_SE
        self.CHEVRON_W01_CW = _vsp.CHEVRON_W01_CW
        self.CHEVRON_W01_NUM_MODES = _vsp.CHEVRON_W01_NUM_MODES
        r""" Number of chevron W parameter mode types."""
        self.COLLISION_OK = _vsp.COLLISION_OK
        r""" No Error."""
        self.COLLISION_INTERSECT_NO_SOLUTION = _vsp.COLLISION_INTERSECT_NO_SOLUTION
        r""" Touching, no solution"""
        self.COLLISION_CLEAR_NO_SOLUTION = _vsp.COLLISION_CLEAR_NO_SOLUTION
        r""" Not touching, no solution"""
        self.NO_FILE_TYPE = _vsp.NO_FILE_TYPE
        r""" No export file type"""
        self.COMP_GEOM_TXT_TYPE = _vsp.COMP_GEOM_TXT_TYPE
        self.COMP_GEOM_CSV_TYPE = _vsp.COMP_GEOM_CSV_TYPE
        self.DRAG_BUILD_TSV_TYPE_DEPRECATED = _vsp.DRAG_BUILD_TSV_TYPE_DEPRECATED
        self.SLICE_TXT_TYPE = _vsp.SLICE_TXT_TYPE
        self.MASS_PROP_TXT_TYPE = _vsp.MASS_PROP_TXT_TYPE
        self.DEGEN_GEOM_CSV_TYPE = _vsp.DEGEN_GEOM_CSV_TYPE
        self.DEGEN_GEOM_M_TYPE = _vsp.DEGEN_GEOM_M_TYPE
        self.CFD_STL_TYPE = _vsp.CFD_STL_TYPE
        self.CFD_POLY_TYPE = _vsp.CFD_POLY_TYPE
        self.CFD_TRI_TYPE = _vsp.CFD_TRI_TYPE
        self.CFD_OBJ_TYPE = _vsp.CFD_OBJ_TYPE
        self.CFD_DAT_TYPE = _vsp.CFD_DAT_TYPE
        self.CFD_KEY_TYPE = _vsp.CFD_KEY_TYPE
        self.CFD_GMSH_TYPE = _vsp.CFD_GMSH_TYPE
        self.CFD_SRF_TYPE_DEPRECATED = _vsp.CFD_SRF_TYPE_DEPRECATED
        self.CFD_TKEY_TYPE = _vsp.CFD_TKEY_TYPE
        self.PROJ_AREA_CSV_TYPE = _vsp.PROJ_AREA_CSV_TYPE
        self.WAVE_DRAG_TXT_TYPE = _vsp.WAVE_DRAG_TXT_TYPE
        self.VSPAERO_PANEL_TRI_TYPE = _vsp.VSPAERO_PANEL_TRI_TYPE
        self.DRAG_BUILD_CSV_TYPE = _vsp.DRAG_BUILD_CSV_TYPE
        self.CFD_FACET_TYPE = _vsp.CFD_FACET_TYPE
        self.CFD_CURV_TYPE_DEPRECATED = _vsp.CFD_CURV_TYPE_DEPRECATED
        self.CFD_PLOT3D_TYPE_DEPRECATED = _vsp.CFD_PLOT3D_TYPE_DEPRECATED
        self.CFD_VSPGEOM_TYPE = _vsp.CFD_VSPGEOM_TYPE
        self.VSPAERO_VSPGEOM_TYPE = _vsp.VSPAERO_VSPGEOM_TYPE
        self.U_TRIM = _vsp.U_TRIM
        r""" Trim by U coordinate"""
        self.L_TRIM = _vsp.L_TRIM
        r""" Trim by L coordinate"""
        self.ETA_TRIM = _vsp.ETA_TRIM
        r""" Trim by Eta coordinate"""
        self.NUM_TRIM_TYPES = _vsp.NUM_TRIM_TYPES
        r""" Number of conformal component trim types"""
        self.DELIM_COMMA = _vsp.DELIM_COMMA
        r""" Comma delimiter"""
        self.DELIM_USCORE = _vsp.DELIM_USCORE
        r""" Underscore delimiter"""
        self.DELIM_SPACE = _vsp.DELIM_SPACE
        r""" Space delimiter"""
        self.DELIM_NONE = _vsp.DELIM_NONE
        r""" No delimiter"""
        self.DELIM_NUM_TYPES = _vsp.DELIM_NUM_TYPES
        r""" Number of delimiter types"""
        self.DEPTH_FRONT = _vsp.DEPTH_FRONT
        r""" Set 3D background before model"""
        self.DEPTH_REAR = _vsp.DEPTH_REAR
        r""" Set 3D background behind model"""
        self.DEPTH_FREE = _vsp.DEPTH_FREE
        r""" Set 3D background at specified location"""
        self.NUM_DEPTH_TYPE = _vsp.NUM_DEPTH_TYPE
        r""" Number of depth types"""
        self.SET_3D = _vsp.SET_3D
        r""" 3D DXF export (default)"""
        self.SET_2D = _vsp.SET_2D
        r""" 2D DXF export"""
        self.X_DIR = _vsp.X_DIR
        r""" X direction"""
        self.Y_DIR = _vsp.Y_DIR
        self.Z_DIR = _vsp.Z_DIR
        self.ALL_DIR = _vsp.ALL_DIR
        self.DISPLAY_BEZIER = _vsp.DISPLAY_BEZIER
        r""" Display the normal Bezier surface (default)"""
        self.DISPLAY_DEGEN_SURF = _vsp.DISPLAY_DEGEN_SURF
        r""" Display as surface Degen Geom"""
        self.DISPLAY_DEGEN_PLATE = _vsp.DISPLAY_DEGEN_PLATE
        r""" Display as plate Degen Geom"""
        self.DISPLAY_DEGEN_CAMBER = _vsp.DISPLAY_DEGEN_CAMBER
        r""" Display as camber Degen Geom"""
        self.GEOM_DRAW_WIRE = _vsp.GEOM_DRAW_WIRE
        r""" Draw the wireframe mesh (see through)"""
        self.GEOM_DRAW_HIDDEN = _vsp.GEOM_DRAW_HIDDEN
        r""" Draw the hidden mesh"""
        self.GEOM_DRAW_SHADE = _vsp.GEOM_DRAW_SHADE
        r""" Draw the shaded mesh"""
        self.GEOM_DRAW_TEXTURE = _vsp.GEOM_DRAW_TEXTURE
        r""" Draw the textured mesh"""
        self.GEOM_DRAW_NONE = _vsp.GEOM_DRAW_NONE
        r""" Do not draw anything"""
        self.ENGINE_GEOM_NONE = _vsp.ENGINE_GEOM_NONE
        r""" Component is not an integrated flowpath component."""
        self.ENGINE_GEOM_INLET = _vsp.ENGINE_GEOM_INLET
        r""" Component represents integrated flowpath inlet."""
        self.ENGINE_GEOM_INLET_OUTLET = _vsp.ENGINE_GEOM_INLET_OUTLET
        r""" Component represents integrated flowpath inlet and outlet."""
        self.ENGINE_GEOM_OUTLET = _vsp.ENGINE_GEOM_OUTLET
        r""" Component represents integrated flowpath outlet."""
        self.ENGINE_GEOM_IO_NUM_TYPES = _vsp.ENGINE_GEOM_IO_NUM_TYPES
        r""" Number of integrated flowpath component types."""
        self.ENGINE_GEOM_FLOWTHROUGH = _vsp.ENGINE_GEOM_FLOWTHROUGH
        r""" Component is modeled as flowthrough engine."""
        self.ENGINE_GEOM_TO_LIP = _vsp.ENGINE_GEOM_TO_LIP
        r""" Component is modeled to the lip."""
        self.ENGINE_GEOM_FLOWPATH = _vsp.ENGINE_GEOM_FLOWPATH
        r""" Component flowpath is modeled."""
        self.ENGINE_GEOM_TO_FACE = _vsp.ENGINE_GEOM_TO_FACE
        r""" Component is modeled to face."""
        self.ENGINE_GEOM_NUM_TYPES = _vsp.ENGINE_GEOM_NUM_TYPES
        r""" Number of integrated flowpath modeling types."""
        self.ENGINE_LOC_INDEX = _vsp.ENGINE_LOC_INDEX
        r""" Integrated flowpath key point identified by XSec index."""
        self.ENGINE_LOC_U = _vsp.ENGINE_LOC_U
        r""" Integrated flowpath key point identified by U parameter."""
        self.ENGINE_LOC_INLET_LIP = _vsp.ENGINE_LOC_INLET_LIP
        r""" Integrated flowpath key point is inlet lip."""
        self.ENGINE_LOC_INLET_FACE = _vsp.ENGINE_LOC_INLET_FACE
        r""" Integrated flowpath key point is inlet face."""
        self.ENGINE_LOC_OUTLET_LIP = _vsp.ENGINE_LOC_OUTLET_LIP
        r""" Integrated flowpath key point is outlet lip."""
        self.ENGINE_LOC_OUTLET_FACE = _vsp.ENGINE_LOC_OUTLET_FACE
        r""" Integrated flowpath key point is outlet face."""
        self.ENGINE_LOC_NUM = _vsp.ENGINE_LOC_NUM
        r""" Number of integrated flowpath key point locations."""
        self.ENGINE_MODE_FLOWTHROUGH = _vsp.ENGINE_MODE_FLOWTHROUGH
        r""" Represent integrated flowpath as flowthrough engine."""
        self.ENGINE_MODE_FLOWTHROUGH_NEG = _vsp.ENGINE_MODE_FLOWTHROUGH_NEG
        r""" Represent integrated flowpath as flowthrough engine with negative flowpath."""
        self.ENGINE_MODE_TO_LIP = _vsp.ENGINE_MODE_TO_LIP
        r""" Represent integrated flowpath to the lip."""
        self.ENGINE_MODE_TO_FACE = _vsp.ENGINE_MODE_TO_FACE
        r""" Represent integrated flowpath to the face."""
        self.ENGINE_MODE_TO_FACE_NEG = _vsp.ENGINE_MODE_TO_FACE_NEG
        r""" Represent integrated flowpath to the face with negative flowpath to the face."""
        self.ENGINE_MODE_EXTEND = _vsp.ENGINE_MODE_EXTEND
        r""" Represent integrated flowpath with farfield extensions."""
        self.ENGINE_MODE_NUM_TYPES = _vsp.ENGINE_MODE_NUM_TYPES
        r""" Number of integrated flowpath representations."""
        self.VSP_OK = _vsp.VSP_OK
        r""" No error"""
        self.VSP_INVALID_PTR = _vsp.VSP_INVALID_PTR
        r""" Invalid pointer error"""
        self.VSP_INVALID_TYPE = _vsp.VSP_INVALID_TYPE
        r""" Invalid type error"""
        self.VSP_CANT_FIND_TYPE = _vsp.VSP_CANT_FIND_TYPE
        r""" Can't find type error"""
        self.VSP_CANT_FIND_PARM = _vsp.VSP_CANT_FIND_PARM
        r""" Can't find parm error"""
        self.VSP_CANT_FIND_NAME = _vsp.VSP_CANT_FIND_NAME
        r""" Can't find name error"""
        self.VSP_INVALID_GEOM_ID = _vsp.VSP_INVALID_GEOM_ID
        r""" Invalid Geom ID error"""
        self.VSP_FILE_DOES_NOT_EXIST = _vsp.VSP_FILE_DOES_NOT_EXIST
        r""" File does not exist error"""
        self.VSP_FILE_WRITE_FAILURE = _vsp.VSP_FILE_WRITE_FAILURE
        r""" File write failure error"""
        self.VSP_FILE_READ_FAILURE = _vsp.VSP_FILE_READ_FAILURE
        r""" File read failure error"""
        self.VSP_WRONG_GEOM_TYPE = _vsp.VSP_WRONG_GEOM_TYPE
        r""" Wrong Geom type error"""
        self.VSP_WRONG_XSEC_TYPE = _vsp.VSP_WRONG_XSEC_TYPE
        r""" Wrong XSec type error"""
        self.VSP_WRONG_FILE_TYPE = _vsp.VSP_WRONG_FILE_TYPE
        r""" Wrong file type error"""
        self.VSP_INDEX_OUT_RANGE = _vsp.VSP_INDEX_OUT_RANGE
        r""" Index out of range error"""
        self.VSP_INVALID_XSEC_ID = _vsp.VSP_INVALID_XSEC_ID
        r""" Invalid XSec ID error"""
        self.VSP_INVALID_ID = _vsp.VSP_INVALID_ID
        r""" Invalid ID error"""
        self.VSP_CANT_SET_NOT_EQ_PARM = _vsp.VSP_CANT_SET_NOT_EQ_PARM
        r""" Can't set NotEqParm error"""
        self.VSP_AMBIGUOUS_SUBSURF = _vsp.VSP_AMBIGUOUS_SUBSURF
        r""" Ambiguous flow-through sub-surface error"""
        self.VSP_INVALID_VARPRESET_SETNAME = _vsp.VSP_INVALID_VARPRESET_SETNAME
        r""" Invalid Variable Preset set name error"""
        self.VSP_INVALID_VARPRESET_GROUPNAME = _vsp.VSP_INVALID_VARPRESET_GROUPNAME
        r""" Invalid Variable Preset group name error"""
        self.VSP_CONFORMAL_PARENT_UNSUPPORTED = _vsp.VSP_CONFORMAL_PARENT_UNSUPPORTED
        r""" Unsupported Conformal Geom parent error"""
        self.VSP_UNEXPECTED_RESET_REMAP_ID = _vsp.VSP_UNEXPECTED_RESET_REMAP_ID
        r""" Unexpected reset remap ID error"""
        self.VSP_INVALID_INPUT_VAL = _vsp.VSP_INVALID_INPUT_VAL
        r""" Invalid input value error"""
        self.VSP_INVALID_CF_EQN = _vsp.VSP_INVALID_CF_EQN
        r""" Invalid friction coefficient equation error"""
        self.VSP_INVALID_DRIVERS = _vsp.VSP_INVALID_DRIVERS
        r""" Invalid drivers for driver group"""
        self.VSP_ADV_LINK_BUILD_FAIL = _vsp.VSP_ADV_LINK_BUILD_FAIL
        r""" Advanced link build failure"""
        self.VSP_DEPRECATED = _vsp.VSP_DEPRECATED
        r""" This capability has been deprecated and is not longer supported"""
        self.VSP_LINK_LOOP_DETECTED = _vsp.VSP_LINK_LOOP_DETECTED
        r""" A parameter link loop was detected and stopped"""
        self.VSP_DUPLICATE_NAME = _vsp.VSP_DUPLICATE_NAME
        r""" A duplicate name has been provided"""
        self.VSP_GUI_DEVICE_DEACTIVATED = _vsp.VSP_GUI_DEVICE_DEACTIVATED
        r""" A deactivated GUI device was touched"""
        self.VSP_COULD_NOT_CREATE_BACKGROUND3D = _vsp.VSP_COULD_NOT_CREATE_BACKGROUND3D
        r""" Could not create and add Background3D"""
        self.VSP_NUM_ERROR_CODE = _vsp.VSP_NUM_ERROR_CODE
        r""" Total number of VSP error codes"""
        self.EXCRESCENCE_COUNT = _vsp.EXCRESCENCE_COUNT
        r""" Drag counts excressence type"""
        self.EXCRESCENCE_CD = _vsp.EXCRESCENCE_CD
        r""" Drag coefficient excressence type"""
        self.EXCRESCENCE_PERCENT_GEOM = _vsp.EXCRESCENCE_PERCENT_GEOM
        r""" Percent of parent Geom drag coefficient excressence type"""
        self.EXCRESCENCE_MARGIN = _vsp.EXCRESCENCE_MARGIN
        r""" Percent margin excressence type"""
        self.EXCRESCENCE_DRAGAREA = _vsp.EXCRESCENCE_DRAGAREA
        r""" Drag area (D/q) excressence type"""
        self.EXPORT_FELISA = _vsp.EXPORT_FELISA
        r""" FELISA export type (NOT IMPLEMENTED)"""
        self.EXPORT_XSEC = _vsp.EXPORT_XSEC
        r""" XSec (*.hrm) export type"""
        self.EXPORT_STL = _vsp.EXPORT_STL
        r""" Stereolith (*.stl) export type"""
        self.EXPORT_AWAVE = _vsp.EXPORT_AWAVE
        r""" AWAVE export type (NOT IMPLEMENTED)"""
        self.EXPORT_NASCART = _vsp.EXPORT_NASCART
        r""" NASCART (*.dat) export type"""
        self.EXPORT_POVRAY = _vsp.EXPORT_POVRAY
        r""" POVRAY (*.pov) export type"""
        self.EXPORT_CART3D = _vsp.EXPORT_CART3D
        r""" Cart3D (*.tri) export type"""
        self.EXPORT_VSPGEOM = _vsp.EXPORT_VSPGEOM
        r""" VSPGeom (*.vspgeom) export type"""
        self.EXPORT_VORXSEC = _vsp.EXPORT_VORXSEC
        r""" VORXSEC  export type (NOT IMPLEMENTED)"""
        self.EXPORT_XSECGEOM = _vsp.EXPORT_XSECGEOM
        r""" XSECGEOM export type (NOT IMPLEMENTED)"""
        self.EXPORT_GMSH = _vsp.EXPORT_GMSH
        r""" Gmsh (*.msh) export type"""
        self.EXPORT_X3D = _vsp.EXPORT_X3D
        r""" X3D (*.x3d) export type"""
        self.EXPORT_STEP = _vsp.EXPORT_STEP
        r""" STEP (*.stp) export type"""
        self.EXPORT_PLOT3D = _vsp.EXPORT_PLOT3D
        r""" PLOT3D (*.p3d) export type"""
        self.EXPORT_IGES = _vsp.EXPORT_IGES
        r""" IGES (*.igs) export type"""
        self.EXPORT_BEM = _vsp.EXPORT_BEM
        r""" Blade Element (*.bem) export type"""
        self.EXPORT_DXF = _vsp.EXPORT_DXF
        r""" AutoCAD (*.dxf) export type"""
        self.EXPORT_FACET = _vsp.EXPORT_FACET
        r""" Xpatch (*.facet) export type"""
        self.EXPORT_SVG = _vsp.EXPORT_SVG
        r""" SVG (*.svg) export type"""
        self.EXPORT_PMARC = _vsp.EXPORT_PMARC
        r""" PMARC 12 (*.pmin) export type"""
        self.EXPORT_OBJ = _vsp.EXPORT_OBJ
        r""" OBJ (*.obj) export type"""
        self.EXPORT_SELIG_AIRFOIL = _vsp.EXPORT_SELIG_AIRFOIL
        r""" Airfoil points (*.dat) export type"""
        self.EXPORT_BEZIER_AIRFOIL = _vsp.EXPORT_BEZIER_AIRFOIL
        r""" Airfoil curves (*.bz) export type"""
        self.EXPORT_IGES_STRUCTURE = _vsp.EXPORT_IGES_STRUCTURE
        r""" IGES structure (*.igs) export type"""
        self.EXPORT_STEP_STRUCTURE = _vsp.EXPORT_STEP_STRUCTURE
        r""" STEP structure (*.stp) export type"""
        self.FEA_BC_STRUCTURE = _vsp.FEA_BC_STRUCTURE
        r""" FEA boundary condition assigned to structure."""
        self.FEA_BC_PART = _vsp.FEA_BC_PART
        r""" FEA boundary condition assigned to part."""
        self.FEA_BC_SUBSURF = _vsp.FEA_BC_SUBSURF
        r""" FEA boundary condition assigned to subsurface."""
        self.FEA_NUM_BC_TYPES = _vsp.FEA_NUM_BC_TYPES
        r""" Number of FEA boundary condition definition types."""
        self.FEA_BCM_USER = _vsp.FEA_BCM_USER
        r""" FEA boundary condition constraints user defined."""
        self.FEA_BCM_ALL = _vsp.FEA_BCM_ALL
        r""" FEA boundary condition constrains all DOF."""
        self.FEA_BCM_PIN = _vsp.FEA_BCM_PIN
        r""" FEA boundary condition pin constraints."""
        self.FEA_BCM_SYMM = _vsp.FEA_BCM_SYMM
        r""" FEA boundary condition symmetrical constraints."""
        self.FEA_BCM_ASYMM = _vsp.FEA_BCM_ASYMM
        r""" FEA boundary condition antisymmetrical constraints."""
        self.FEA_NUM_BCM_MODES = _vsp.FEA_NUM_BCM_MODES
        r""" Number of FEA boundary condition constraint types."""
        self.FEA_XSEC_GENERAL = _vsp.FEA_XSEC_GENERAL
        r""" General XSec type"""
        self.FEA_XSEC_CIRC = _vsp.FEA_XSEC_CIRC
        r""" Circle XSec type"""
        self.FEA_XSEC_PIPE = _vsp.FEA_XSEC_PIPE
        r""" Pipe XSec type"""
        self.FEA_XSEC_I = _vsp.FEA_XSEC_I
        r""" I XSec type"""
        self.FEA_XSEC_RECT = _vsp.FEA_XSEC_RECT
        r""" Rectangle XSec type"""
        self.FEA_XSEC_BOX = _vsp.FEA_XSEC_BOX
        r""" Box XSec type"""
        self.FEA_MASS_FILE_NAME = _vsp.FEA_MASS_FILE_NAME
        r""" FEA Mesh mass export type"""
        self.FEA_NASTRAN_FILE_NAME = _vsp.FEA_NASTRAN_FILE_NAME
        r""" FEA Mesh NASTRAN export type"""
        self.FEA_NKEY_FILE_NAME = _vsp.FEA_NKEY_FILE_NAME
        r""" FEA Mesh NKey export type"""
        self.FEA_CALCULIX_FILE_NAME = _vsp.FEA_CALCULIX_FILE_NAME
        r""" FEA Mesh Calculix export type"""
        self.FEA_STL_FILE_NAME = _vsp.FEA_STL_FILE_NAME
        r""" FEA Mesh STL export type"""
        self.FEA_GMSH_FILE_NAME = _vsp.FEA_GMSH_FILE_NAME
        r""" FEA Mesh GMSH export type"""
        self.FEA_SRF_FILE_NAME = _vsp.FEA_SRF_FILE_NAME
        r""" FEA Mesh SRF export type"""
        self.FEA_CURV_FILE_NAME = _vsp.FEA_CURV_FILE_NAME
        r""" FEA Mesh CURV export type"""
        self.FEA_PLOT3D_FILE_NAME = _vsp.FEA_PLOT3D_FILE_NAME
        r""" FEA Mesh PLOT3D export type"""
        self.FEA_IGES_FILE_NAME = _vsp.FEA_IGES_FILE_NAME
        r""" FEA Mesh trimmed IGES export type"""
        self.FEA_STEP_FILE_NAME = _vsp.FEA_STEP_FILE_NAME
        r""" FEA Mesh trimmed STEP export type"""
        self.FEA_NUM_FILE_NAMES = _vsp.FEA_NUM_FILE_NAMES
        r""" Number of FEA Mesh export type."""
        self.FEA_FIX_PT_ON_BODY = _vsp.FEA_FIX_PT_ON_BODY
        r""" On body fixed point type"""
        self.FEA_FIX_PT_GLOBAL_XYZ = _vsp.FEA_FIX_PT_GLOBAL_XYZ
        r""" Global XYZ off body fixed point type"""
        self.FEA_FIX_PT_DELTA_XYZ = _vsp.FEA_FIX_PT_DELTA_XYZ
        r""" Delta XYZ off body fixed point type"""
        self.FEA_FIX_PT_DELTA_UVN = _vsp.FEA_FIX_PT_DELTA_UVN
        r""" Delta UVN off body fixed point type"""
        self.FEA_FIX_PT_GEOM_ORIGIN = _vsp.FEA_FIX_PT_GEOM_ORIGIN
        r""" Geom origin off body fixed point type"""
        self.FEA_FIX_PT_GEOM_CG = _vsp.FEA_FIX_PT_GEOM_CG
        r""" Geom CG off body fixed point type"""
        self.FEA_NUM_FIX_PT_TYPES = _vsp.FEA_NUM_FIX_PT_TYPES
        r""" Number of off body fixed point types"""
        self.FEA_ISOTROPIC = _vsp.FEA_ISOTROPIC
        r""" Isotropic material"""
        self.FEA_ENG_ORTHO = _vsp.FEA_ENG_ORTHO
        r""" Orthotropic material in engineering parameters"""
        self.FEA_ENG_ORTHO_TRANS_ISO = _vsp.FEA_ENG_ORTHO_TRANS_ISO
        r""" Orthotropic material with transverse isotropy assumed in engineering parameters"""
        self.FEA_LAMINATE = _vsp.FEA_LAMINATE
        r""" Laminate buildup material"""
        self.FEA_NUM_MAT_TYPES = _vsp.FEA_NUM_MAT_TYPES
        r""" Number of FEA material types"""
        self.FEA_ORIENT_GLOBAL_X = _vsp.FEA_ORIENT_GLOBAL_X
        r""" FEA Global X material orientation"""
        self.FEA_ORIENT_GLOBAL_Y = _vsp.FEA_ORIENT_GLOBAL_Y
        r""" FEA Global Y material orientation"""
        self.FEA_ORIENT_GLOBAL_Z = _vsp.FEA_ORIENT_GLOBAL_Z
        r""" FEA Global Z material orientation"""
        self.FEA_ORIENT_COMP_X = _vsp.FEA_ORIENT_COMP_X
        r""" FEA Comp X material orientation"""
        self.FEA_ORIENT_COMP_Y = _vsp.FEA_ORIENT_COMP_Y
        r""" FEA Comp Y material orientation"""
        self.FEA_ORIENT_COMP_Z = _vsp.FEA_ORIENT_COMP_Z
        r""" FEA Comp Z material orientation"""
        self.FEA_ORIENT_PART_U = _vsp.FEA_ORIENT_PART_U
        r""" FEA Part U material orientation"""
        self.FEA_ORIENT_PART_V = _vsp.FEA_ORIENT_PART_V
        r""" FEA Part V material orientation"""
        self.FEA_ORIENT_OML_U = _vsp.FEA_ORIENT_OML_U
        r""" FEA OML U material orientation"""
        self.FEA_ORIENT_OML_V = _vsp.FEA_ORIENT_OML_V
        r""" FEA OML V material orientation"""
        self.FEA_ORIENT_OML_R = _vsp.FEA_ORIENT_OML_R
        r""" FEA OML R material orientation"""
        self.FEA_ORIENT_OML_S = _vsp.FEA_ORIENT_OML_S
        r""" FEA OML S material orientation"""
        self.FEA_ORIENT_OML_T = _vsp.FEA_ORIENT_OML_T
        r""" FEA OML T material orientation"""
        self.FEA_NUM_ORIENT_TYPES = _vsp.FEA_NUM_ORIENT_TYPES
        r""" Number of FEA material orientation types"""
        self.FEA_DEPRECATED = _vsp.FEA_DEPRECATED
        r""" Flag for deprecated element type option"""
        self.FEA_SHELL = _vsp.FEA_SHELL
        r""" Shell (tris) FEA element type"""
        self.FEA_BEAM = _vsp.FEA_BEAM
        r""" Beam FEA element type"""
        self.FEA_SHELL_AND_BEAM = _vsp.FEA_SHELL_AND_BEAM
        r""" Both Shell and Beam FEA element types"""
        self.FEA_NO_ELEMENTS = _vsp.FEA_NO_ELEMENTS
        r""" FEA part with no elements"""
        self.FEA_NUM_ELEMENT_TYPES = _vsp.FEA_NUM_ELEMENT_TYPES
        r""" Number of FEA element type choices"""
        self.FEA_KEEP = _vsp.FEA_KEEP
        r""" Keep shell elements"""
        self.FEA_DELETE = _vsp.FEA_DELETE
        r""" Delete shell elements"""
        self.FEA_NUM_SHELL_TREATMENT_TYPES = _vsp.FEA_NUM_SHELL_TREATMENT_TYPES
        r""" Number of FEA subsurface treatment choices"""
        self.FEA_SLICE = _vsp.FEA_SLICE
        r""" Slice FEA Part type"""
        self.FEA_RIB = _vsp.FEA_RIB
        r""" Rib FEA Part type"""
        self.FEA_SPAR = _vsp.FEA_SPAR
        r""" Spar FEA Part type"""
        self.FEA_FIX_POINT = _vsp.FEA_FIX_POINT
        r""" Fixed Point FEA Part type"""
        self.FEA_DOME = _vsp.FEA_DOME
        r""" Dome FEA Part type"""
        self.FEA_RIB_ARRAY = _vsp.FEA_RIB_ARRAY
        r""" Rib array FEA Part type"""
        self.FEA_SLICE_ARRAY = _vsp.FEA_SLICE_ARRAY
        r""" Slice array FEA Part type"""
        self.FEA_SKIN = _vsp.FEA_SKIN
        r""" Skin FEA Part type"""
        self.FEA_TRIM = _vsp.FEA_TRIM
        r""" Trim FEA Part type"""
        self.FEA_NUM_TYPES = _vsp.FEA_NUM_TYPES
        r""" Number of FEA Part types"""
        self.XY_BODY = _vsp.XY_BODY
        r""" Slice is parallel to parent Geom body XY plane"""
        self.YZ_BODY = _vsp.YZ_BODY
        r""" Slice is parallel to parent Geom body YZ plane"""
        self.XZ_BODY = _vsp.XZ_BODY
        r""" Slice is parallel to parent Geom body XZ plane"""
        self.XY_ABS = _vsp.XY_ABS
        r""" Slice is parallel to absolute XY plane"""
        self.YZ_ABS = _vsp.YZ_ABS
        r""" Slice is parallel to absolute YZ plane"""
        self.XZ_ABS = _vsp.XZ_ABS
        r""" Slice is parallel to absolute XZ plane"""
        self.SPINE_NORMAL = _vsp.SPINE_NORMAL
        r""" Slice is perpendicular to thespine of the parent Geom"""
        self.SI_UNIT = _vsp.SI_UNIT
        r""" FEA Files output in (m, kg)"""
        self.CGS_UNIT = _vsp.CGS_UNIT
        r""" FEA Files output in (cm, g)"""
        self.MPA_UNIT = _vsp.MPA_UNIT
        r""" FEA Files output in (mm, tonne)"""
        self.BFT_UNIT = _vsp.BFT_UNIT
        r""" FEA Files output in (ft, slug)"""
        self.BIN_UNIT = _vsp.BIN_UNIT
        r""" FEA Files output in (in, lbf*sec^2/in)"""
        self.NO_NORMAL = _vsp.NO_NORMAL
        r""" FEA Rib or Rib Array has no set perpendicular edge"""
        self.LE_NORMAL = _vsp.LE_NORMAL
        r""" FEA Rib or Rib Array is set perpendicular to the leading edge"""
        self.TE_NORMAL = _vsp.TE_NORMAL
        r""" FEA Rib or Rib Array is set perpendicular to the trailing edge"""
        self.SPAR_NORMAL = _vsp.SPAR_NORMAL
        r""" FEA Rib or Rib Array is set perpendicular to an FEA Spar"""
        self.FF_B_MANUAL = _vsp.FF_B_MANUAL
        r""" Manual FF equation"""
        self.FF_B_SCHEMENSKY_FUSE = _vsp.FF_B_SCHEMENSKY_FUSE
        r""" Schemensky Fuselage FF equation"""
        self.FF_B_SCHEMENSKY_NACELLE = _vsp.FF_B_SCHEMENSKY_NACELLE
        r""" Schemensky Nacelle FF equation"""
        self.FF_B_HOERNER_STREAMBODY = _vsp.FF_B_HOERNER_STREAMBODY
        r""" Hoerner Streamlined Body FF equation"""
        self.FF_B_TORENBEEK = _vsp.FF_B_TORENBEEK
        r""" Torenbeek FF equation"""
        self.FF_B_SHEVELL = _vsp.FF_B_SHEVELL
        r""" Shevell FF equation"""
        self.FF_B_COVERT = _vsp.FF_B_COVERT
        r""" Covert FF equation"""
        self.FF_B_JENKINSON_FUSE = _vsp.FF_B_JENKINSON_FUSE
        r""" Jenkinson Fuselage FF equation"""
        self.FF_B_JENKINSON_WING_NACELLE = _vsp.FF_B_JENKINSON_WING_NACELLE
        r""" Jenkinson Wing Nacelle FF equation"""
        self.FF_B_JENKINSON_AFT_FUSE_NACELLE = _vsp.FF_B_JENKINSON_AFT_FUSE_NACELLE
        r""" Jenkinson Aft Fuselage Nacelle FF equation"""
        self.FF_W_MANUAL = _vsp.FF_W_MANUAL
        r""" Manual FF equation"""
        self.FF_W_EDET_CONV = _vsp.FF_W_EDET_CONV
        r""" EDET Conventional Airfoil FF equation"""
        self.FF_W_EDET_ADV = _vsp.FF_W_EDET_ADV
        r""" EDET Advanced Airfoil FF equation"""
        self.FF_W_HOERNER = _vsp.FF_W_HOERNER
        r""" Hoerner FF equation"""
        self.FF_W_COVERT = _vsp.FF_W_COVERT
        r""" Covert FF equation"""
        self.FF_W_SHEVELL = _vsp.FF_W_SHEVELL
        r""" Shevell FF equation"""
        self.FF_W_KROO = _vsp.FF_W_KROO
        r""" Kroo FF equation"""
        self.FF_W_TORENBEEK = _vsp.FF_W_TORENBEEK
        r""" Torenbeek FF equation"""
        self.FF_W_DATCOM = _vsp.FF_W_DATCOM
        r""" DATCOM FF equation"""
        self.FF_W_SCHEMENSKY_6_SERIES_AF = _vsp.FF_W_SCHEMENSKY_6_SERIES_AF
        r""" Schemensky 6 Series Airfoil FF equation"""
        self.FF_W_SCHEMENSKY_4_SERIES_AF = _vsp.FF_W_SCHEMENSKY_4_SERIES_AF
        r""" Schemensky 4 Series Airfoil FF equation"""
        self.FF_W_JENKINSON_WING = _vsp.FF_W_JENKINSON_WING
        r""" Jenkinson Wing FF equation"""
        self.FF_W_JENKINSON_TAIL = _vsp.FF_W_JENKINSON_TAIL
        r""" Jenkinson Tail FF equation"""
        self.FF_W_SCHEMENSKY_SUPERCRITICAL_AF = _vsp.FF_W_SCHEMENSKY_SUPERCRITICAL_AF
        r""" Schemensky Supercritical Airfoil FF equation"""
        self.PD_UNITS_IMPERIAL = _vsp.PD_UNITS_IMPERIAL
        r""" Imperial unit system"""
        self.PD_UNITS_METRIC = _vsp.PD_UNITS_METRIC
        r""" Metric unit system"""
        self.OPEN = _vsp.OPEN
        r""" Browse files that already exist"""
        self.SAVE = _vsp.SAVE
        r""" Browse file system and enter file name"""
        self.NUM_FILE_CHOOSER_MODES = _vsp.NUM_FILE_CHOOSER_MODES
        r""" Number of file chooser modes"""
        self.FC_OPENVSP = _vsp.FC_OPENVSP
        r""" OpenVSP's own file chooser with directory preferences."""
        self.FC_NATIVE = _vsp.FC_NATIVE
        r""" Operating system's native file chooser"""
        self.NUM_FILE_CHOOSER_TYPES = _vsp.NUM_FILE_CHOOSER_TYPES
        r""" Number of file chooser types"""
        self.GDEV_TAB = _vsp.GDEV_TAB
        r""" Custom GUI Tab"""
        self.GDEV_SCROLL_TAB = _vsp.GDEV_SCROLL_TAB
        r""" Custom GUI Fl_Scroll and Tab"""
        self.GDEV_GROUP = _vsp.GDEV_GROUP
        r""" Custom GUI Group"""
        self.GDEV_PARM_BUTTON = _vsp.GDEV_PARM_BUTTON
        r""" Custom GUI ParmButton"""
        self.GDEV_INPUT = _vsp.GDEV_INPUT
        r""" Custom GUI Input"""
        self.GDEV_OUTPUT = _vsp.GDEV_OUTPUT
        r""" Custom GUI Output"""
        self.GDEV_SLIDER = _vsp.GDEV_SLIDER
        r""" Custom GUI Slider"""
        self.GDEV_SLIDER_ADJ_RANGE = _vsp.GDEV_SLIDER_ADJ_RANGE
        r""" Custom GUI SliderAdjRangeInput"""
        self.GDEV_CHECK_BUTTON = _vsp.GDEV_CHECK_BUTTON
        r""" Custom GUI CheckButton"""
        self.GDEV_CHECK_BUTTON_BIT = _vsp.GDEV_CHECK_BUTTON_BIT
        r""" Custom GUI CheckButtonBit"""
        self.GDEV_RADIO_BUTTON = _vsp.GDEV_RADIO_BUTTON
        r""" Custom GUI RadioButton"""
        self.GDEV_TOGGLE_BUTTON = _vsp.GDEV_TOGGLE_BUTTON
        r""" Custom GUI ToggleButton"""
        self.GDEV_TOGGLE_BUTTON_FREE = _vsp.GDEV_TOGGLE_BUTTON_FREE
        r""" Custom GUI ToggleButton without Parm"""
        self.GDEV_TOGGLE_RADIO_GROUP = _vsp.GDEV_TOGGLE_RADIO_GROUP
        r""" Custom GUI ToggleRadioGroup (NOT IMPLEMENTED)"""
        self.GDEV_TRIGGER_BUTTON = _vsp.GDEV_TRIGGER_BUTTON
        r""" Custom GUI TriggerButton"""
        self.GDEV_COUNTER = _vsp.GDEV_COUNTER
        r""" Custom GUI Counter"""
        self.GDEV_CHOICE = _vsp.GDEV_CHOICE
        r""" Custom GUI Choice"""
        self.GDEV_ADD_CHOICE_ITEM = _vsp.GDEV_ADD_CHOICE_ITEM
        r""" Add item to custom GUI Choice"""
        self.GDEV_SLIDER_INPUT = _vsp.GDEV_SLIDER_INPUT
        r""" Custom GUI SliderInput"""
        self.GDEV_SLIDER_ADJ_RANGE_INPUT = _vsp.GDEV_SLIDER_ADJ_RANGE_INPUT
        r""" Custom GUI SliderAdjRangeInput"""
        self.GDEV_SLIDER_ADJ_RANGE_TWO_INPUT = _vsp.GDEV_SLIDER_ADJ_RANGE_TWO_INPUT
        r""" Custom GUI SliderAdjRangeInput with two inputs (NOT IMPLEMENTED)"""
        self.GDEV_FRACT_PARM_SLIDER = _vsp.GDEV_FRACT_PARM_SLIDER
        r""" Custom GUI FractParmSlider"""
        self.GDEV_STRING_INPUT = _vsp.GDEV_STRING_INPUT
        r""" Custom GUI StringInput"""
        self.GDEV_INDEX_SELECTOR = _vsp.GDEV_INDEX_SELECTOR
        r""" Custom GUI IndexSelector"""
        self.GDEV_COLOR_PICKER = _vsp.GDEV_COLOR_PICKER
        r""" Custom GUI ColorPicker"""
        self.GDEV_YGAP = _vsp.GDEV_YGAP
        r""" Custom GUI Y gap"""
        self.GDEV_DIVIDER_BOX = _vsp.GDEV_DIVIDER_BOX
        r""" Custom GUI divider box"""
        self.GDEV_BEGIN_SAME_LINE = _vsp.GDEV_BEGIN_SAME_LINE
        r""" Set begin same line flag for custom GUI"""
        self.GDEV_END_SAME_LINE = _vsp.GDEV_END_SAME_LINE
        r""" Set end same line flag for custom GUI"""
        self.GDEV_FORCE_WIDTH = _vsp.GDEV_FORCE_WIDTH
        r""" Set forced width for custom GUI"""
        self.GDEV_SET_FORMAT = _vsp.GDEV_SET_FORMAT
        r""" Set format label for custom GUI"""
        self.NUM_GDEV_TYPES = _vsp.NUM_GDEV_TYPES
        r""" Number of GDEV types"""
        self.ALL_GDEV_TYPES = _vsp.ALL_GDEV_TYPES
        r""" Flag for all GDEV types"""
        self.MALE = _vsp.MALE
        r""" Male Human component"""
        self.FEMALE = _vsp.FEMALE
        r""" Female Human component"""
        self.POD_GEOM_SCREEN = _vsp.POD_GEOM_SCREEN
        r""" Pod geom screen"""
        self.FUSELAGE_GEOM_SCREEN = _vsp.FUSELAGE_GEOM_SCREEN
        r""" Fuselage geom screen"""
        self.MS_WING_GEOM_SCREEN = _vsp.MS_WING_GEOM_SCREEN
        r""" Wing geom screen"""
        self.BLANK_GEOM_SCREEN = _vsp.BLANK_GEOM_SCREEN
        r""" Blank geom screen"""
        self.MESH_GEOM_SCREEN = _vsp.MESH_GEOM_SCREEN
        r""" Mesh geom screen"""
        self.STACK_GEOM_SCREEN = _vsp.STACK_GEOM_SCREEN
        r""" Stack geom screen"""
        self.CUSTOM_GEOM_SCREEN = _vsp.CUSTOM_GEOM_SCREEN
        r""" Custom geom screen"""
        self.PT_CLOUD_GEOM_SCREEN = _vsp.PT_CLOUD_GEOM_SCREEN
        r""" Point cloud geom screen"""
        self.PROP_GEOM_SCREEN = _vsp.PROP_GEOM_SCREEN
        r""" Propeller geom screen"""
        self.HINGE_GEOM_SCREEN = _vsp.HINGE_GEOM_SCREEN
        r""" Hinge geom screen"""
        self.MULT_GEOM_SCREEN = _vsp.MULT_GEOM_SCREEN
        r""" Multiple geom screen"""
        self.CONFORMAL_SCREEN = _vsp.CONFORMAL_SCREEN
        r""" Conformal geom screen"""
        self.ELLIPSOID_GEOM_SCREEN = _vsp.ELLIPSOID_GEOM_SCREEN
        r""" Ellipsoid geom screen"""
        self.BOR_GEOM_SCREEN = _vsp.BOR_GEOM_SCREEN
        r""" Body of revolution geom screen"""
        self.WIRE_FRAME_GEOM_SCREEN = _vsp.WIRE_FRAME_GEOM_SCREEN
        r""" Wireframe geom screen"""
        self.HUMAN_GEOM_SCREEN = _vsp.HUMAN_GEOM_SCREEN
        r""" Human geom screen"""
        self.NUM_GEOM_SCREENS = _vsp.NUM_GEOM_SCREENS
        r""" Number of geom screens"""
        self.ALL_GEOM_SCREENS = _vsp.ALL_GEOM_SCREENS
        r""" All geom screens"""
        self.VSP_ADV_LINK_SCREEN = _vsp.VSP_ADV_LINK_SCREEN
        r""" Advanced linking screen"""
        self.VSP_ADV_LINK_VAR_RENAME_SCREEN = _vsp.VSP_ADV_LINK_VAR_RENAME_SCREEN
        r""" Advanced link variable rename screen"""
        self.VSP_AERO_STRUCT_SCREEN = _vsp.VSP_AERO_STRUCT_SCREEN
        r""" Aero / structural analysis screen"""
        self.VSP_AIRFOIL_CURVES_EXPORT_SCREEN = _vsp.VSP_AIRFOIL_CURVES_EXPORT_SCREEN
        r""" Airfoil curves export screen"""
        self.VSP_AIRFOIL_POINTS_EXPORT_SCREEN = _vsp.VSP_AIRFOIL_POINTS_EXPORT_SCREEN
        r""" Airfoil points screen"""
        self.VSP_ATTRIBUTE_EXPLORER_SCREEN = _vsp.VSP_ATTRIBUTE_EXPLORER_SCREEN
        r""" Attribute details screen"""
        self.VSP_BACKGROUND_SCREEN = _vsp.VSP_BACKGROUND_SCREEN
        r""" Background control screen"""
        self.VSP_BACKGROUND3D_SCREEN = _vsp.VSP_BACKGROUND3D_SCREEN
        r""" Background3D control screen"""
        self.VSP_BACKGROUND3D_PREVIEW_SCREEN = _vsp.VSP_BACKGROUND3D_PREVIEW_SCREEN
        r""" Background3D preview screen"""
        self.VSP_BEM_OPTIONS_SCREEN = _vsp.VSP_BEM_OPTIONS_SCREEN
        r""" Blade element method options screen"""
        self.VSP_CFD_MESH_SCREEN = _vsp.VSP_CFD_MESH_SCREEN
        r""" CFD Mesh screen"""
        self.VSP_CLIPPING_SCREEN = _vsp.VSP_CLIPPING_SCREEN
        r""" Clipping screen"""
        self.VSP_COMP_GEOM_SCREEN = _vsp.VSP_COMP_GEOM_SCREEN
        r""" CompGeom screen"""
        self.VSP_COR_SCREEN = _vsp.VSP_COR_SCREEN
        r""" Center of rotation screen"""
        self.VSP_CURVE_EDIT_SCREEN = _vsp.VSP_CURVE_EDIT_SCREEN
        r""" Curve edit screen"""
        self.VSP_DEGEN_GEOM_SCREEN = _vsp.VSP_DEGEN_GEOM_SCREEN
        r""" Degen geom screen"""
        self.VSP_DESIGN_VAR_SCREEN = _vsp.VSP_DESIGN_VAR_SCREEN
        r""" Design variables screen"""
        self.VSP_DXF_OPTIONS_SCREEN = _vsp.VSP_DXF_OPTIONS_SCREEN
        r""" DXF options screen"""
        self.VSP_EXPORT_SCREEN = _vsp.VSP_EXPORT_SCREEN
        r""" Export screen"""
        self.VSP_FEA_PART_EDIT_SCREEN = _vsp.VSP_FEA_PART_EDIT_SCREEN
        r""" FEA Part edit screen"""
        self.VSP_FEA_XSEC_SCREEN = _vsp.VSP_FEA_XSEC_SCREEN
        r""" FEA XSec screen"""
        self.VSP_FIT_MODEL_SCREEN = _vsp.VSP_FIT_MODEL_SCREEN
        r""" Fit model screen"""
        self.VSP_IGES_OPTIONS_SCREEN = _vsp.VSP_IGES_OPTIONS_SCREEN
        r""" IGES options screen"""
        self.VSP_IGES_STRUCTURE_OPTIONS_SCREEN = _vsp.VSP_IGES_STRUCTURE_OPTIONS_SCREEN
        r""" IGES structure options screen"""
        self.VSP_EXPORT_CUSTOM_SCRIPT = _vsp.VSP_EXPORT_CUSTOM_SCRIPT
        r""" Custom geom export screen"""
        self.VSP_IMPORT_SCREEN = _vsp.VSP_IMPORT_SCREEN
        r""" Import screen"""
        self.VSP_LIGHTING_SCREEN = _vsp.VSP_LIGHTING_SCREEN
        r""" Lighting screen"""
        self.VSP_MANAGE_GEOM_SCREEN = _vsp.VSP_MANAGE_GEOM_SCREEN
        r""" Manage geom screen"""
        self.VSP_MANAGE_TEXTURE_SCREEN = _vsp.VSP_MANAGE_TEXTURE_SCREEN
        r""" Texture mapping screen"""
        self.VSP_MASS_PROP_SCREEN = _vsp.VSP_MASS_PROP_SCREEN
        r""" Mass properties screen"""
        self.VSP_MATERIAL_EDIT_SCREEN = _vsp.VSP_MATERIAL_EDIT_SCREEN
        r""" Material edit screen"""
        self.VSP_MEASURE_SCREEN = _vsp.VSP_MEASURE_SCREEN
        r""" Measure screen"""
        self.VSP_MODE_EDITOR_SCREEN = _vsp.VSP_MODE_EDITOR_SCREEN
        r""" Mode editor screen"""
        self.VSP_NERF_MANAGE_GEOM_SCREEN = _vsp.VSP_NERF_MANAGE_GEOM_SCREEN
        r""" NERF'ed (limited to make safe) Manage geom screen"""
        self.VSP_SNAP_TO_SCREEN = _vsp.VSP_SNAP_TO_SCREEN
        r""" Snap to screen"""
        self.VSP_PARASITE_DRAG_SCREEN = _vsp.VSP_PARASITE_DRAG_SCREEN
        r""" Parasite drg screen"""
        self.VSP_PARM_DEBUG_SCREEN = _vsp.VSP_PARM_DEBUG_SCREEN
        r""" Parameter debug screen"""
        self.VSP_PARM_LINK_SCREEN = _vsp.VSP_PARM_LINK_SCREEN
        r""" Parameter linking screen"""
        self.VSP_PARM_SCREEN = _vsp.VSP_PARM_SCREEN
        r""" Parameter screen"""
        self.VSP_PICK_SET_SCREEN = _vsp.VSP_PICK_SET_SCREEN
        r""" Pick set screen"""
        self.VSP_PREFERENCES_SCREEN = _vsp.VSP_PREFERENCES_SCREEN
        r""" Preferences screen"""
        self.VSP_PROJECTION_SCREEN = _vsp.VSP_PROJECTION_SCREEN
        r""" Projected area screen"""
        self.VSP_PSLICE_SCREEN = _vsp.VSP_PSLICE_SCREEN
        r""" Planar slicing screen"""
        self.VSP_SCREENSHOT_SCREEN = _vsp.VSP_SCREENSHOT_SCREEN
        r""" Screenshot screen"""
        self.VSP_SELECT_FILE_SCREEN = _vsp.VSP_SELECT_FILE_SCREEN
        r""" Select file screen"""
        self.VSP_SET_EDITOR_SCREEN = _vsp.VSP_SET_EDITOR_SCREEN
        r""" Set editor screen"""
        self.VSP_STEP_OPTIONS_SCREEN = _vsp.VSP_STEP_OPTIONS_SCREEN
        r""" STEP options screen"""
        self.VSP_STEP_STRUCTURE_OPTIONS_SCREEN = _vsp.VSP_STEP_STRUCTURE_OPTIONS_SCREEN
        r""" STEP structure options screen"""
        self.VSP_STL_OPTIONS_SCREEN = _vsp.VSP_STL_OPTIONS_SCREEN
        r""" STL options screen"""
        self.VSP_STRUCT_SCREEN = _vsp.VSP_STRUCT_SCREEN
        r""" Structure definition screen"""
        self.VSP_STRUCT_ASSEMBLY_SCREEN = _vsp.VSP_STRUCT_ASSEMBLY_SCREEN
        r""" Structure assembly screen"""
        self.VSP_SURFACE_INTERSECTION_SCREEN = _vsp.VSP_SURFACE_INTERSECTION_SCREEN
        r""" Surface intersection screen"""
        self.VSP_SVG_OPTIONS_SCREEN = _vsp.VSP_SVG_OPTIONS_SCREEN
        r""" SVG options screen"""
        self.VSP_USER_PARM_SCREEN = _vsp.VSP_USER_PARM_SCREEN
        r""" User parameter screen"""
        self.VSP_VAR_PRESET_SCREEN = _vsp.VSP_VAR_PRESET_SCREEN
        r""" Variable presets editor screen"""
        self.VSP_VEH_NOTES_SCREEN = _vsp.VSP_VEH_NOTES_SCREEN
        r""" Vehicle notes screen"""
        self.VSP_VEH_SCREEN = _vsp.VSP_VEH_SCREEN
        r""" Veh geom screen"""
        self.VSP_VIEW_SCREEN = _vsp.VSP_VIEW_SCREEN
        r""" Adjust viewpoint screen"""
        self.VSP_VSPAERO_PLOT_SCREEN = _vsp.VSP_VSPAERO_PLOT_SCREEN
        r""" VSPAERO results manager screen"""
        self.VSP_VSPAERO_SCREEN = _vsp.VSP_VSPAERO_SCREEN
        r""" VSPAERO screen"""
        self.VSP_XSEC_SCREEN = _vsp.VSP_XSEC_SCREEN
        r""" XSec screen"""
        self.VSP_WAVEDRAG_SCREEN = _vsp.VSP_WAVEDRAG_SCREEN
        r""" Wave drag screen"""
        self.VSP_MAIN_SCREEN = _vsp.VSP_MAIN_SCREEN
        r""" Main screen"""
        self.VSP_NUM_SCREENS = _vsp.VSP_NUM_SCREENS
        r""" Number of screens"""
        self.VSP_ALL_SCREENS = _vsp.VSP_ALL_SCREENS
        r""" Flag for all screens"""
        self.EDIT_XSEC_CIRCLE = _vsp.EDIT_XSEC_CIRCLE
        r""" Circle initialized as cubic Bezier type"""
        self.EDIT_XSEC_ELLIPSE = _vsp.EDIT_XSEC_ELLIPSE
        r""" Ellipse initialized as PCHIP type"""
        self.EDIT_XSEC_RECTANGLE = _vsp.EDIT_XSEC_RECTANGLE
        r""" Rectangle initialized as linear type"""
        self.IMPORT_STL = _vsp.IMPORT_STL
        r""" Stereolith (*.stl) import"""
        self.IMPORT_NASCART = _vsp.IMPORT_NASCART
        r""" NASCART (*.dat) import"""
        self.IMPORT_CART3D_TRI = _vsp.IMPORT_CART3D_TRI
        r""" Cart3D (*.try) import"""
        self.IMPORT_XSEC_MESH = _vsp.IMPORT_XSEC_MESH
        r""" XSec as Tri Mesh (*.hrm) import"""
        self.IMPORT_PTS = _vsp.IMPORT_PTS
        r""" Point Cloud (*.pts) import"""
        self.IMPORT_V2 = _vsp.IMPORT_V2
        r""" OpenVSP v2 (*.vsp) import"""
        self.IMPORT_BEM = _vsp.IMPORT_BEM
        r""" Blade Element (*.bem) import"""
        self.IMPORT_XSEC_WIRE = _vsp.IMPORT_XSEC_WIRE
        r""" XSec as Wireframe (*.hrm) import"""
        self.IMPORT_P3D_WIRE = _vsp.IMPORT_P3D_WIRE
        r""" Plot3D as Wireframe (*.p3d) import"""
        self.INTERSECT_SRF_FILE_NAME = _vsp.INTERSECT_SRF_FILE_NAME
        r""" SRF intersection file type"""
        self.INTERSECT_CURV_FILE_NAME = _vsp.INTERSECT_CURV_FILE_NAME
        r""" CURV intersection file type"""
        self.INTERSECT_PLOT3D_FILE_NAME = _vsp.INTERSECT_PLOT3D_FILE_NAME
        r""" PLOT3D intersection file type"""
        self.INTERSECT_IGES_FILE_NAME = _vsp.INTERSECT_IGES_FILE_NAME
        r""" IGES intersection file type"""
        self.INTERSECT_STEP_FILE_NAME = _vsp.INTERSECT_STEP_FILE_NAME
        r""" STEP intersection file type"""
        self.INTERSECT_NUM_FILE_NAMES = _vsp.INTERSECT_NUM_FILE_NAMES
        r""" Number of surface intersection file types"""
        self.LEN_MM = _vsp.LEN_MM
        r""" Millimeter"""
        self.LEN_CM = _vsp.LEN_CM
        r""" Centimeter"""
        self.LEN_M = _vsp.LEN_M
        r""" Meter"""
        self.LEN_IN = _vsp.LEN_IN
        r""" Inch"""
        self.LEN_FT = _vsp.LEN_FT
        r""" Feet"""
        self.LEN_YD = _vsp.LEN_YD
        r""" Yard"""
        self.LEN_UNITLESS = _vsp.LEN_UNITLESS
        r""" Unitless"""
        self.NUM_LEN_UNIT = _vsp.NUM_LEN_UNIT
        r""" Number of length unit types"""
        self.MASS_UNIT_G = _vsp.MASS_UNIT_G
        r""" Gram"""
        self.MASS_UNIT_KG = _vsp.MASS_UNIT_KG
        r""" Kilogram"""
        self.MASS_UNIT_TONNE = _vsp.MASS_UNIT_TONNE
        r""" Tonne"""
        self.MASS_UNIT_LBM = _vsp.MASS_UNIT_LBM
        r""" Pound-mass"""
        self.MASS_UNIT_SLUG = _vsp.MASS_UNIT_SLUG
        r""" Slug"""
        self.MASS_LBFSEC2IN = _vsp.MASS_LBFSEC2IN
        r""" lbf*sec^2/in"""
        self.NUM_MASS_UNIT = _vsp.NUM_MASS_UNIT
        r""" Number of mass unit types"""
        self.NO_REASON = _vsp.NO_REASON
        r""" No reason determined."""
        self.MAX_LEN_CONSTRAINT = _vsp.MAX_LEN_CONSTRAINT
        r""" Maximum edge length."""
        self.CURV_GAP = _vsp.CURV_GAP
        r""" Maximum gap curvature based criteria."""
        self.CURV_NCIRCSEG = _vsp.CURV_NCIRCSEG
        r""" Minimum number of segments to define a circle curvature based criteria."""
        self.SOURCES = _vsp.SOURCES
        r""" Mesh sources."""
        self.MIN_LEN_CONSTRAINT = _vsp.MIN_LEN_CONSTRAINT
        r""" Minimum edge length."""
        self.MIN_LEN_CONSTRAINT_CURV_GAP = _vsp.MIN_LEN_CONSTRAINT_CURV_GAP
        r""" Maximum gap constrained by minimum length."""
        self.MIN_LEN_CONSTRAINT_CURV_NCIRCSEG = _vsp.MIN_LEN_CONSTRAINT_CURV_NCIRCSEG
        r""" Number of segments to define a circle constrained by minimum length."""
        self.MIN_LEN_CONSTRAINT_SOURCES = _vsp.MIN_LEN_CONSTRAINT_SOURCES
        r""" Mesh sources constrained by minimum length (not applied)."""
        self.GROW_LIMIT_MAX_LEN_CONSTRAINT = _vsp.GROW_LIMIT_MAX_LEN_CONSTRAINT
        r""" Maximum growth limit from maximum edge length (not used, growth limited small to large)."""
        self.GROW_LIMIT_CURV_GAP = _vsp.GROW_LIMIT_CURV_GAP
        r""" Maximum growth limit from maximum gap."""
        self.GROW_LIMIT_CURV_NCIRCSEG = _vsp.GROW_LIMIT_CURV_NCIRCSEG
        r""" Maximum growth limit from number of segments to define a circle."""
        self.GROW_LIMIT_SOURCES = _vsp.GROW_LIMIT_SOURCES
        r""" Maximum growth limit from mesh sources."""
        self.GROW_LIMIT_MIN_LEN_CONSTRAINT = _vsp.GROW_LIMIT_MIN_LEN_CONSTRAINT
        r""" Maximum growth limit from minimum length constraint."""
        self.GROW_LIMIT_MIN_LEN_CONSTRAINT_CURV_GAP = _vsp.GROW_LIMIT_MIN_LEN_CONSTRAINT_CURV_GAP
        r""" Maximum growth limit from maximum gap constrained by minimum length."""
        self.GROW_LIMIT_MIN_LEN_CONSTRAINT_CURV_NCIRCSEG = _vsp.GROW_LIMIT_MIN_LEN_CONSTRAINT_CURV_NCIRCSEG
        r""" Maximum growth limit from number of segments to define a circle constrained by minimum length."""
        self.GROW_LIMIT_MIN_LEN_CONSTRAINT_SOURCES = _vsp.GROW_LIMIT_MIN_LEN_CONSTRAINT_SOURCES
        r""" Maximum growth limit from sources constrained by minimum length."""
        self.NUM_MESH_REASON = _vsp.NUM_MESH_REASON
        r""" Number of reasons that can set the mesh local minimum edge length."""
        self.MIN_LEN_INCREMENT = _vsp.MIN_LEN_INCREMENT
        r""" Reason increment when adding minimum length constraint."""
        self.GROW_LIMIT_INCREMENT = _vsp.GROW_LIMIT_INCREMENT
        r""" Reason increment when adding growth limit constraint."""
        self.MIN_GROW_LIMIT = _vsp.MIN_GROW_LIMIT
        r""" Reason marker for minimum reason to apply growth limit."""
        self.ID_LENGTH_PRESET_GROUP = _vsp.ID_LENGTH_PRESET_GROUP
        r""" ID for Var Preset Groups are length 5"""
        self.ID_LENGTH_PRESET_SETTING = _vsp.ID_LENGTH_PRESET_SETTING
        r""" ID for Var Preset Settings are length 6"""
        self.ID_LENGTH_ATTR = _vsp.ID_LENGTH_ATTR
        r""" ID for Attributes are length 8"""
        self.ID_LENGTH_ATTRCOLL = _vsp.ID_LENGTH_ATTRCOLL
        r""" ID for Attribute Collections are length 9"""
        self.ID_LENGTH_PARMCONTAINER = _vsp.ID_LENGTH_PARMCONTAINER
        r""" ID for Parm Containers are length 10"""
        self.ID_LENGTH_PARM = _vsp.ID_LENGTH_PARM
        r""" ID for Parms are length 11"""
        self.PARM_DOUBLE_TYPE = _vsp.PARM_DOUBLE_TYPE
        r""" Double Parm type (Parm)"""
        self.PARM_INT_TYPE = _vsp.PARM_INT_TYPE
        r""" Integer Parm type (IntParm)"""
        self.PARM_BOOL_TYPE = _vsp.PARM_BOOL_TYPE
        r""" Bool Parm type (BoolParm)"""
        self.PARM_FRACTION_TYPE = _vsp.PARM_FRACTION_TYPE
        r""" Fraction Parm type (FractionParm)"""
        self.PARM_LIMITED_INT_TYPE = _vsp.PARM_LIMITED_INT_TYPE
        r""" Limited integer Parm type (LimIntParm)"""
        self.PARM_NOTEQ_TYPE = _vsp.PARM_NOTEQ_TYPE
        r""" Not equal Parm type (NotEqParm)"""
        self.PARM_POWER_INT_TYPE = _vsp.PARM_POWER_INT_TYPE
        r""" Power integer Parm type (PowIntParm)"""
        self.PATCH_NONE = _vsp.PATCH_NONE
        r""" No patch"""
        self.PATCH_POINT = _vsp.PATCH_POINT
        r""" Point patch type"""
        self.PATCH_LINE = _vsp.PATCH_LINE
        r""" Line patch type"""
        self.PATCH_COPY = _vsp.PATCH_COPY
        r""" Copy patch type"""
        self.PATCH_HALFWAY = _vsp.PATCH_HALFWAY
        r""" Halfway patch type"""
        self.PATCH_NUM_TYPES = _vsp.PATCH_NUM_TYPES
        r""" Number of patch types"""
        self.LINEAR = _vsp.LINEAR
        r""" Linear curve type"""
        self.PCHIP = _vsp.PCHIP
        r""" Piecewise Cubic Hermite Interpolating Polynomial curve type"""
        self.CEDIT = _vsp.CEDIT
        r""" Cubic Bezier curve type"""
        self.APPROX_CEDIT = _vsp.APPROX_CEDIT
        r""" Approximate curve as Cubic Bezier"""
        self.NUM_PCURV_TYPE = _vsp.NUM_PCURV_TYPE
        r""" Number of curve types"""
        self.PRES_UNIT_PSF = _vsp.PRES_UNIT_PSF
        r""" Pounds per square foot"""
        self.PRES_UNIT_PSI = _vsp.PRES_UNIT_PSI
        r""" Pounds per square inch"""
        self.PRES_UNIT_BA = _vsp.PRES_UNIT_BA
        r""" Barye"""
        self.PRES_UNIT_PA = _vsp.PRES_UNIT_PA
        r""" Pascal"""
        self.PRES_UNIT_KPA = _vsp.PRES_UNIT_KPA
        r""" Kilopascal"""
        self.PRES_UNIT_MPA = _vsp.PRES_UNIT_MPA
        r""" Megapascal"""
        self.PRES_UNIT_INCHHG = _vsp.PRES_UNIT_INCHHG
        r""" Inch of mercury"""
        self.PRES_UNIT_MMHG = _vsp.PRES_UNIT_MMHG
        r""" Millimeter of mercury"""
        self.PRES_UNIT_MMH20 = _vsp.PRES_UNIT_MMH20
        r""" Millimeter of water"""
        self.PRES_UNIT_MB = _vsp.PRES_UNIT_MB
        r""" Millibar"""
        self.PRES_UNIT_ATM = _vsp.PRES_UNIT_ATM
        r""" Atmosphere"""
        self.NUM_PRES_UNIT = _vsp.NUM_PRES_UNIT
        r""" Number of pressure unit choices"""
        self.NO_BOUNDARY = _vsp.NO_BOUNDARY
        r""" No boundary"""
        self.SET_BOUNDARY = _vsp.SET_BOUNDARY
        r""" Set boundary"""
        self.GEOM_BOUNDARY = _vsp.GEOM_BOUNDARY
        r""" Geom boundary"""
        self.NUM_PROJ_BNDY_OPTIONS = _vsp.NUM_PROJ_BNDY_OPTIONS
        r""" Number of projected area boundary options"""
        self.X_PROJ = _vsp.X_PROJ
        r""" Project in X axis direction"""
        self.Y_PROJ = _vsp.Y_PROJ
        r""" Project in Y axis direction"""
        self.Z_PROJ = _vsp.Z_PROJ
        r""" Project in Z axis direction"""
        self.GEOM_PROJ = _vsp.GEOM_PROJ
        r""" Project toward a Geom"""
        self.VEC_PROJ = _vsp.VEC_PROJ
        r""" Project along a 3D vector"""
        self.NUM_PROJ_DIR_OPTIONS = _vsp.NUM_PROJ_DIR_OPTIONS
        r""" Number of Projected Area direction types"""
        self.SET_TARGET = _vsp.SET_TARGET
        r""" Set target type"""
        self.GEOM_TARGET = _vsp.GEOM_TARGET
        r""" Geom target type"""
        self.MODE_TARGET = _vsp.MODE_TARGET
        r""" Mode target type"""
        self.NUM_PROJ_TGT_OPTIONS = _vsp.NUM_PROJ_TGT_OPTIONS
        r""" Number of Projected Area target types"""
        self.PROP_AZI_UNIFORM = _vsp.PROP_AZI_UNIFORM
        r""" Propeller blades are uniformly spaced"""
        self.PROP_AZI_FREE = _vsp.PROP_AZI_FREE
        r""" Propeller blades are free to spaced arbitrarially"""
        self.PROP_AZI_BALANCED = _vsp.PROP_AZI_BALANCED
        r""" Propeller blade balance is enforced"""
        self.NUM_PROP_AZI = _vsp.NUM_PROP_AZI
        r""" Number of propeller blade azimuth modes"""
        self.PROP_BLADES = _vsp.PROP_BLADES
        r""" Propeller Geom is defined by individual propeller blades"""
        self.PROP_BOTH = _vsp.PROP_BOTH
        r""" Propeller Geom is defined by blades and a disk together"""
        self.PROP_DISK = _vsp.PROP_DISK
        r""" Propeller Geom is defined by a flat circular disk"""
        self.PROP_CHORD = _vsp.PROP_CHORD
        r""" Chord parameterization"""
        self.PROP_TWIST = _vsp.PROP_TWIST
        r""" Twist parameterization"""
        self.PROP_RAKE = _vsp.PROP_RAKE
        r""" Rake parameterization"""
        self.PROP_SKEW = _vsp.PROP_SKEW
        r""" Skew parameterization"""
        self.PROP_SWEEP = _vsp.PROP_SWEEP
        r""" Sweep parameterization"""
        self.PROP_THICK = _vsp.PROP_THICK
        r""" Thickness parameterization"""
        self.PROP_CLI = _vsp.PROP_CLI
        r""" Induced lift coefficient parameterization"""
        self.PROP_AXIAL = _vsp.PROP_AXIAL
        r""" Axial parameterization"""
        self.PROP_TANGENTIAL = _vsp.PROP_TANGENTIAL
        r""" Tangential parameterization"""
        self.NUM_PROP_PCURVE = _vsp.NUM_PROP_PCURVE
        r""" Number of propeller blade curve parameterization options"""
        self.REORDER_MOVE_UP = _vsp.REORDER_MOVE_UP
        r""" Move up one position"""
        self.REORDER_MOVE_DOWN = _vsp.REORDER_MOVE_DOWN
        r""" Move down one position"""
        self.REORDER_MOVE_TOP = _vsp.REORDER_MOVE_TOP
        r""" Move to top"""
        self.REORDER_MOVE_BOTTOM = _vsp.REORDER_MOVE_BOTTOM
        r""" Move to bottom"""
        self.NUM_REORDER_TYPES = _vsp.NUM_REORDER_TYPES
        r""" Number reordering instructions"""
        self.MANUAL_REF = _vsp.MANUAL_REF
        r""" Manually specify the reference areas and lengths"""
        self.COMPONENT_REF = _vsp.COMPONENT_REF
        r""" Use a particular wing to calculate the reference area and lengths"""
        self.NUM_REF_TYPES = _vsp.NUM_REF_TYPES
        r""" Number of wing reference types"""
        self.INVALID_TYPE = _vsp.INVALID_TYPE
        r""" Invalid data type"""
        self.BOOL_DATA = _vsp.BOOL_DATA
        r""" Bool data type"""
        self.INT_DATA = _vsp.INT_DATA
        r""" Integer data type"""
        self.DOUBLE_DATA = _vsp.DOUBLE_DATA
        r""" Double data type"""
        self.STRING_DATA = _vsp.STRING_DATA
        r""" String data type"""
        self.VEC3D_DATA = _vsp.VEC3D_DATA
        r""" Vec3d data type"""
        self.INT_MATRIX_DATA = _vsp.INT_MATRIX_DATA
        r""" Int matrix data type"""
        self.DOUBLE_MATRIX_DATA = _vsp.DOUBLE_MATRIX_DATA
        r""" Double matrix data type"""
        self.NAMEVAL_COLLECTION_DATA = _vsp.NAMEVAL_COLLECTION_DATA
        r""" NameVal collection data type"""
        self.ATTR_COLLECTION_DATA = _vsp.ATTR_COLLECTION_DATA
        r""" Attribute collection data type"""
        self.PARM_REFERENCE_DATA = _vsp.PARM_REFERENCE_DATA
        r""" Parm reference data type"""
        self.MESH_INDEXED_TRI = _vsp.MESH_INDEXED_TRI
        r""" Indexed triangulated mesh Geom type"""
        self.MESH_SLICE_TRI = _vsp.MESH_SLICE_TRI
        r""" Sliced Triangulated mesh Geom type"""
        self.GEOM_XSECS = _vsp.GEOM_XSECS
        r""" GeomXSec Geom type"""
        self.MESH_INDEX_AND_SLICE_TRI = _vsp.MESH_INDEX_AND_SLICE_TRI
        r""" Both indexed and sliced triangulated mesh Geom type"""
        self.RHO_UNIT_SLUG_FT3 = _vsp.RHO_UNIT_SLUG_FT3
        r""" Slug per cubic foot"""
        self.RHO_UNIT_G_CM3 = _vsp.RHO_UNIT_G_CM3
        r""" Gram per cubic centimeter"""
        self.RHO_UNIT_KG_M3 = _vsp.RHO_UNIT_KG_M3
        r""" Kilogram per cubic meter"""
        self.RHO_UNIT_TONNE_MM3 = _vsp.RHO_UNIT_TONNE_MM3
        r""" Tonne per cubic millimeter"""
        self.RHO_UNIT_LBM_FT3 = _vsp.RHO_UNIT_LBM_FT3
        r""" Pound-mass per cubic foot"""
        self.RHO_UNIT_LBFSEC2_IN4 = _vsp.RHO_UNIT_LBFSEC2_IN4
        r""" Pound-force-second squared per inch to the fourth"""
        self.RHO_UNIT_LBM_IN3 = _vsp.RHO_UNIT_LBM_IN3
        r""" Pound-mass per cubic inch"""
        self.NUM_RHO_UNIT = _vsp.NUM_RHO_UNIT
        r""" Number of density unit options"""
        self.SCALE_WIDTH = _vsp.SCALE_WIDTH
        r""" Scale image to match desired width"""
        self.SCALE_HEIGHT = _vsp.SCALE_HEIGHT
        r""" Scale image to match desired height"""
        self.SCALE_WIDTH_HEIGHT = _vsp.SCALE_WIDTH_HEIGHT
        r""" Scale image to match desired width and height"""
        self.SCALE_RESOLUTION = _vsp.SCALE_RESOLUTION
        r""" Scale image to specified resolution"""
        self.NUM_SCALE_TYPES = _vsp.NUM_SCALE_TYPES
        r""" Number of ways to scale 3D background image."""
        self.SET_NONE = _vsp.SET_NONE
        r""" None set"""
        self.SET_ALL = _vsp.SET_ALL
        r""" All set"""
        self.SET_SHOWN = _vsp.SET_SHOWN
        r""" Shown set"""
        self.SET_NOT_SHOWN = _vsp.SET_NOT_SHOWN
        r""" Not shown set"""
        self.SET_FIRST_USER = _vsp.SET_FIRST_USER
        r""" First user-defined set"""
        self.MIN_NUM_USER = _vsp.MIN_NUM_USER
        r""" Minimum number of user sets"""
        self.MAX_NUM_SETS = _vsp.MAX_NUM_SETS
        r""" Maximum possible number of sets"""
        self.STEP_SHELL = _vsp.STEP_SHELL
        r""" Manifold shell surface STEP file representation"""
        self.STEP_BREP = _vsp.STEP_BREP
        r""" Manifold solid BREP STEP file representation"""
        self.SS_INC_TREAT_AS_PARENT = _vsp.SS_INC_TREAT_AS_PARENT
        r""" Treat the sub-surface the same as the parent"""
        self.SS_INC_SEPARATE_TREATMENT = _vsp.SS_INC_SEPARATE_TREATMENT
        r""" Treat the sub-surface separately from the parent"""
        self.SS_INC_ZERO_DRAG = _vsp.SS_INC_ZERO_DRAG
        r""" No drag contribution for the sub-surface"""
        self.INSIDE = _vsp.INSIDE
        r""" The interior of the sub-surface is its surface"""
        self.OUTSIDE = _vsp.OUTSIDE
        r""" The exterior of the sub-surface is its surface"""
        self.NONE = _vsp.NONE
        r""" No part of the parent surface belongs to the sub-surface"""
        self.CONST_U = _vsp.CONST_U
        r""" Constant U sub-surface"""
        self.CONST_W = _vsp.CONST_W
        r""" Constant W sub-surface"""
        self.SS_LINE = _vsp.SS_LINE
        r""" Line sub-surface type"""
        self.SS_RECTANGLE = _vsp.SS_RECTANGLE
        r""" Rectangle sub-surface type"""
        self.SS_ELLIPSE = _vsp.SS_ELLIPSE
        r""" Ellipse sub-surface type"""
        self.SS_CONTROL = _vsp.SS_CONTROL
        r""" Control sub-surface type"""
        self.SS_LINE_ARRAY = _vsp.SS_LINE_ARRAY
        r""" Line array sub-surface type"""
        self.SS_FINITE_LINE = _vsp.SS_FINITE_LINE
        r""" Finite line sub-surface type"""
        self.SS_NUM_TYPES = _vsp.SS_NUM_TYPES
        r""" Number of sub-surface types"""
        self.SYM_XY = _vsp.SYM_XY
        r""" XY planar symmetry."""
        self.SYM_XZ = _vsp.SYM_XZ
        r""" XZ planar symmetry."""
        self.SYM_YZ = _vsp.SYM_YZ
        r""" YZ planar symmetry."""
        self.SYM_ROT_X = _vsp.SYM_ROT_X
        r""" X rotational symmetry."""
        self.SYM_ROT_Y = _vsp.SYM_ROT_Y
        r""" Y rotational symmetry."""
        self.SYM_ROT_Z = _vsp.SYM_ROT_Z
        r""" Z rotational symmetry."""
        self.SYM_PLANAR_TYPES = _vsp.SYM_PLANAR_TYPES
        r""" Number of planar symmetry types."""
        self.SYM_NUM_TYPES = _vsp.SYM_NUM_TYPES
        r""" Number of symmetry types."""
        self.SYM_NONE = _vsp.SYM_NONE
        r""" No cross section symmetry."""
        self.SYM_RL = _vsp.SYM_RL
        r""" Right/left cross section symmetry."""
        self.SYM_TB = _vsp.SYM_TB
        r""" Top/bottom cross section symmetry."""
        self.SYM_ALL = _vsp.SYM_ALL
        r""" All cross section symmetry."""
        self.TEMP_UNIT_K = _vsp.TEMP_UNIT_K
        r""" Kelvin"""
        self.TEMP_UNIT_C = _vsp.TEMP_UNIT_C
        r""" Celsius"""
        self.TEMP_UNIT_F = _vsp.TEMP_UNIT_F
        r""" Fahrenheit"""
        self.TEMP_UNIT_R = _vsp.TEMP_UNIT_R
        r""" Rankine"""
        self.NUM_TEMP_UNIT = _vsp.NUM_TEMP_UNIT
        r""" Number of temperature unit choices"""
        self.V_UNIT_FT_S = _vsp.V_UNIT_FT_S
        r""" Feet per second"""
        self.V_UNIT_M_S = _vsp.V_UNIT_M_S
        r""" Meter per second"""
        self.V_UNIT_MPH = _vsp.V_UNIT_MPH
        r""" Mile per hour"""
        self.V_UNIT_KM_HR = _vsp.V_UNIT_KM_HR
        r""" Kilometer per hour"""
        self.V_UNIT_KEAS = _vsp.V_UNIT_KEAS
        r""" Knots equivalent airspeed"""
        self.V_UNIT_KTAS = _vsp.V_UNIT_KTAS
        r""" Knots true airspeed"""
        self.V_UNIT_MACH = _vsp.V_UNIT_MACH
        r""" Mach"""
        self.VIEW_1 = _vsp.VIEW_1
        r""" One 2D view"""
        self.VIEW_2HOR = _vsp.VIEW_2HOR
        r""" Two horizontal 2D views"""
        self.VIEW_2VER = _vsp.VIEW_2VER
        r""" Two vertical 2D views"""
        self.VIEW_4 = _vsp.VIEW_4
        r""" Four 2D views"""
        self.ROT_0 = _vsp.ROT_0
        r""" No rotation"""
        self.ROT_90 = _vsp.ROT_90
        r""" 90 degree rotation"""
        self.ROT_180 = _vsp.ROT_180
        r""" 180 degree rotation"""
        self.ROT_270 = _vsp.ROT_270
        r""" 270 degree rotation"""
        self.VIEW_LEFT = _vsp.VIEW_LEFT
        r""" Left 2D view type"""
        self.VIEW_RIGHT = _vsp.VIEW_RIGHT
        r""" Right 2D view type"""
        self.VIEW_TOP = _vsp.VIEW_TOP
        r""" Top 2D view type"""
        self.VIEW_BOTTOM = _vsp.VIEW_BOTTOM
        r""" Bottom 2D view type"""
        self.VIEW_FRONT = _vsp.VIEW_FRONT
        r""" Front 2D view type"""
        self.VIEW_REAR = _vsp.VIEW_REAR
        r""" Rear 2D view type"""
        self.VIEW_NONE = _vsp.VIEW_NONE
        r""" No 2D view type"""
        self.VIEW_NUM_TYPES = _vsp.VIEW_NUM_TYPES
        r""" Number of 2D view types"""
        self.VORTEX_LATTICE = _vsp.VORTEX_LATTICE
        r""" VSPAERO vortex lattice method"""
        self.PANEL = _vsp.PANEL
        r""" VSPAERO panel method"""
        self.NOISE_FLYBY = _vsp.NOISE_FLYBY
        r""" Set up fly by noise analysis in VSPAERO for PSU-WOPWOP"""
        self.NOISE_FOOTPRINT = _vsp.NOISE_FOOTPRINT
        r""" Set up footprint noise analysis in VSPAERO for PSU-WOPWOP"""
        self.NOISE_STEADY = _vsp.NOISE_STEADY
        r""" Set up steady state noise analysis in VSPAERO for PSU-WOPWOP"""
        self.NOISE_SI = _vsp.NOISE_SI
        r""" Assume geometry and VSPAERO inputs in SI (m N kg s) for PSU-WOPWOP"""
        self.NOISE_ENGLISH = _vsp.NOISE_ENGLISH
        r""" Assume geometry and VSPAERO inputs in english (ft lbf slug s) units, will convert to SI (m N kg s) for PSU-WOPWOP"""
        self.PRECON_MATRIX = _vsp.PRECON_MATRIX
        r""" Matrix preconditioner"""
        self.PRECON_JACOBI = _vsp.PRECON_JACOBI
        r""" Jacobi preconditioner"""
        self.PRECON_SSOR = _vsp.PRECON_SSOR
        r""" Symmetric successive over-relaxation preconditioner"""
        self.STABILITY_OFF = _vsp.STABILITY_OFF
        r""" No stability analysis (off)"""
        self.STABILITY_DEFAULT = _vsp.STABILITY_DEFAULT
        r""" Steady 6DOF stability analysis"""
        self.STABILITY_P_ANALYSIS = _vsp.STABILITY_P_ANALYSIS
        r""" Unsteady roll stability analysis"""
        self.STABILITY_Q_ANALYSIS = _vsp.STABILITY_Q_ANALYSIS
        r""" Unsteady pitch stability analysis"""
        self.STABILITY_R_ANALYSIS = _vsp.STABILITY_R_ANALYSIS
        r""" Unsteady yaw stability analysis"""
        self.STABILITY_PITCH = _vsp.STABILITY_PITCH
        r""" Simplified pitch stability analysis"""
        self.STABILITY_NUM_TYPES = _vsp.STABILITY_NUM_TYPES
        r""" Number of stability analysis types"""
        self.CLMAX_OFF = _vsp.CLMAX_OFF
        r""" Stall modeling off (Cl Max = 0)"""
        self.CLMAX_2D = _vsp.CLMAX_2D
        r""" 2D Cl Max stall modeling with user defined value"""
        self.CLMAX_CARLSON = _vsp.CLMAX_CARLSON
        r""" Carlson's Pressure Correlation"""
        self.CFD_NORMAL = _vsp.CFD_NORMAL
        r""" Normal CFD Mesh surface"""
        self.CFD_NEGATIVE = _vsp.CFD_NEGATIVE
        r""" Negative volume CFD Mesh surface"""
        self.CFD_TRANSPARENT = _vsp.CFD_TRANSPARENT
        r""" Transparent CFD Mesh surface"""
        self.CFD_STRUCTURE = _vsp.CFD_STRUCTURE
        r""" FEA structure CFD Mesh surface"""
        self.CFD_STIFFENER = _vsp.CFD_STIFFENER
        r""" FEA stiffener CFD Mesh surface"""
        self.CFD_MEASURE_DUCT = _vsp.CFD_MEASURE_DUCT
        r""" Measure duct cross sectional area surface"""
        self.CFD_NUM_TYPES = _vsp.CFD_NUM_TYPES
        r""" Number of CFD Mesh surface types"""
        self.NORMAL_SURF = _vsp.NORMAL_SURF
        r""" Normal VSP surface"""
        self.WING_SURF = _vsp.WING_SURF
        r""" Wing VSP surface"""
        self.DISK_SURF = _vsp.DISK_SURF
        r""" Disk VSP surface"""
        self.NUM_SURF_TYPES = _vsp.NUM_SURF_TYPES
        r""" Number of VSP surface types"""
        self.W_RIGHT_0 = _vsp.W_RIGHT_0
        r""" Chevron start/ends at right (W = 0) of cross section"""
        self.W_BOTTOM = _vsp.W_BOTTOM
        r""" Chevron start/ends at bottom of cross section"""
        self.W_LEFT = _vsp.W_LEFT
        r""" Chevron start/ends at left of cross section"""
        self.W_TOP = _vsp.W_TOP
        r""" Chevron start/ends at top of cross section"""
        self.W_RIGHT_1 = _vsp.W_RIGHT_1
        r""" Chevron start/ends at right (W = 1) of cross section"""
        self.W_FREE = _vsp.W_FREE
        r""" Chevron start/ends at user specified point on cross section"""
        self.BLEND_FREE = _vsp.BLEND_FREE
        r""" Free blending"""
        self.BLEND_ANGLES = _vsp.BLEND_ANGLES
        r""" Blend based on angles (sweep & dihedral)"""
        self.BLEND_MATCH_IN_LE_TRAP = _vsp.BLEND_MATCH_IN_LE_TRAP
        r""" Match inboard leading edge trapezoid"""
        self.BLEND_MATCH_IN_TE_TRAP = _vsp.BLEND_MATCH_IN_TE_TRAP
        r""" Match inboard trailing edge trapezoid"""
        self.BLEND_MATCH_OUT_LE_TRAP = _vsp.BLEND_MATCH_OUT_LE_TRAP
        r""" Match outboard leading edge trapezoid"""
        self.BLEND_MATCH_OUT_TE_TRAP = _vsp.BLEND_MATCH_OUT_TE_TRAP
        r""" Match outboard trailing edge trapezoid"""
        self.BLEND_MATCH_IN_ANGLES = _vsp.BLEND_MATCH_IN_ANGLES
        r""" Match inboard angles"""
        self.BLEND_MATCH_LE_ANGLES = _vsp.BLEND_MATCH_LE_ANGLES
        r""" Match leading edge angles"""
        self.BLEND_NUM_TYPES = _vsp.BLEND_NUM_TYPES
        r""" Number of blending types"""
        self.AR_WSECT_DRIVER = _vsp.AR_WSECT_DRIVER
        r""" Aspect ratio driver"""
        self.SPAN_WSECT_DRIVER = _vsp.SPAN_WSECT_DRIVER
        r""" Span driver"""
        self.AREA_WSECT_DRIVER = _vsp.AREA_WSECT_DRIVER
        r""" Area driver"""
        self.TAPER_WSECT_DRIVER = _vsp.TAPER_WSECT_DRIVER
        r""" Taper driver"""
        self.AVEC_WSECT_DRIVER = _vsp.AVEC_WSECT_DRIVER
        r""" Average chord driver"""
        self.ROOTC_WSECT_DRIVER = _vsp.ROOTC_WSECT_DRIVER
        r""" Root chord driver"""
        self.TIPC_WSECT_DRIVER = _vsp.TIPC_WSECT_DRIVER
        r""" Tip chord driver"""
        self.SECSWEEP_WSECT_DRIVER = _vsp.SECSWEEP_WSECT_DRIVER
        r""" Section sweep driver"""
        self.NUM_WSECT_DRIVER = _vsp.NUM_WSECT_DRIVER
        r""" Number of wing section drivers"""
        self.SWEEP_WSECT_DRIVER = _vsp.SWEEP_WSECT_DRIVER
        self.SWEEPLOC_WSECT_DRIVER = _vsp.SWEEPLOC_WSECT_DRIVER
        self.SECSWEEPLOC_WSECT_DRIVER = _vsp.SECSWEEPLOC_WSECT_DRIVER
        self.XDDM_VAR = _vsp.XDDM_VAR
        r""" Variable XDDM type"""
        self.XDDM_CONST = _vsp.XDDM_CONST
        r""" Constant XDDM type"""
        self.CLOSE_NONE = _vsp.CLOSE_NONE
        r""" No closure"""
        self.CLOSE_SKEWLOW = _vsp.CLOSE_SKEWLOW
        r""" Skew lower closure"""
        self.CLOSE_SKEWUP = _vsp.CLOSE_SKEWUP
        r""" Skew upper closure"""
        self.CLOSE_SKEWBOTH = _vsp.CLOSE_SKEWBOTH
        r""" Skew both closure"""
        self.CLOSE_EXTRAP = _vsp.CLOSE_EXTRAP
        r""" Extrapolate closure"""
        self.CLOSE_NUM_TYPES = _vsp.CLOSE_NUM_TYPES
        r""" Number of XSec closure types"""
        self.XS_UNDEFINED = _vsp.XS_UNDEFINED
        self.XS_POINT = _vsp.XS_POINT
        r""" Point XSec"""
        self.XS_CIRCLE = _vsp.XS_CIRCLE
        r""" Circle XSec"""
        self.XS_ELLIPSE = _vsp.XS_ELLIPSE
        r""" Ellipse XSec"""
        self.XS_SUPER_ELLIPSE = _vsp.XS_SUPER_ELLIPSE
        r""" Super ellipse XSec"""
        self.XS_ROUNDED_RECTANGLE = _vsp.XS_ROUNDED_RECTANGLE
        r""" Rounded rectangle XSec"""
        self.XS_GENERAL_FUSE = _vsp.XS_GENERAL_FUSE
        r""" General fuselage XSec"""
        self.XS_FILE_FUSE = _vsp.XS_FILE_FUSE
        r""" Fuselage file XSec"""
        self.XS_FOUR_SERIES = _vsp.XS_FOUR_SERIES
        r""" Four series XSec"""
        self.XS_SIX_SERIES = _vsp.XS_SIX_SERIES
        r""" Six series XSec"""
        self.XS_BICONVEX = _vsp.XS_BICONVEX
        r""" Biconvex XSec"""
        self.XS_WEDGE = _vsp.XS_WEDGE
        r""" Wedge XSec"""
        self.XS_EDIT_CURVE = _vsp.XS_EDIT_CURVE
        r""" Generic Edit Curve XSec"""
        self.XS_FILE_AIRFOIL = _vsp.XS_FILE_AIRFOIL
        r""" Airfoil file XSec"""
        self.XS_CST_AIRFOIL = _vsp.XS_CST_AIRFOIL
        r""" CST airfoil XSec"""
        self.XS_VKT_AIRFOIL = _vsp.XS_VKT_AIRFOIL
        r""" VKT airfoil XSec"""
        self.XS_FOUR_DIGIT_MOD = _vsp.XS_FOUR_DIGIT_MOD
        r""" Four digit modified XSec"""
        self.XS_FIVE_DIGIT = _vsp.XS_FIVE_DIGIT
        r""" Five digit XSec"""
        self.XS_FIVE_DIGIT_MOD = _vsp.XS_FIVE_DIGIT_MOD
        r""" Five digit modified XSec"""
        self.XS_ONE_SIX_SERIES = _vsp.XS_ONE_SIX_SERIES
        r""" One six series XSec"""
        self.XS_NUM_TYPES = _vsp.XS_NUM_TYPES
        r""" Number of XSec types"""
        self.WIDTH_XSEC_DRIVER = _vsp.WIDTH_XSEC_DRIVER
        self.AREA_XSEC_DRIVER = _vsp.AREA_XSEC_DRIVER
        self.HEIGHT_XSEC_DRIVER = _vsp.HEIGHT_XSEC_DRIVER
        r""" Height driver"""
        self.HWRATIO_XSEC_DRIVER = _vsp.HWRATIO_XSEC_DRIVER
        r""" Height/width ratio driver"""
        self.NUM_XSEC_DRIVER = _vsp.NUM_XSEC_DRIVER
        r""" Number of XSec drivers"""
        self.CIRCLE_NUM_XSEC_DRIVER = _vsp.CIRCLE_NUM_XSEC_DRIVER
        self.XSEC_BOTH_SIDES = _vsp.XSEC_BOTH_SIDES
        r""" Both sides"""
        self.XSEC_LEFT_SIDE = _vsp.XSEC_LEFT_SIDE
        r""" Left side"""
        self.XSEC_RIGHT_SIDE = _vsp.XSEC_RIGHT_SIDE
        r""" Right side"""
        self.TRIM_NONE = _vsp.TRIM_NONE
        r""" No trimming"""
        self.TRIM_X = _vsp.TRIM_X
        r""" Trim XSec by X"""
        self.TRIM_THICK = _vsp.TRIM_THICK
        r""" Trim XSec by thickness"""
        self.TRIM_NUM_TYPES = _vsp.TRIM_NUM_TYPES
        r""" Number of trimming types"""
        self.XSEC_FUSE = _vsp.XSEC_FUSE
        r""" Fuselage XSec Geom"""
        self.XSEC_STACK = _vsp.XSEC_STACK
        r""" Stack XSec Geom"""
        self.XSEC_WING = _vsp.XSEC_WING
        r""" Wing XSec Geom"""
        self.XSEC_CUSTOM = _vsp.XSEC_CUSTOM
        r""" Custom XSec Geom"""
        self.XSEC_PROP = _vsp.XSEC_PROP
        r""" Propeller XSec Geom"""
        self.XSEC_NUM_TYPES = _vsp.XSEC_NUM_TYPES
        r""" Number of XSec types"""
        self.XS_SHIFT_LE = _vsp.XS_SHIFT_LE
        r""" Shift leading edge"""
        self.XS_SHIFT_MID = _vsp.XS_SHIFT_MID
        self.XS_SHIFT_TE = _vsp.XS_SHIFT_TE
        # Register ErrorObj in _vsp:
        
        # Register ErrorMgrSingleton in _vsp:
        
    @client_wrap
    def ErrorMgrSingleton_getInstance(self, ):
        r"""ErrorMgrSingleton_getInstance() -> ErrorMgrSingleton"""
        return _vsp.ErrorMgrSingleton_getInstance()
    
    
    @client_wrap
    def VSPCheckSetup(self, ):
        r"""VSPCheckSetup()"""
        return _vsp.VSPCheckSetup()
    
    @client_wrap
    def VSPRenew(self, ):
        r"""VSPRenew()"""
        return _vsp.VSPRenew()
    
    @client_wrap
    def Update(self, update_managers=True):
        r"""Update(bool update_managers=True)"""
        return _vsp.Update(update_managers)
    
    @client_wrap
    def VSPExit(self, error_code):
        r"""VSPExit(int error_code)"""
        return _vsp.VSPExit(error_code)
    
    @client_wrap
    def VSPCrash(self, crash_type):
        r"""VSPCrash(int crash_type)"""
        return _vsp.VSPCrash(crash_type)
    
    @client_wrap
    def GetAndResetUpdateCount(self, ):
        r"""GetAndResetUpdateCount() -> int"""
        return _vsp.GetAndResetUpdateCount()
    
    @client_wrap
    def GetVSPVersion(self, ):
        r"""GetVSPVersion() -> std::string"""
        return _vsp.GetVSPVersion()
    
    @client_wrap
    def GetVSPVersionMajor(self, ):
        r"""GetVSPVersionMajor() -> int"""
        return _vsp.GetVSPVersionMajor()
    
    @client_wrap
    def GetVSPVersionMinor(self, ):
        r"""GetVSPVersionMinor() -> int"""
        return _vsp.GetVSPVersionMinor()
    
    @client_wrap
    def GetVSPVersionChange(self, ):
        r"""GetVSPVersionChange() -> int"""
        return _vsp.GetVSPVersionChange()
    
    @client_wrap
    def GetVSPExePath(self, ):
        r"""GetVSPExePath() -> std::string"""
        return _vsp.GetVSPExePath()
    
    @client_wrap
    def SetVSPAEROPath(self, path):
        r"""SetVSPAEROPath(std::string const & path) -> bool"""
        return _vsp.SetVSPAEROPath(path)
    
    @client_wrap
    def GetVSPAEROPath(self, ):
        r"""GetVSPAEROPath() -> std::string"""
        return _vsp.GetVSPAEROPath()
    
    @client_wrap
    def CheckForVSPAERO(self, path):
        r"""CheckForVSPAERO(std::string const & path) -> bool"""
        return _vsp.CheckForVSPAERO(path)
    
    @client_wrap
    def SetVSPHelpPath(self, path):
        r"""SetVSPHelpPath(std::string const & path) -> bool"""
        return _vsp.SetVSPHelpPath(path)
    
    @client_wrap
    def GetVSPHelpPath(self, ):
        r"""GetVSPHelpPath() -> std::string"""
        return _vsp.GetVSPHelpPath()
    
    @client_wrap
    def CheckForVSPHelp(self, path):
        r"""CheckForVSPHelp(std::string const & path) -> bool"""
        return _vsp.CheckForVSPHelp(path)
    
    @client_wrap
    def RegisterCFDMeshAnalyses(self, ):
        r"""RegisterCFDMeshAnalyses()"""
        return _vsp.RegisterCFDMeshAnalyses()
    
    @client_wrap
    def ReadVSPFile(self, file_name):
        r"""ReadVSPFile(std::string const & file_name)"""
        return _vsp.ReadVSPFile(file_name)
    
    @client_wrap
    def WriteVSPFile(self, *args):
        r"""WriteVSPFile(std::string const & file_name, int set=SET_ALL)"""
        return _vsp.WriteVSPFile(*args)
    
    @client_wrap
    def SetVSP3FileName(self, file_name):
        r"""SetVSP3FileName(std::string const & file_name)"""
        return _vsp.SetVSP3FileName(file_name)
    
    @client_wrap
    def GetVSPFileName(self, ):
        r"""GetVSPFileName() -> std::string"""
        return _vsp.GetVSPFileName()
    
    @client_wrap
    def ClearVSPModel(self, ):
        r"""ClearVSPModel()"""
        return _vsp.ClearVSPModel()
    
    @client_wrap
    def InsertVSPFile(self, file_name, parent_geom_id):
        r"""InsertVSPFile(std::string const & file_name, std::string const & parent_geom_id)"""
        return _vsp.InsertVSPFile(file_name, parent_geom_id)
    
    @client_wrap
    def ExportFile(self, *args):
        r"""ExportFile(std::string const & file_name, int thick_set, int file_type, int subsFlag=1, int thin_set=SET_NONE, bool useMode=False, string const & modeID="") -> std::string"""
        return _vsp.ExportFile(*args)
    
    @client_wrap
    def ImportFile(self, file_name, file_type, parent):
        r"""ImportFile(std::string const & file_name, int file_type, std::string const & parent) -> std::string"""
        return _vsp.ImportFile(file_name, file_type, parent)
    
    @client_wrap
    def SetBEMPropID(self, prop_id):
        r"""SetBEMPropID(string const & prop_id)"""
        return _vsp.SetBEMPropID(prop_id)
    
    @client_wrap
    def ReadApplyDESFile(self, file_name):
        r"""ReadApplyDESFile(std::string const & file_name)"""
        return _vsp.ReadApplyDESFile(file_name)
    
    @client_wrap
    def WriteDESFile(self, file_name):
        r"""WriteDESFile(std::string const & file_name)"""
        return _vsp.WriteDESFile(file_name)
    
    @client_wrap
    def ReadApplyXDDMFile(self, file_name):
        r"""ReadApplyXDDMFile(std::string const & file_name)"""
        return _vsp.ReadApplyXDDMFile(file_name)
    
    @client_wrap
    def WriteXDDMFile(self, file_name):
        r"""WriteXDDMFile(std::string const & file_name)"""
        return _vsp.WriteXDDMFile(file_name)
    
    @client_wrap
    def GetNumDesignVars(self, ):
        r"""GetNumDesignVars() -> int"""
        return _vsp.GetNumDesignVars()
    
    @client_wrap
    def AddDesignVar(self, parm_id, type):
        r"""AddDesignVar(std::string const & parm_id, int type)"""
        return _vsp.AddDesignVar(parm_id, type)
    
    @client_wrap
    def DeleteAllDesignVars(self, ):
        r"""DeleteAllDesignVars()"""
        return _vsp.DeleteAllDesignVars()
    
    @client_wrap
    def GetDesignVar(self, index):
        r"""GetDesignVar(int index) -> std::string"""
        return _vsp.GetDesignVar(index)
    
    @client_wrap
    def GetDesignVarType(self, index):
        r"""GetDesignVarType(int index) -> int"""
        return _vsp.GetDesignVarType(index)
    
    @client_wrap
    def SetComputationFileName(self, file_type, file_name):
        r"""SetComputationFileName(int file_type, std::string const & file_name)"""
        return _vsp.SetComputationFileName(file_type, file_name)
    
    @client_wrap
    def ComputeMassProps(self, set, num_slices, idir):
        r"""ComputeMassProps(int set, int num_slices, int idir) -> std::string"""
        return _vsp.ComputeMassProps(set, num_slices, idir)
    
    @client_wrap
    def ComputeCompGeom(self, set, half_mesh, file_export_types):
        r"""ComputeCompGeom(int set, bool half_mesh, int file_export_types) -> std::string"""
        return _vsp.ComputeCompGeom(set, half_mesh, file_export_types)
    
    @client_wrap
    def ComputePlaneSlice(self, set, num_slices, norm, auto_bnd, start_bnd=0, end_bnd=0, measureduct=False):
        r"""ComputePlaneSlice(int set, int num_slices, vec3d norm, bool auto_bnd, double start_bnd=0, double end_bnd=0, bool measureduct=False) -> std::string"""
        return _vsp.ComputePlaneSlice(set, num_slices, norm, auto_bnd, start_bnd, end_bnd, measureduct)
    
    @client_wrap
    def ComputeDegenGeom(self, set, file_export_types):
        r"""ComputeDegenGeom(int set, int file_export_types)"""
        return _vsp.ComputeDegenGeom(set, file_export_types)
    
    @client_wrap
    def ComputeCFDMesh(self, set, degenset, file_export_types):
        r"""ComputeCFDMesh(int set, int degenset, int file_export_types)"""
        return _vsp.ComputeCFDMesh(set, degenset, file_export_types)
    
    @client_wrap
    def SetCFDMeshVal(self, type, val):
        r"""SetCFDMeshVal(int type, double val)"""
        return _vsp.SetCFDMeshVal(type, val)
    
    @client_wrap
    def SetCFDWakeFlag(self, geom_id, flag):
        r"""SetCFDWakeFlag(std::string const & geom_id, bool flag)"""
        return _vsp.SetCFDWakeFlag(geom_id, flag)
    
    @client_wrap
    def DeleteAllCFDSources(self, ):
        r"""DeleteAllCFDSources()"""
        return _vsp.DeleteAllCFDSources()
    
    @client_wrap
    def AddDefaultSources(self, ):
        r"""AddDefaultSources()"""
        return _vsp.AddDefaultSources()
    
    @client_wrap
    def AddCFDSource(self, type, geom_id, surf_index, l1, r1, u1, w1, l2=0, r2=0, u2=0, w2=0):
        r"""AddCFDSource(int type, std::string const & geom_id, int surf_index, double l1, double r1, double u1, double w1, double l2=0, double r2=0, double u2=0, double w2=0)"""
        return _vsp.AddCFDSource(type, geom_id, surf_index, l1, r1, u1, w1, l2, r2, u2, w2)
    
    @client_wrap
    def GetVSPAERORefWingID(self, ):
        r"""GetVSPAERORefWingID() -> string"""
        return _vsp.GetVSPAERORefWingID()
    
    @client_wrap
    def SetVSPAERORefWingID(self, geom_id):
        r"""SetVSPAERORefWingID(std::string const & geom_id) -> string"""
        return _vsp.SetVSPAERORefWingID(geom_id)
    
    @client_wrap
    def GetNumAnalysis(self, ):
        r"""GetNumAnalysis() -> int"""
        return _vsp.GetNumAnalysis()
    
    @client_wrap
    def ListAnalysis(self, ):
        r"""ListAnalysis() -> StringVector"""
        return _vsp.ListAnalysis()
    
    @client_wrap
    def GetAnalysisInputNames(self, analysis):
        r"""GetAnalysisInputNames(std::string const & analysis) -> StringVector"""
        return _vsp.GetAnalysisInputNames(analysis)
    
    @client_wrap
    def GetAnalysisDoc(self, analysis):
        r"""GetAnalysisDoc(std::string const & analysis) -> std::string"""
        return _vsp.GetAnalysisDoc(analysis)
    
    @client_wrap
    def GetAnalysisInputDoc(self, analysis, name):
        r"""GetAnalysisInputDoc(std::string const & analysis, std::string const & name) -> std::string"""
        return _vsp.GetAnalysisInputDoc(analysis, name)
    
    @client_wrap
    def ExecAnalysis(self, analysis):
        r"""ExecAnalysis(std::string const & analysis) -> std::string"""
        return _vsp.ExecAnalysis(analysis)
    
    @client_wrap
    def GetNumAnalysisInputData(self, analysis, name):
        r"""GetNumAnalysisInputData(std::string const & analysis, std::string const & name) -> int"""
        return _vsp.GetNumAnalysisInputData(analysis, name)
    
    @client_wrap
    def GetAnalysisInputType(self, analysis, name):
        r"""GetAnalysisInputType(std::string const & analysis, std::string const & name) -> int"""
        return _vsp.GetAnalysisInputType(analysis, name)
    
    @client_wrap
    def GetIntAnalysisInput(self, analysis, name, index=0):
        r"""GetIntAnalysisInput(std::string const & analysis, std::string const & name, int index=0) -> IntVector"""
        return _vsp.GetIntAnalysisInput(analysis, name, index)
    
    @client_wrap
    def GetDoubleAnalysisInput(self, analysis, name, index=0):
        r"""GetDoubleAnalysisInput(std::string const & analysis, std::string const & name, int index=0) -> DoubleVector"""
        return _vsp.GetDoubleAnalysisInput(analysis, name, index)
    
    @client_wrap
    def GetStringAnalysisInput(self, analysis, name, index=0):
        r"""GetStringAnalysisInput(std::string const & analysis, std::string const & name, int index=0) -> StringVector"""
        return _vsp.GetStringAnalysisInput(analysis, name, index)
    
    @client_wrap
    def GetVec3dAnalysisInput(self, analysis, name, index=0):
        r"""GetVec3dAnalysisInput(std::string const & analysis, std::string const & name, int index=0) -> Vec3dVec"""
        return _vsp.GetVec3dAnalysisInput(analysis, name, index)
    
    @client_wrap
    def SetAnalysisInputDefaults(self, analysis):
        r"""SetAnalysisInputDefaults(std::string const & analysis)"""
        return _vsp.SetAnalysisInputDefaults(analysis)
    
    @client_wrap
    def SetIntAnalysisInput(self, analysis, name, indata, index=0):
        r"""SetIntAnalysisInput(std::string const & analysis, std::string const & name, IntVector indata, int index=0)"""
        return _vsp.SetIntAnalysisInput(analysis, name, indata, index)
    
    @client_wrap
    def SetDoubleAnalysisInput(self, analysis, name, indata, index=0):
        r"""SetDoubleAnalysisInput(std::string const & analysis, std::string const & name, DoubleVector indata, int index=0)"""
        return _vsp.SetDoubleAnalysisInput(analysis, name, indata, index)
    
    @client_wrap
    def SetStringAnalysisInput(self, analysis, name, indata, index=0):
        r"""SetStringAnalysisInput(std::string const & analysis, std::string const & name, StringVector indata, int index=0)"""
        return _vsp.SetStringAnalysisInput(analysis, name, indata, index)
    
    @client_wrap
    def SetVec3dAnalysisInput(self, analysis, name, indata, index=0):
        r"""SetVec3dAnalysisInput(std::string const & analysis, std::string const & name, Vec3dVec indata, int index=0)"""
        return _vsp.SetVec3dAnalysisInput(analysis, name, indata, index)
    
    @client_wrap
    def PrintAnalysisInputs(self, analysis_name):
        r"""PrintAnalysisInputs(std::string const & analysis_name)"""
        return _vsp.PrintAnalysisInputs(analysis_name)
    
    @client_wrap
    def PrintAnalysisDocs(self, analysis_name):
        r"""PrintAnalysisDocs(std::string const & analysis_name)"""
        return _vsp.PrintAnalysisDocs(analysis_name)
    
    @client_wrap
    def SummarizeAttributes(self, ):
        r"""SummarizeAttributes() -> string"""
        return _vsp.SummarizeAttributes()
    
    @client_wrap
    def SummarizeAttributesAsTree(self, ):
        r"""SummarizeAttributesAsTree() -> string"""
        return _vsp.SummarizeAttributesAsTree()
    
    @client_wrap
    def FindAllAttributes(self, ):
        r"""FindAllAttributes() -> StringVector"""
        return _vsp.FindAllAttributes()
    
    @client_wrap
    def FindAttributesByName(self, search_str):
        r"""FindAttributesByName(string const & search_str) -> StringVector"""
        return _vsp.FindAttributesByName(search_str)
    
    @client_wrap
    def FindAttributeByName(self, search_str, index):
        r"""FindAttributeByName(string const & search_str, int index) -> string"""
        return _vsp.FindAttributeByName(search_str, index)
    
    @client_wrap
    def FindAttributeInCollection(self, obj_id, search_str, index):
        r"""FindAttributeInCollection(string const & obj_id, string const & search_str, int index) -> string"""
        return _vsp.FindAttributeInCollection(obj_id, search_str, index)
    
    @client_wrap
    def FindAttributeNamesInCollection(self, collID):
        r"""FindAttributeNamesInCollection(string const & collID) -> StringVector"""
        return _vsp.FindAttributeNamesInCollection(collID)
    
    @client_wrap
    def FindAttributesInCollection(self, collID):
        r"""FindAttributesInCollection(string const & collID) -> StringVector"""
        return _vsp.FindAttributesInCollection(collID)
    
    @client_wrap
    def FindAttributedObjects(self, ):
        r"""FindAttributedObjects() -> StringVector"""
        return _vsp.FindAttributedObjects()
    
    @client_wrap
    def GetObjectType(self, attachID):
        r"""GetObjectType(string const & attachID) -> int"""
        return _vsp.GetObjectType(attachID)
    
    @client_wrap
    def GetObjectTypeName(self, attachID):
        r"""GetObjectTypeName(string const & attachID) -> string"""
        return _vsp.GetObjectTypeName(attachID)
    
    @client_wrap
    def GetObjectName(self, attachID):
        r"""GetObjectName(string const & attachID) -> string"""
        return _vsp.GetObjectName(attachID)
    
    @client_wrap
    def GetObjectParent(self, id):
        r"""GetObjectParent(string const & id) -> string"""
        return _vsp.GetObjectParent(id)
    
    @client_wrap
    def GetChildCollection(self, attachID):
        r"""GetChildCollection(string const & attachID) -> string"""
        return _vsp.GetChildCollection(attachID)
    
    @client_wrap
    def GetGeomSetCollection(self, index):
        r"""GetGeomSetCollection(int const & index) -> string"""
        return _vsp.GetGeomSetCollection(index)
    
    @client_wrap
    def GetAttributeName(self, attrID):
        r"""GetAttributeName(string const & attrID) -> string"""
        return _vsp.GetAttributeName(attrID)
    
    @client_wrap
    def GetAttributeID(self, collID, attributeName, index):
        r"""GetAttributeID(string const & collID, string const & attributeName, int index) -> string"""
        return _vsp.GetAttributeID(collID, attributeName, index)
    
    @client_wrap
    def GetAttributeDoc(self, attrID):
        r"""GetAttributeDoc(string const & attrID) -> string"""
        return _vsp.GetAttributeDoc(attrID)
    
    @client_wrap
    def GetAttributeType(self, attrID):
        r"""GetAttributeType(string const & attrID) -> int"""
        return _vsp.GetAttributeType(attrID)
    
    @client_wrap
    def GetAttributeTypeName(self, attrID):
        r"""GetAttributeTypeName(string const & attrID) -> string"""
        return _vsp.GetAttributeTypeName(attrID)
    
    @client_wrap
    def GetAttributeBoolVal(self, attrID):
        r"""GetAttributeBoolVal(string const & attrID) -> IntVector"""
        return _vsp.GetAttributeBoolVal(attrID)
    
    @client_wrap
    def GetAttributeIntVal(self, attrID):
        r"""GetAttributeIntVal(string const & attrID) -> IntVector"""
        return _vsp.GetAttributeIntVal(attrID)
    
    @client_wrap
    def GetAttributeDoubleVal(self, attrID):
        r"""GetAttributeDoubleVal(string const & attrID) -> DoubleVector"""
        return _vsp.GetAttributeDoubleVal(attrID)
    
    @client_wrap
    def GetAttributeStringVal(self, attrID):
        r"""GetAttributeStringVal(string const & attrID) -> StringVector"""
        return _vsp.GetAttributeStringVal(attrID)
    
    @client_wrap
    def GetAttributeParmVal(self, attrID):
        r"""GetAttributeParmVal(string const & attrID) -> DoubleVector"""
        return _vsp.GetAttributeParmVal(attrID)
    
    @client_wrap
    def GetAttributeParmName(self, attrID):
        r"""GetAttributeParmName(string const & attrID) -> StringVector"""
        return _vsp.GetAttributeParmName(attrID)
    
    @client_wrap
    def GetAttributeVec3dVal(self, attrID):
        r"""GetAttributeVec3dVal(string const & attrID) -> Vec3dVec"""
        return _vsp.GetAttributeVec3dVal(attrID)
    
    @client_wrap
    def GetAttributeIntMatrixVal(self, attrID):
        r"""GetAttributeIntMatrixVal(string const & attrID) -> IntVecVec"""
        return _vsp.GetAttributeIntMatrixVal(attrID)
    
    @client_wrap
    def GetAttributeDoubleMatrixVal(self, attrID):
        r"""GetAttributeDoubleMatrixVal(string const & attrID) -> DoubleVecVec"""
        return _vsp.GetAttributeDoubleMatrixVal(attrID)
    
    @client_wrap
    def SetAttributeName(self, attrID, name):
        r"""SetAttributeName(string const & attrID, string const & name)"""
        return _vsp.SetAttributeName(attrID, name)
    
    @client_wrap
    def SetAttributeDoc(self, attrID, doc):
        r"""SetAttributeDoc(string const & attrID, string const & doc)"""
        return _vsp.SetAttributeDoc(attrID, doc)
    
    @client_wrap
    def SetAttributeBool(self, attrID, value):
        r"""SetAttributeBool(string const & attrID, bool value)"""
        return _vsp.SetAttributeBool(attrID, value)
    
    @client_wrap
    def SetAttributeInt(self, attrID, value):
        r"""SetAttributeInt(string const & attrID, int value)"""
        return _vsp.SetAttributeInt(attrID, value)
    
    @client_wrap
    def SetAttributeDouble(self, attrID, value):
        r"""SetAttributeDouble(string const & attrID, double value)"""
        return _vsp.SetAttributeDouble(attrID, value)
    
    @client_wrap
    def SetAttributeString(self, attrID, value):
        r"""SetAttributeString(string const & attrID, string const & value)"""
        return _vsp.SetAttributeString(attrID, value)
    
    @client_wrap
    def SetAttributeVec3d(self, attrID, value):
        r"""SetAttributeVec3d(string const & attrID, Vec3dVec value)"""
        return _vsp.SetAttributeVec3d(attrID, value)
    
    @client_wrap
    def SetAttributeIntMatrix(self, attrID, value):
        r"""SetAttributeIntMatrix(string const & attrID, IntVecVec value)"""
        return _vsp.SetAttributeIntMatrix(attrID, value)
    
    @client_wrap
    def SetAttributeDoubleMatrix(self, attrID, value):
        r"""SetAttributeDoubleMatrix(string const & attrID, DoubleVecVec value)"""
        return _vsp.SetAttributeDoubleMatrix(attrID, value)
    
    @client_wrap
    def DeleteAttribute(self, attrID):
        r"""DeleteAttribute(string const & attrID)"""
        return _vsp.DeleteAttribute(attrID)
    
    @client_wrap
    def AddAttributeBool(self, collID, attributeName, value):
        r"""AddAttributeBool(string const & collID, string const & attributeName, bool value) -> string"""
        return _vsp.AddAttributeBool(collID, attributeName, value)
    
    @client_wrap
    def AddAttributeInt(self, collID, attributeName, value):
        r"""AddAttributeInt(string const & collID, string const & attributeName, int const value) -> string"""
        return _vsp.AddAttributeInt(collID, attributeName, value)
    
    @client_wrap
    def AddAttributeDouble(self, collID, attributeName, value):
        r"""AddAttributeDouble(string const & collID, string const & attributeName, double const value) -> string"""
        return _vsp.AddAttributeDouble(collID, attributeName, value)
    
    @client_wrap
    def AddAttributeString(self, collID, attributeName, value):
        r"""AddAttributeString(string const & collID, string const & attributeName, string const & value) -> string"""
        return _vsp.AddAttributeString(collID, attributeName, value)
    
    @client_wrap
    def AddAttributeParm(self, collID, attributeName, parmID):
        r"""AddAttributeParm(string const & collID, string const & attributeName, string const & parmID) -> string"""
        return _vsp.AddAttributeParm(collID, attributeName, parmID)
    
    @client_wrap
    def AddAttributeVec3d(self, collID, attributeName, value):
        r"""AddAttributeVec3d(string const & collID, string const & attributeName, Vec3dVec value) -> string"""
        return _vsp.AddAttributeVec3d(collID, attributeName, value)
    
    @client_wrap
    def AddAttributeIntMatrix(self, collID, attributeName, value):
        r"""AddAttributeIntMatrix(string const & collID, string const & attributeName, IntVecVec value) -> string"""
        return _vsp.AddAttributeIntMatrix(collID, attributeName, value)
    
    @client_wrap
    def AddAttributeDoubleMatrix(self, collID, attributeName, value):
        r"""AddAttributeDoubleMatrix(string const & collID, string const & attributeName, DoubleVecVec value) -> string"""
        return _vsp.AddAttributeDoubleMatrix(collID, attributeName, value)
    
    @client_wrap
    def AddAttributeGroup(self, collID, attributeName):
        r"""AddAttributeGroup(string const & collID, string const & attributeName) -> string"""
        return _vsp.AddAttributeGroup(collID, attributeName)
    
    @client_wrap
    def CopyAttribute(self, attrID):
        r"""CopyAttribute(string const & attrID) -> int"""
        return _vsp.CopyAttribute(attrID)
    
    @client_wrap
    def CutAttribute(self, attrID):
        r"""CutAttribute(string const & attrID)"""
        return _vsp.CutAttribute(attrID)
    
    @client_wrap
    def PasteAttribute(self, coll_id):
        r"""PasteAttribute(string const & coll_id) -> StringVector"""
        return _vsp.PasteAttribute(coll_id)
    
    @client_wrap
    def GetAllResultsNames(self, ):
        r"""GetAllResultsNames() -> StringVector"""
        return _vsp.GetAllResultsNames()
    
    @client_wrap
    def GetAllDataNames(self, results_id):
        r"""GetAllDataNames(std::string const & results_id) -> StringVector"""
        return _vsp.GetAllDataNames(results_id)
    
    @client_wrap
    def GetNumResults(self, name):
        r"""GetNumResults(std::string const & name) -> int"""
        return _vsp.GetNumResults(name)
    
    @client_wrap
    def GetResultsName(self, results_id):
        r"""GetResultsName(std::string const & results_id) -> std::string"""
        return _vsp.GetResultsName(results_id)
    
    @client_wrap
    def GetResultsSetDoc(self, results_id):
        r"""GetResultsSetDoc(std::string const & results_id) -> std::string"""
        return _vsp.GetResultsSetDoc(results_id)
    
    @client_wrap
    def GetResultsEntryDoc(self, results_id, data_name):
        r"""GetResultsEntryDoc(std::string const & results_id, std::string const & data_name) -> std::string"""
        return _vsp.GetResultsEntryDoc(results_id, data_name)
    
    @client_wrap
    def FindResultsID(self, name, index=0):
        r"""FindResultsID(std::string const & name, int index=0) -> std::string"""
        return _vsp.FindResultsID(name, index)
    
    @client_wrap
    def FindLatestResultsID(self, name):
        r"""FindLatestResultsID(std::string const & name) -> std::string"""
        return _vsp.FindLatestResultsID(name)
    
    @client_wrap
    def GetNumData(self, results_id, data_name):
        r"""GetNumData(std::string const & results_id, std::string const & data_name) -> int"""
        return _vsp.GetNumData(results_id, data_name)
    
    @client_wrap
    def GetResultsType(self, results_id, data_name):
        r"""GetResultsType(std::string const & results_id, std::string const & data_name) -> int"""
        return _vsp.GetResultsType(results_id, data_name)
    
    @client_wrap
    def GetIntResults(self, id, name, index=0):
        r"""GetIntResults(std::string const & id, std::string const & name, int index=0) -> IntVector"""
        return _vsp.GetIntResults(id, name, index)
    
    @client_wrap
    def GetDoubleResults(self, id, name, index=0):
        r"""GetDoubleResults(std::string const & id, std::string const & name, int index=0) -> DoubleVector"""
        return _vsp.GetDoubleResults(id, name, index)
    
    @client_wrap
    def GetDoubleMatResults(self, id, name, index=0):
        r"""GetDoubleMatResults(std::string const & id, std::string const & name, int index=0) -> DoubleVecVec"""
        return _vsp.GetDoubleMatResults(id, name, index)
    
    @client_wrap
    def GetStringResults(self, id, name, index=0):
        r"""GetStringResults(std::string const & id, std::string const & name, int index=0) -> StringVector"""
        return _vsp.GetStringResults(id, name, index)
    
    @client_wrap
    def GetVec3dResults(self, id, name, index=0):
        r"""GetVec3dResults(std::string const & id, std::string const & name, int index=0) -> Vec3dVec"""
        return _vsp.GetVec3dResults(id, name, index)
    
    @client_wrap
    def CreateGeomResults(self, geom_id, name):
        r"""CreateGeomResults(std::string const & geom_id, std::string const & name) -> std::string"""
        return _vsp.CreateGeomResults(geom_id, name)
    
    @client_wrap
    def DeleteAllResults(self, ):
        r"""DeleteAllResults()"""
        return _vsp.DeleteAllResults()
    
    @client_wrap
    def DeleteResult(self, id):
        r"""DeleteResult(std::string const & id)"""
        return _vsp.DeleteResult(id)
    
    @client_wrap
    def WriteResultsCSVFile(self, id, file_name):
        r"""WriteResultsCSVFile(std::string const & id, std::string const & file_name)"""
        return _vsp.WriteResultsCSVFile(id, file_name)
    
    @client_wrap
    def PrintResults(self, results_id):
        r"""PrintResults(std::string const & results_id)"""
        return _vsp.PrintResults(results_id)
    
    @client_wrap
    def PrintResultsDocs(self, results_id):
        r"""PrintResultsDocs(std::string const & results_id)"""
        return _vsp.PrintResultsDocs(results_id)
    
    @client_wrap
    def WriteTestResults(self, ):
        r"""WriteTestResults()"""
        return _vsp.WriteTestResults()
    
    @client_wrap
    def InitGUI(self, ):
        r"""InitGUI()"""
        return _vsp.InitGUI()
    
    @client_wrap
    def StartGUI(self, ):
        r"""StartGUI()"""
        return _vsp.StartGUI()
    
    @client_wrap
    def EnableStopGUIMenuItem(self, ):
        r"""EnableStopGUIMenuItem()"""
        return _vsp.EnableStopGUIMenuItem()
    
    @client_wrap
    def DisableStopGUIMenuItem(self, ):
        r"""DisableStopGUIMenuItem()"""
        return _vsp.DisableStopGUIMenuItem()
    
    @client_wrap
    def StopGUI(self, ):
        r"""StopGUI()"""
        return _vsp.StopGUI()
    
    @client_wrap
    def PopupMsg(self, msg):
        r"""PopupMsg(std::string const & msg)"""
        return _vsp.PopupMsg(msg)
    
    @client_wrap
    def UpdateGUI(self, ):
        r"""UpdateGUI()"""
        return _vsp.UpdateGUI()
    
    @client_wrap
    def IsGUIBuild(self, ):
        r"""IsGUIBuild() -> bool"""
        return _vsp.IsGUIBuild()
    
    @client_wrap
    def Lock(self, ):
        r"""Lock()"""
        return _vsp.Lock()
    
    @client_wrap
    def Unlock(self, ):
        r"""Unlock()"""
        return _vsp.Unlock()
    
    @client_wrap
    def IsEventLoopRunning(self, ):
        r"""IsEventLoopRunning() -> bool"""
        return _vsp.IsEventLoopRunning()
    
    @client_wrap
    def ScreenGrab(self, fname, w, h, transparentBG, autocrop=False):
        r"""ScreenGrab(string const & fname, int w, int h, bool transparentBG, bool autocrop=False)"""
        return _vsp.ScreenGrab(fname, w, h, transparentBG, autocrop)
    
    @client_wrap
    def SetViewAxis(self, vaxis):
        r"""SetViewAxis(bool vaxis)"""
        return _vsp.SetViewAxis(vaxis)
    
    @client_wrap
    def SetShowBorders(self, brdr):
        r"""SetShowBorders(bool brdr)"""
        return _vsp.SetShowBorders(brdr)
    
    @client_wrap
    def SetGeomDrawType(self, geom_id, type):
        r"""SetGeomDrawType(string const & geom_id, int type)"""
        return _vsp.SetGeomDrawType(geom_id, type)
    
    @client_wrap
    def SetGeomWireColor(self, geom_id, r, g, b):
        r"""SetGeomWireColor(string const & geom_id, int r, int g, int b)"""
        return _vsp.SetGeomWireColor(geom_id, r, g, b)
    
    @client_wrap
    def SetGeomDisplayType(self, geom_id, type):
        r"""SetGeomDisplayType(string const & geom_id, int type)"""
        return _vsp.SetGeomDisplayType(geom_id, type)
    
    @client_wrap
    def SetGeomMaterialName(self, geom_id, name):
        r"""SetGeomMaterialName(string const & geom_id, string const & name)"""
        return _vsp.SetGeomMaterialName(geom_id, name)
    
    @client_wrap
    def AddMaterial(self, name, ambient, diffuse, specular, emissive, alpha, shininess):
        r"""AddMaterial(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)
    
    @client_wrap
    def GetMaterialNames(self, ):
        r"""GetMaterialNames() -> StringVector"""
        return _vsp.GetMaterialNames()
    
    @client_wrap
    def SetBackground(self, r, g, b):
        r"""SetBackground(double r, double g, double b)"""
        return _vsp.SetBackground(r, g, b)
    
    @client_wrap
    def SetAllViews(self, view):
        r"""SetAllViews(int view)"""
        return _vsp.SetAllViews(view)
    
    @client_wrap
    def SetView(self, viewport, view):
        r"""SetView(int viewport, int view)"""
        return _vsp.SetView(viewport, view)
    
    @client_wrap
    def FitAllViews(self, ):
        r"""FitAllViews()"""
        return _vsp.FitAllViews()
    
    @client_wrap
    def ResetViews(self, ):
        r"""ResetViews()"""
        return _vsp.ResetViews()
    
    @client_wrap
    def SetWindowLayout(self, r, c):
        r"""SetWindowLayout(int r, int c)"""
        return _vsp.SetWindowLayout(r, c)
    
    @client_wrap
    def SetGUIElementDisable(self, e, state):
        r"""SetGUIElementDisable(int e, bool state)"""
        return _vsp.SetGUIElementDisable(e, state)
    
    @client_wrap
    def SetGUIScreenDisable(self, s, state):
        r"""SetGUIScreenDisable(int s, bool state)"""
        return _vsp.SetGUIScreenDisable(s, state)
    
    @client_wrap
    def SetGeomScreenDisable(self, s, state):
        r"""SetGeomScreenDisable(int s, bool state)"""
        return _vsp.SetGeomScreenDisable(s, state)
    
    @client_wrap
    def GetGeomTypes(self, ):
        r"""GetGeomTypes() -> StringVector"""
        return _vsp.GetGeomTypes()
    
    @client_wrap
    def AddGeom(self, *args):
        r"""AddGeom(std::string const & type, std::string const & parent=std::string()) -> std::string"""
        return _vsp.AddGeom(*args)
    
    @client_wrap
    def UpdateGeom(self, geom_id):
        r"""UpdateGeom(std::string const & geom_id)"""
        return _vsp.UpdateGeom(geom_id)
    
    @client_wrap
    def DeleteGeom(self, geom_id):
        r"""DeleteGeom(std::string const & geom_id)"""
        return _vsp.DeleteGeom(geom_id)
    
    @client_wrap
    def DeleteGeomVec(self, del_vec):
        r"""DeleteGeomVec(StringVector del_vec)"""
        return _vsp.DeleteGeomVec(del_vec)
    
    @client_wrap
    def CutGeomToClipboard(self, geom_id):
        r"""CutGeomToClipboard(std::string const & geom_id)"""
        return _vsp.CutGeomToClipboard(geom_id)
    
    @client_wrap
    def CopyGeomToClipboard(self, geom_id):
        r"""CopyGeomToClipboard(std::string const & geom_id)"""
        return _vsp.CopyGeomToClipboard(geom_id)
    
    @client_wrap
    def PasteGeomClipboard(self, *args):
        r"""PasteGeomClipboard(std::string const & parent=std::string()) -> StringVector"""
        return _vsp.PasteGeomClipboard(*args)
    
    @client_wrap
    def FindGeoms(self, ):
        r"""FindGeoms() -> StringVector"""
        return _vsp.FindGeoms()
    
    @client_wrap
    def FindGeomsWithName(self, name):
        r"""FindGeomsWithName(std::string const & name) -> StringVector"""
        return _vsp.FindGeomsWithName(name)
    
    @client_wrap
    def FindGeom(self, name, index):
        r"""FindGeom(std::string const & name, int index) -> std::string"""
        return _vsp.FindGeom(name, index)
    
    @client_wrap
    def SetGeomName(self, geom_id, name):
        r"""SetGeomName(std::string const & geom_id, std::string const & name)"""
        return _vsp.SetGeomName(geom_id, name)
    
    @client_wrap
    def GetGeomName(self, geom_id):
        r"""GetGeomName(std::string const & geom_id) -> std::string"""
        return _vsp.GetGeomName(geom_id)
    
    @client_wrap
    def GetGeomParmIDs(self, geom_id):
        r"""GetGeomParmIDs(std::string const & geom_id) -> StringVector"""
        return _vsp.GetGeomParmIDs(geom_id)
    
    @client_wrap
    def GetGeomTypeName(self, geom_id):
        r"""GetGeomTypeName(std::string const & geom_id) -> std::string"""
        return _vsp.GetGeomTypeName(geom_id)
    
    @client_wrap
    def GetParm(self, geom_id, name, group):
        r"""GetParm(std::string const & geom_id, std::string const & name, std::string const & group) -> std::string"""
        return _vsp.GetParm(geom_id, name, group)
    
    @client_wrap
    def GetGeomParent(self, geom_id):
        r"""GetGeomParent(std::string const & geom_id) -> std::string"""
        return _vsp.GetGeomParent(geom_id)
    
    @client_wrap
    def GetGeomChildren(self, geom_id):
        r"""GetGeomChildren(std::string const & geom_id) -> StringVector"""
        return _vsp.GetGeomChildren(geom_id)
    
    @client_wrap
    def GetNumXSecSurfs(self, geom_id):
        r"""GetNumXSecSurfs(std::string const & geom_id) -> int"""
        return _vsp.GetNumXSecSurfs(geom_id)
    
    @client_wrap
    def GetNumMainSurfs(self, geom_id):
        r"""GetNumMainSurfs(std::string const & geom_id) -> int"""
        return _vsp.GetNumMainSurfs(geom_id)
    
    @client_wrap
    def GetTotalNumSurfs(self, geom_id):
        r"""GetTotalNumSurfs(std::string const & geom_id) -> int"""
        return _vsp.GetTotalNumSurfs(geom_id)
    
    @client_wrap
    def GetGeomVSPSurfType(self, geom_id, main_surf_ind=0):
        r"""GetGeomVSPSurfType(std::string const & geom_id, int main_surf_ind=0) -> int"""
        return _vsp.GetGeomVSPSurfType(geom_id, main_surf_ind)
    
    @client_wrap
    def GetGeomVSPSurfCfdType(self, geom_id, main_surf_ind=0):
        r"""GetGeomVSPSurfCfdType(std::string const & geom_id, int main_surf_ind=0) -> int"""
        return _vsp.GetGeomVSPSurfCfdType(geom_id, main_surf_ind)
    
    @client_wrap
    def GetGeomBBoxMax(self, geom_id, main_surf_ind=0, ref_frame_is_absolute=True):
        r"""GetGeomBBoxMax(std::string const & geom_id, int main_surf_ind=0, bool ref_frame_is_absolute=True) -> vec3d"""
        return _vsp.GetGeomBBoxMax(geom_id, main_surf_ind, ref_frame_is_absolute)
    
    @client_wrap
    def GetGeomBBoxMin(self, geom_id, main_surf_ind=0, ref_frame_is_absolute=True):
        r"""GetGeomBBoxMin(std::string const & geom_id, int main_surf_ind=0, bool ref_frame_is_absolute=True) -> vec3d"""
        return _vsp.GetGeomBBoxMin(geom_id, main_surf_ind, ref_frame_is_absolute)
    
    @client_wrap
    def AddSubSurf(self, geom_id, type, surfindex=0):
        r"""AddSubSurf(std::string const & geom_id, int type, int surfindex=0) -> std::string"""
        return _vsp.AddSubSurf(geom_id, type, surfindex)
    
    @client_wrap
    def GetSubSurf(self, *args):
        r"""
        GetSubSurf(std::string const & geom_id, int index) -> std::string
        GetSubSurf(std::string const & geom_id, std::string const & name) -> StringVector
        """
        return _vsp.GetSubSurf(*args)
    
    @client_wrap
    def DeleteSubSurf(self, *args):
        r"""
        DeleteSubSurf(std::string const & geom_id, std::string const & sub_id)
        DeleteSubSurf(std::string const & sub_id)
        """
        return _vsp.DeleteSubSurf(*args)
    
    @client_wrap
    def SetSubSurfName(self, *args):
        r"""
        SetSubSurfName(std::string const & geom_id, std::string const & sub_id, std::string const & name)
        SetSubSurfName(std::string const & sub_id, std::string const & name)
        """
        return _vsp.SetSubSurfName(*args)
    
    @client_wrap
    def GetSubSurfName(self, *args):
        r"""
        GetSubSurfName(std::string const & geom_id, std::string const & sub_id) -> std::string
        GetSubSurfName(std::string const & sub_id) -> std::string
        """
        return _vsp.GetSubSurfName(*args)
    
    @client_wrap
    def GetSubSurfIndex(self, sub_id):
        r"""GetSubSurfIndex(std::string const & sub_id) -> int"""
        return _vsp.GetSubSurfIndex(sub_id)
    
    @client_wrap
    def GetSubSurfIDVec(self, geom_id):
        r"""GetSubSurfIDVec(std::string const & geom_id) -> StringVector"""
        return _vsp.GetSubSurfIDVec(geom_id)
    
    @client_wrap
    def GetAllSubSurfIDs(self, ):
        r"""GetAllSubSurfIDs() -> StringVector"""
        return _vsp.GetAllSubSurfIDs()
    
    @client_wrap
    def GetNumSubSurf(self, geom_id):
        r"""GetNumSubSurf(std::string const & geom_id) -> int"""
        return _vsp.GetNumSubSurf(geom_id)
    
    @client_wrap
    def GetSubSurfType(self, sub_id):
        r"""GetSubSurfType(std::string const & sub_id) -> int"""
        return _vsp.GetSubSurfType(sub_id)
    
    @client_wrap
    def GetSubSurfParmIDs(self, sub_id):
        r"""GetSubSurfParmIDs(std::string const & sub_id) -> StringVector"""
        return _vsp.GetSubSurfParmIDs(sub_id)
    
    @client_wrap
    def AddFeaStruct(self, geom_id, init_skin=True, surfindex=0):
        r"""AddFeaStruct(std::string const & geom_id, bool init_skin=True, int surfindex=0) -> int"""
        return _vsp.AddFeaStruct(geom_id, init_skin, surfindex)
    
    @client_wrap
    def SetFeaMeshStructIndex(self, struct_index):
        r"""SetFeaMeshStructIndex(int struct_index)"""
        return _vsp.SetFeaMeshStructIndex(struct_index)
    
    @client_wrap
    def DeleteFeaStruct(self, geom_id, fea_struct_ind):
        r"""DeleteFeaStruct(std::string const & geom_id, int fea_struct_ind)"""
        return _vsp.DeleteFeaStruct(geom_id, fea_struct_ind)
    
    @client_wrap
    def GetFeaStructID(self, geom_id, fea_struct_ind):
        r"""GetFeaStructID(std::string const & geom_id, int fea_struct_ind) -> std::string"""
        return _vsp.GetFeaStructID(geom_id, fea_struct_ind)
    
    @client_wrap
    def GetFeaStructIndex(self, struct_id):
        r"""GetFeaStructIndex(std::string const & struct_id) -> int"""
        return _vsp.GetFeaStructIndex(struct_id)
    
    @client_wrap
    def GetFeaStructParentGeomID(self, struct_id):
        r"""GetFeaStructParentGeomID(std::string const & struct_id) -> std::string"""
        return _vsp.GetFeaStructParentGeomID(struct_id)
    
    @client_wrap
    def GetFeaStructName(self, geom_id, fea_struct_ind):
        r"""GetFeaStructName(std::string const & geom_id, int fea_struct_ind) -> std::string"""
        return _vsp.GetFeaStructName(geom_id, fea_struct_ind)
    
    @client_wrap
    def SetFeaStructName(self, geom_id, fea_struct_ind, name):
        r"""SetFeaStructName(std::string const & geom_id, int fea_struct_ind, std::string const & name)"""
        return _vsp.SetFeaStructName(geom_id, fea_struct_ind, name)
    
    @client_wrap
    def GetFeaStructIDVec(self, ):
        r"""GetFeaStructIDVec() -> StringVector"""
        return _vsp.GetFeaStructIDVec()
    
    @client_wrap
    def SetFeaPartName(self, part_id, name):
        r"""SetFeaPartName(std::string const & part_id, std::string const & name)"""
        return _vsp.SetFeaPartName(part_id, name)
    
    @client_wrap
    def AddFeaPart(self, geom_id, fea_struct_ind, type):
        r"""AddFeaPart(std::string const & geom_id, int fea_struct_ind, int type) -> std::string"""
        return _vsp.AddFeaPart(geom_id, fea_struct_ind, type)
    
    @client_wrap
    def DeleteFeaPart(self, geom_id, fea_struct_ind, part_id):
        r"""DeleteFeaPart(std::string const & geom_id, int fea_struct_ind, std::string const & part_id)"""
        return _vsp.DeleteFeaPart(geom_id, fea_struct_ind, part_id)
    
    @client_wrap
    def GetFeaPartID(self, fea_struct_id, fea_part_index):
        r"""GetFeaPartID(std::string const & fea_struct_id, int fea_part_index) -> std::string"""
        return _vsp.GetFeaPartID(fea_struct_id, fea_part_index)
    
    @client_wrap
    def GetFeaPartName(self, part_id):
        r"""GetFeaPartName(std::string const & part_id) -> std::string"""
        return _vsp.GetFeaPartName(part_id)
    
    @client_wrap
    def GetFeaPartType(self, part_id):
        r"""GetFeaPartType(std::string const & part_id) -> int"""
        return _vsp.GetFeaPartType(part_id)
    
    @client_wrap
    def GetFeaPartIDVec(self, fea_struct_id):
        r"""GetFeaPartIDVec(std::string const & fea_struct_id) -> StringVector"""
        return _vsp.GetFeaPartIDVec(fea_struct_id)
    
    @client_wrap
    def GetFeaSubSurfIDVec(self, fea_struct_id):
        r"""GetFeaSubSurfIDVec(std::string const & fea_struct_id) -> StringVector"""
        return _vsp.GetFeaSubSurfIDVec(fea_struct_id)
    
    @client_wrap
    def SetFeaPartPerpendicularSparID(self, part_id, perpendicular_spar_id):
        r"""SetFeaPartPerpendicularSparID(std::string const & part_id, std::string const & perpendicular_spar_id)"""
        return _vsp.SetFeaPartPerpendicularSparID(part_id, perpendicular_spar_id)
    
    @client_wrap
    def GetFeaPartPerpendicularSparID(self, part_id):
        r"""GetFeaPartPerpendicularSparID(std::string const & part_id) -> std::string"""
        return _vsp.GetFeaPartPerpendicularSparID(part_id)
    
    @client_wrap
    def SetFeaSubSurfName(self, subsurf_id, name):
        r"""SetFeaSubSurfName(std::string const & subsurf_id, std::string const & name)"""
        return _vsp.SetFeaSubSurfName(subsurf_id, name)
    
    @client_wrap
    def GetFeaSubSurfName(self, subsurf_id):
        r"""GetFeaSubSurfName(std::string const & subsurf_id) -> std::string"""
        return _vsp.GetFeaSubSurfName(subsurf_id)
    
    @client_wrap
    def AddFeaSubSurf(self, geom_id, fea_struct_ind, type):
        r"""AddFeaSubSurf(std::string const & geom_id, int fea_struct_ind, int type) -> std::string"""
        return _vsp.AddFeaSubSurf(geom_id, fea_struct_ind, type)
    
    @client_wrap
    def DeleteFeaSubSurf(self, geom_id, fea_struct_ind, ss_id):
        r"""DeleteFeaSubSurf(std::string const & geom_id, int fea_struct_ind, std::string const & ss_id)"""
        return _vsp.DeleteFeaSubSurf(geom_id, fea_struct_ind, ss_id)
    
    @client_wrap
    def GetFeaSubSurfIndex(self, ss_id):
        r"""GetFeaSubSurfIndex(string const & ss_id) -> int"""
        return _vsp.GetFeaSubSurfIndex(ss_id)
    
    @client_wrap
    def NumFeaStructures(self, ):
        r"""NumFeaStructures() -> int"""
        return _vsp.NumFeaStructures()
    
    @client_wrap
    def NumFeaParts(self, fea_struct_id):
        r"""NumFeaParts(std::string const & fea_struct_id) -> int"""
        return _vsp.NumFeaParts(fea_struct_id)
    
    @client_wrap
    def NumFeaSubSurfs(self, fea_struct_id):
        r"""NumFeaSubSurfs(std::string const & fea_struct_id) -> int"""
        return _vsp.NumFeaSubSurfs(fea_struct_id)
    
    @client_wrap
    def AddFeaBC(self, fea_struct_id, type=-1):
        r"""AddFeaBC(string const & fea_struct_id, int type=-1) -> std::string"""
        return _vsp.AddFeaBC(fea_struct_id, type)
    
    @client_wrap
    def DelFeaBC(self, fea_struct_id, bc_id):
        r"""DelFeaBC(string const & fea_struct_id, std::string const & bc_id)"""
        return _vsp.DelFeaBC(fea_struct_id, bc_id)
    
    @client_wrap
    def GetFeaBCIDVec(self, fea_struct_id):
        r"""GetFeaBCIDVec(string const & fea_struct_id) -> StringVector"""
        return _vsp.GetFeaBCIDVec(fea_struct_id)
    
    @client_wrap
    def NumFeaBCs(self, fea_struct_id):
        r"""NumFeaBCs(string const & fea_struct_id) -> int"""
        return _vsp.NumFeaBCs(fea_struct_id)
    
    @client_wrap
    def AddFeaMaterial(self, ):
        r"""AddFeaMaterial() -> std::string"""
        return _vsp.AddFeaMaterial()
    
    @client_wrap
    def AddFeaProperty(self, property_type=0):
        r"""AddFeaProperty(int property_type=0) -> std::string"""
        return _vsp.AddFeaProperty(property_type)
    
    @client_wrap
    def SetFeaMeshVal(self, geom_id, fea_struct_ind, type, val):
        r"""SetFeaMeshVal(std::string const & geom_id, int fea_struct_ind, int type, double val)"""
        return _vsp.SetFeaMeshVal(geom_id, fea_struct_ind, type, val)
    
    @client_wrap
    def SetFeaMeshFileName(self, geom_id, fea_struct_ind, file_type, file_name):
        r"""SetFeaMeshFileName(std::string const & geom_id, int fea_struct_ind, int file_type, string const & file_name)"""
        return _vsp.SetFeaMeshFileName(geom_id, fea_struct_ind, file_type, file_name)
    
    @client_wrap
    def ComputeFeaMesh(self, *args):
        r"""
        ComputeFeaMesh(std::string const & geom_id, int fea_struct_ind, int file_type)
        ComputeFeaMesh(std::string const & struct_id, int file_type)
        """
        return _vsp.ComputeFeaMesh(*args)
    
    @client_wrap
    def CutXSec(self, geom_id, index):
        r"""CutXSec(std::string const & geom_id, int index)"""
        return _vsp.CutXSec(geom_id, index)
    
    @client_wrap
    def CopyXSec(self, geom_id, index):
        r"""CopyXSec(std::string const & geom_id, int index)"""
        return _vsp.CopyXSec(geom_id, index)
    
    @client_wrap
    def PasteXSec(self, geom_id, index):
        r"""PasteXSec(std::string const & geom_id, int index)"""
        return _vsp.PasteXSec(geom_id, index)
    
    @client_wrap
    def InsertXSec(self, geom_id, index, type):
        r"""InsertXSec(std::string const & geom_id, int index, int type)"""
        return _vsp.InsertXSec(geom_id, index, type)
    
    @client_wrap
    def SplitWingXSec(self, wing_id, section_index):
        r"""SplitWingXSec(string const & wing_id, int section_index)"""
        return _vsp.SplitWingXSec(wing_id, section_index)
    
    @client_wrap
    def SetDriverGroup(self, geom_id, section_index, driver_0, driver_1=-1, driver_2=-1):
        r"""SetDriverGroup(std::string const & geom_id, int section_index, int driver_0, int driver_1=-1, int driver_2=-1)"""
        return _vsp.SetDriverGroup(geom_id, section_index, driver_0, driver_1, driver_2)
    
    @client_wrap
    def GetXSecSurf(self, geom_id, index):
        r"""GetXSecSurf(std::string const & geom_id, int index) -> std::string"""
        return _vsp.GetXSecSurf(geom_id, index)
    
    @client_wrap
    def GetNumXSec(self, xsec_surf_id):
        r"""GetNumXSec(std::string const & xsec_surf_id) -> int"""
        return _vsp.GetNumXSec(xsec_surf_id)
    
    @client_wrap
    def GetXSec(self, xsec_surf_id, xsec_index):
        r"""GetXSec(std::string const & xsec_surf_id, int xsec_index) -> std::string"""
        return _vsp.GetXSec(xsec_surf_id, xsec_index)
    
    @client_wrap
    def ChangeXSecShape(self, xsec_surf_id, xsec_index, type):
        r"""ChangeXSecShape(std::string const & xsec_surf_id, int xsec_index, int type)"""
        return _vsp.ChangeXSecShape(xsec_surf_id, xsec_index, type)
    
    @client_wrap
    def SetXSecSurfGlobalXForm(self, xsec_surf_id, mat):
        r"""SetXSecSurfGlobalXForm(std::string const & xsec_surf_id, Matrix4d mat)"""
        return _vsp.SetXSecSurfGlobalXForm(xsec_surf_id, mat)
    
    @client_wrap
    def GetXSecSurfGlobalXForm(self, xsec_surf_id):
        r"""GetXSecSurfGlobalXForm(std::string const & xsec_surf_id) -> Matrix4d"""
        return _vsp.GetXSecSurfGlobalXForm(xsec_surf_id)
    
    @client_wrap
    def GetXSecShape(self, xsec_id):
        r"""GetXSecShape(std::string const & xsec_id) -> int"""
        return _vsp.GetXSecShape(xsec_id)
    
    @client_wrap
    def GetXSecWidth(self, xsec_id):
        r"""GetXSecWidth(std::string const & xsec_id) -> double"""
        return _vsp.GetXSecWidth(xsec_id)
    
    @client_wrap
    def GetXSecHeight(self, xsec_id):
        r"""GetXSecHeight(std::string const & xsec_id) -> double"""
        return _vsp.GetXSecHeight(xsec_id)
    
    @client_wrap
    def SetXSecWidthHeight(self, xsec_id, w, h):
        r"""SetXSecWidthHeight(std::string const & xsec_id, double w, double h)"""
        return _vsp.SetXSecWidthHeight(xsec_id, w, h)
    
    @client_wrap
    def SetXSecWidth(self, xsec_id, w):
        r"""SetXSecWidth(std::string const & xsec_id, double w)"""
        return _vsp.SetXSecWidth(xsec_id, w)
    
    @client_wrap
    def SetXSecHeight(self, xsec_id, h):
        r"""SetXSecHeight(std::string const & xsec_id, double h)"""
        return _vsp.SetXSecHeight(xsec_id, h)
    
    @client_wrap
    def GetXSecParmIDs(self, xsec_id):
        r"""GetXSecParmIDs(std::string const & xsec_id) -> StringVector"""
        return _vsp.GetXSecParmIDs(xsec_id)
    
    @client_wrap
    def GetXSecParm(self, xsec_id, name):
        r"""GetXSecParm(std::string const & xsec_id, std::string const & name) -> std::string"""
        return _vsp.GetXSecParm(xsec_id, name)
    
    @client_wrap
    def ReadFileXSec(self, xsec_id, file_name):
        r"""ReadFileXSec(std::string const & xsec_id, std::string const & file_name) -> Vec3dVec"""
        return _vsp.ReadFileXSec(xsec_id, file_name)
    
    @client_wrap
    def SetXSecPnts(self, xsec_id, pnt_vec):
        r"""SetXSecPnts(std::string const & xsec_id, Vec3dVec pnt_vec)"""
        return _vsp.SetXSecPnts(xsec_id, pnt_vec)
    
    @client_wrap
    def ComputeXSecPnt(self, xsec_id, fract):
        r"""ComputeXSecPnt(std::string const & xsec_id, double fract) -> vec3d"""
        return _vsp.ComputeXSecPnt(xsec_id, fract)
    
    @client_wrap
    def ComputeXSecTan(self, xsec_id, fract):
        r"""ComputeXSecTan(std::string const & xsec_id, double fract) -> vec3d"""
        return _vsp.ComputeXSecTan(xsec_id, fract)
    
    @client_wrap
    def ResetXSecSkinParms(self, xsec_id):
        r"""ResetXSecSkinParms(std::string const & xsec_id)"""
        return _vsp.ResetXSecSkinParms(xsec_id)
    
    @client_wrap
    def SetXSecContinuity(self, xsec_id, cx):
        r"""SetXSecContinuity(std::string const & xsec_id, int cx)"""
        return _vsp.SetXSecContinuity(xsec_id, cx)
    
    @client_wrap
    def SetXSecTanAngles(self, xsec_id, side, top, right, bottom, left):
        r"""SetXSecTanAngles(std::string const & xsec_id, int side, double top, double right, double bottom, double left)"""
        return _vsp.SetXSecTanAngles(xsec_id, side, top, right, bottom, left)
    
    @client_wrap
    def SetXSecTanSlews(self, xsec_id, side, top, right, bottom, left):
        r"""SetXSecTanSlews(std::string const & xsec_id, int side, double top, double right, double bottom, double left)"""
        return _vsp.SetXSecTanSlews(xsec_id, side, top, right, bottom, left)
    
    @client_wrap
    def SetXSecTanStrengths(self, xsec_id, side, top, right, bottom, left):
        r"""SetXSecTanStrengths(std::string const & xsec_id, int side, double top, double right, double bottom, double left)"""
        return _vsp.SetXSecTanStrengths(xsec_id, side, top, right, bottom, left)
    
    @client_wrap
    def SetXSecCurvatures(self, xsec_id, side, top, right, bottom, left):
        r"""SetXSecCurvatures(std::string const & xsec_id, int side, double top, double right, double bottom, double left)"""
        return _vsp.SetXSecCurvatures(xsec_id, side, top, right, bottom, left)
    
    @client_wrap
    def ReadFileAirfoil(self, xsec_id, file_name):
        r"""ReadFileAirfoil(std::string const & xsec_id, std::string const & file_name)"""
        return _vsp.ReadFileAirfoil(xsec_id, file_name)
    
    @client_wrap
    def SetAirfoilUpperPnts(self, xsec_id, up_pnt_vec):
        r"""SetAirfoilUpperPnts(std::string const & xsec_id, Vec3dVec up_pnt_vec)"""
        return _vsp.SetAirfoilUpperPnts(xsec_id, up_pnt_vec)
    
    @client_wrap
    def SetAirfoilLowerPnts(self, xsec_id, low_pnt_vec):
        r"""SetAirfoilLowerPnts(std::string const & xsec_id, Vec3dVec low_pnt_vec)"""
        return _vsp.SetAirfoilLowerPnts(xsec_id, low_pnt_vec)
    
    @client_wrap
    def SetAirfoilPnts(self, xsec_id, up_pnt_vec, low_pnt_vec):
        r"""SetAirfoilPnts(std::string const & xsec_id, Vec3dVec up_pnt_vec, Vec3dVec low_pnt_vec)"""
        return _vsp.SetAirfoilPnts(xsec_id, up_pnt_vec, low_pnt_vec)
    
    @client_wrap
    def GetHersheyBarLiftDist(self, npts, alpha, Vinf, span, full_span_flag=False):
        r"""GetHersheyBarLiftDist(int const & npts, double const & alpha, double const & Vinf, double const & span, bool full_span_flag=False) -> Vec3dVec"""
        return _vsp.GetHersheyBarLiftDist(npts, alpha, Vinf, span, full_span_flag)
    
    @client_wrap
    def GetHersheyBarDragDist(self, npts, alpha, Vinf, span, full_span_flag=False):
        r"""GetHersheyBarDragDist(int const & npts, double const & alpha, double const & Vinf, double const & span, bool full_span_flag=False) -> Vec3dVec"""
        return _vsp.GetHersheyBarDragDist(npts, alpha, Vinf, span, full_span_flag)
    
    @client_wrap
    def GetVKTAirfoilPnts(self, npts, alpha, epsilon, kappa, tau):
        r"""GetVKTAirfoilPnts(int const & npts, double const & alpha, double const & epsilon, double const & kappa, double const & tau) -> Vec3dVec"""
        return _vsp.GetVKTAirfoilPnts(npts, alpha, epsilon, kappa, tau)
    
    @client_wrap
    def GetVKTAirfoilCpDist(self, alpha, epsilon, kappa, tau, xyz_data):
        r"""GetVKTAirfoilCpDist(double const & alpha, double const & epsilon, double const & kappa, double const & tau, Vec3dVec xyz_data) -> DoubleVector"""
        return _vsp.GetVKTAirfoilCpDist(alpha, epsilon, kappa, tau, xyz_data)
    
    @client_wrap
    def GetEllipsoidSurfPnts(self, center, abc_rad, u_npts=20, w_npts=20):
        r"""GetEllipsoidSurfPnts(vec3d center, vec3d abc_rad, int u_npts=20, int w_npts=20) -> Vec3dVec"""
        return _vsp.GetEllipsoidSurfPnts(center, abc_rad, u_npts, w_npts)
    
    @client_wrap
    def GetFeatureLinePnts(self, geom_id):
        r"""GetFeatureLinePnts(string const & geom_id) -> Vec3dVec"""
        return _vsp.GetFeatureLinePnts(geom_id)
    
    @client_wrap
    def GetEllipsoidCpDist(self, surf_pnt_vec, abc_rad, V_inf):
        r"""GetEllipsoidCpDist(Vec3dVec surf_pnt_vec, vec3d abc_rad, vec3d V_inf) -> DoubleVector"""
        return _vsp.GetEllipsoidCpDist(surf_pnt_vec, abc_rad, V_inf)
    
    @client_wrap
    def IntegrateEllipsoidFlow(self, abc_rad, abc_index):
        r"""IntegrateEllipsoidFlow(vec3d abc_rad, int const & abc_index) -> double"""
        return _vsp.IntegrateEllipsoidFlow(abc_rad, abc_index)
    
    @client_wrap
    def GetAirfoilUpperPnts(self, xsec_id):
        r"""GetAirfoilUpperPnts(std::string const & xsec_id) -> Vec3dVec"""
        return _vsp.GetAirfoilUpperPnts(xsec_id)
    
    @client_wrap
    def GetAirfoilLowerPnts(self, xsec_id):
        r"""GetAirfoilLowerPnts(std::string const & xsec_id) -> Vec3dVec"""
        return _vsp.GetAirfoilLowerPnts(xsec_id)
    
    @client_wrap
    def GetUpperCSTCoefs(self, xsec_id):
        r"""GetUpperCSTCoefs(std::string const & xsec_id) -> DoubleVector"""
        return _vsp.GetUpperCSTCoefs(xsec_id)
    
    @client_wrap
    def GetLowerCSTCoefs(self, xsec_id):
        r"""GetLowerCSTCoefs(std::string const & xsec_id) -> DoubleVector"""
        return _vsp.GetLowerCSTCoefs(xsec_id)
    
    @client_wrap
    def GetUpperCSTDegree(self, xsec_id):
        r"""GetUpperCSTDegree(std::string const & xsec_id) -> int"""
        return _vsp.GetUpperCSTDegree(xsec_id)
    
    @client_wrap
    def GetLowerCSTDegree(self, xsec_id):
        r"""GetLowerCSTDegree(std::string const & xsec_id) -> int"""
        return _vsp.GetLowerCSTDegree(xsec_id)
    
    @client_wrap
    def SetUpperCST(self, xsec_id, deg, coefs):
        r"""SetUpperCST(std::string const & xsec_id, int deg, DoubleVector coefs)"""
        return _vsp.SetUpperCST(xsec_id, deg, coefs)
    
    @client_wrap
    def SetLowerCST(self, xsec_id, deg, coefs):
        r"""SetLowerCST(std::string const & xsec_id, int deg, DoubleVector coefs)"""
        return _vsp.SetLowerCST(xsec_id, deg, coefs)
    
    @client_wrap
    def PromoteCSTUpper(self, xsec_id):
        r"""PromoteCSTUpper(std::string const & xsec_id)"""
        return _vsp.PromoteCSTUpper(xsec_id)
    
    @client_wrap
    def PromoteCSTLower(self, xsec_id):
        r"""PromoteCSTLower(std::string const & xsec_id)"""
        return _vsp.PromoteCSTLower(xsec_id)
    
    @client_wrap
    def DemoteCSTUpper(self, xsec_id):
        r"""DemoteCSTUpper(std::string const & xsec_id)"""
        return _vsp.DemoteCSTUpper(xsec_id)
    
    @client_wrap
    def DemoteCSTLower(self, xsec_id):
        r"""DemoteCSTLower(std::string const & xsec_id)"""
        return _vsp.DemoteCSTLower(xsec_id)
    
    @client_wrap
    def FitAfCST(self, xsec_surf_id, xsec_index, deg):
        r"""FitAfCST(std::string const & xsec_surf_id, int xsec_index, int deg)"""
        return _vsp.FitAfCST(xsec_surf_id, xsec_index, deg)
    
    @client_wrap
    def AddBackground3D(self, ):
        r"""AddBackground3D() -> string"""
        return _vsp.AddBackground3D()
    
    @client_wrap
    def GetNumBackground3Ds(self, ):
        r"""GetNumBackground3Ds() -> int"""
        return _vsp.GetNumBackground3Ds()
    
    @client_wrap
    def GetAllBackground3Ds(self, ):
        r"""GetAllBackground3Ds() -> StringVector"""
        return _vsp.GetAllBackground3Ds()
    
    @client_wrap
    def ShowAllBackground3Ds(self, ):
        r"""ShowAllBackground3Ds()"""
        return _vsp.ShowAllBackground3Ds()
    
    @client_wrap
    def HideAllBackground3Ds(self, ):
        r"""HideAllBackground3Ds()"""
        return _vsp.HideAllBackground3Ds()
    
    @client_wrap
    def DelAllBackground3Ds(self, ):
        r"""DelAllBackground3Ds()"""
        return _vsp.DelAllBackground3Ds()
    
    @client_wrap
    def DelBackground3D(self, id):
        r"""DelBackground3D(string const & id)"""
        return _vsp.DelBackground3D(id)
    
    @client_wrap
    def GetAllBackground3DRelativePaths(self, ):
        r"""GetAllBackground3DRelativePaths() -> StringVector"""
        return _vsp.GetAllBackground3DRelativePaths()
    
    @client_wrap
    def GetAllBackground3DAbsolutePaths(self, ):
        r"""GetAllBackground3DAbsolutePaths() -> StringVector"""
        return _vsp.GetAllBackground3DAbsolutePaths()
    
    @client_wrap
    def GetBackground3DRelativePath(self, id):
        r"""GetBackground3DRelativePath(string const & id) -> string"""
        return _vsp.GetBackground3DRelativePath(id)
    
    @client_wrap
    def GetBackground3DAbsolutePath(self, id):
        r"""GetBackground3DAbsolutePath(string const & id) -> string"""
        return _vsp.GetBackground3DAbsolutePath(id)
    
    @client_wrap
    def SetBackground3DRelativePath(self, id, fname):
        r"""SetBackground3DRelativePath(string const & id, string const & fname)"""
        return _vsp.SetBackground3DRelativePath(id, fname)
    
    @client_wrap
    def SetBackground3DAbsolutePath(self, id, fname):
        r"""SetBackground3DAbsolutePath(string const & id, string const & fname)"""
        return _vsp.SetBackground3DAbsolutePath(id, fname)
    
    @client_wrap
    def ChangeBORXSecShape(self, bor_id, type):
        r"""ChangeBORXSecShape(string const & bor_id, int type)"""
        return _vsp.ChangeBORXSecShape(bor_id, type)
    
    @client_wrap
    def GetBORXSecShape(self, bor_id):
        r"""GetBORXSecShape(string const & bor_id) -> int"""
        return _vsp.GetBORXSecShape(bor_id)
    
    @client_wrap
    def ReadBORFileXSec(self, bor_id, file_name):
        r"""ReadBORFileXSec(std::string const & bor_id, std::string const & file_name) -> Vec3dVec"""
        return _vsp.ReadBORFileXSec(bor_id, file_name)
    
    @client_wrap
    def SetBORXSecPnts(self, bor_id, pnt_vec):
        r"""SetBORXSecPnts(std::string const & bor_id, Vec3dVec pnt_vec)"""
        return _vsp.SetBORXSecPnts(bor_id, pnt_vec)
    
    @client_wrap
    def ComputeBORXSecPnt(self, bor_id, fract):
        r"""ComputeBORXSecPnt(std::string const & bor_id, double fract) -> vec3d"""
        return _vsp.ComputeBORXSecPnt(bor_id, fract)
    
    @client_wrap
    def ComputeBORXSecTan(self, bor_id, fract):
        r"""ComputeBORXSecTan(std::string const & bor_id, double fract) -> vec3d"""
        return _vsp.ComputeBORXSecTan(bor_id, fract)
    
    @client_wrap
    def ReadBORFileAirfoil(self, bor_id, file_name):
        r"""ReadBORFileAirfoil(std::string const & bor_id, std::string const & file_name)"""
        return _vsp.ReadBORFileAirfoil(bor_id, file_name)
    
    @client_wrap
    def SetBORAirfoilUpperPnts(self, bor_id, up_pnt_vec):
        r"""SetBORAirfoilUpperPnts(std::string const & bor_id, Vec3dVec up_pnt_vec)"""
        return _vsp.SetBORAirfoilUpperPnts(bor_id, up_pnt_vec)
    
    @client_wrap
    def SetBORAirfoilLowerPnts(self, bor_id, low_pnt_vec):
        r"""SetBORAirfoilLowerPnts(std::string const & bor_id, Vec3dVec low_pnt_vec)"""
        return _vsp.SetBORAirfoilLowerPnts(bor_id, low_pnt_vec)
    
    @client_wrap
    def SetBORAirfoilPnts(self, bor_id, up_pnt_vec, low_pnt_vec):
        r"""SetBORAirfoilPnts(std::string const & bor_id, Vec3dVec up_pnt_vec, Vec3dVec low_pnt_vec)"""
        return _vsp.SetBORAirfoilPnts(bor_id, up_pnt_vec, low_pnt_vec)
    
    @client_wrap
    def GetBORAirfoilUpperPnts(self, bor_id):
        r"""GetBORAirfoilUpperPnts(std::string const & bor_id) -> Vec3dVec"""
        return _vsp.GetBORAirfoilUpperPnts(bor_id)
    
    @client_wrap
    def GetBORAirfoilLowerPnts(self, bor_id):
        r"""GetBORAirfoilLowerPnts(std::string const & bor_id) -> Vec3dVec"""
        return _vsp.GetBORAirfoilLowerPnts(bor_id)
    
    @client_wrap
    def GetBORUpperCSTCoefs(self, bor_id):
        r"""GetBORUpperCSTCoefs(std::string const & bor_id) -> DoubleVector"""
        return _vsp.GetBORUpperCSTCoefs(bor_id)
    
    @client_wrap
    def GetBORLowerCSTCoefs(self, bor_id):
        r"""GetBORLowerCSTCoefs(std::string const & bor_id) -> DoubleVector"""
        return _vsp.GetBORLowerCSTCoefs(bor_id)
    
    @client_wrap
    def GetBORUpperCSTDegree(self, bor_id):
        r"""GetBORUpperCSTDegree(std::string const & bor_id) -> int"""
        return _vsp.GetBORUpperCSTDegree(bor_id)
    
    @client_wrap
    def GetBORLowerCSTDegree(self, bor_id):
        r"""GetBORLowerCSTDegree(std::string const & bor_id) -> int"""
        return _vsp.GetBORLowerCSTDegree(bor_id)
    
    @client_wrap
    def SetBORUpperCST(self, bor_id, deg, coefs):
        r"""SetBORUpperCST(std::string const & bor_id, int deg, DoubleVector coefs)"""
        return _vsp.SetBORUpperCST(bor_id, deg, coefs)
    
    @client_wrap
    def SetBORLowerCST(self, bor_id, deg, coefs):
        r"""SetBORLowerCST(std::string const & bor_id, int deg, DoubleVector coefs)"""
        return _vsp.SetBORLowerCST(bor_id, deg, coefs)
    
    @client_wrap
    def PromoteBORCSTUpper(self, bor_id):
        r"""PromoteBORCSTUpper(std::string const & bor_id)"""
        return _vsp.PromoteBORCSTUpper(bor_id)
    
    @client_wrap
    def PromoteBORCSTLower(self, bor_id):
        r"""PromoteBORCSTLower(std::string const & bor_id)"""
        return _vsp.PromoteBORCSTLower(bor_id)
    
    @client_wrap
    def DemoteBORCSTUpper(self, bor_id):
        r"""DemoteBORCSTUpper(std::string const & bor_id)"""
        return _vsp.DemoteBORCSTUpper(bor_id)
    
    @client_wrap
    def DemoteBORCSTLower(self, bor_id):
        r"""DemoteBORCSTLower(std::string const & bor_id)"""
        return _vsp.DemoteBORCSTLower(bor_id)
    
    @client_wrap
    def FitBORAfCST(self, bor_id, deg):
        r"""FitBORAfCST(std::string const & bor_id, int deg)"""
        return _vsp.FitBORAfCST(bor_id, deg)
    
    @client_wrap
    def WriteBezierAirfoil(self, file_name, geom_id, foilsurf_u):
        r"""WriteBezierAirfoil(std::string const & file_name, std::string const & geom_id, double const & foilsurf_u)"""
        return _vsp.WriteBezierAirfoil(file_name, geom_id, foilsurf_u)
    
    @client_wrap
    def WriteSeligAirfoil(self, file_name, geom_id, foilsurf_u):
        r"""WriteSeligAirfoil(std::string const & file_name, std::string const & geom_id, double const & foilsurf_u)"""
        return _vsp.WriteSeligAirfoil(file_name, geom_id, foilsurf_u)
    
    @client_wrap
    def GetAirfoilCoordinates(self, geom_id, foilsurf_u):
        r"""GetAirfoilCoordinates(std::string const & geom_id, double const & foilsurf_u) -> Vec3dVec"""
        return _vsp.GetAirfoilCoordinates(geom_id, foilsurf_u)
    
    @client_wrap
    def EditXSecInitShape(self, xsec_id):
        r"""EditXSecInitShape(std::string const & xsec_id)"""
        return _vsp.EditXSecInitShape(xsec_id)
    
    @client_wrap
    def EditXSecConvertTo(self, xsec_id, newtype):
        r"""EditXSecConvertTo(std::string const & xsec_id, int const & newtype)"""
        return _vsp.EditXSecConvertTo(xsec_id, newtype)
    
    @client_wrap
    def GetEditXSecUVec(self, xsec_id):
        r"""GetEditXSecUVec(std::string const & xsec_id) -> DoubleVector"""
        return _vsp.GetEditXSecUVec(xsec_id)
    
    @client_wrap
    def GetEditXSecCtrlVec(self, xsec_id, non_dimensional=True):
        r"""GetEditXSecCtrlVec(std::string const & xsec_id, bool non_dimensional=True) -> Vec3dVec"""
        return _vsp.GetEditXSecCtrlVec(xsec_id, non_dimensional)
    
    @client_wrap
    def SetEditXSecPnts(self, xsec_id, u_vec, control_pts, r_vec):
        r"""SetEditXSecPnts(std::string const & xsec_id, DoubleVector u_vec, Vec3dVec control_pts, DoubleVector r_vec)"""
        return _vsp.SetEditXSecPnts(xsec_id, u_vec, control_pts, r_vec)
    
    @client_wrap
    def EditXSecDelPnt(self, xsec_id, indx):
        r"""EditXSecDelPnt(std::string const & xsec_id, int const & indx)"""
        return _vsp.EditXSecDelPnt(xsec_id, indx)
    
    @client_wrap
    def EditXSecSplit01(self, xsec_id, u):
        r"""EditXSecSplit01(std::string const & xsec_id, double const & u) -> int"""
        return _vsp.EditXSecSplit01(xsec_id, u)
    
    @client_wrap
    def MoveEditXSecPnt(self, xsec_id, indx, new_pnt):
        r"""MoveEditXSecPnt(std::string const & xsec_id, int const & indx, vec3d new_pnt)"""
        return _vsp.MoveEditXSecPnt(xsec_id, indx, new_pnt)
    
    @client_wrap
    def ConvertXSecToEdit(self, geom_id, indx=0):
        r"""ConvertXSecToEdit(std::string const & geom_id, int const & indx=0)"""
        return _vsp.ConvertXSecToEdit(geom_id, indx)
    
    @client_wrap
    def GetEditXSecFixedUVec(self, xsec_id):
        r"""GetEditXSecFixedUVec(std::string const & xsec_id) -> BoolVector"""
        return _vsp.GetEditXSecFixedUVec(xsec_id)
    
    @client_wrap
    def SetEditXSecFixedUVec(self, xsec_id, fixed_u_vec):
        r"""SetEditXSecFixedUVec(std::string const & xsec_id, BoolVector fixed_u_vec)"""
        return _vsp.SetEditXSecFixedUVec(xsec_id, fixed_u_vec)
    
    @client_wrap
    def ReparameterizeEditXSec(self, xsec_id):
        r"""ReparameterizeEditXSec(std::string const & xsec_id)"""
        return _vsp.ReparameterizeEditXSec(xsec_id)
    
    @client_wrap
    def GetNumSets(self, ):
        r"""GetNumSets() -> int"""
        return _vsp.GetNumSets()
    
    @client_wrap
    def SetSetName(self, index, name):
        r"""SetSetName(int index, std::string const & name)"""
        return _vsp.SetSetName(index, name)
    
    @client_wrap
    def GetSetName(self, index):
        r"""GetSetName(int index) -> std::string"""
        return _vsp.GetSetName(index)
    
    @client_wrap
    def GetGeomSetAtIndex(self, index):
        r"""GetGeomSetAtIndex(int index) -> StringVector"""
        return _vsp.GetGeomSetAtIndex(index)
    
    @client_wrap
    def GetGeomSet(self, name):
        r"""GetGeomSet(std::string const & name) -> StringVector"""
        return _vsp.GetGeomSet(name)
    
    @client_wrap
    def GetSetIndex(self, name):
        r"""GetSetIndex(std::string const & name) -> int"""
        return _vsp.GetSetIndex(name)
    
    @client_wrap
    def GetSetFlag(self, geom_id, set_index):
        r"""GetSetFlag(std::string const & geom_id, int set_index) -> bool"""
        return _vsp.GetSetFlag(geom_id, set_index)
    
    @client_wrap
    def SetSetFlag(self, geom_id, set_index, flag):
        r"""SetSetFlag(std::string const & geom_id, int set_index, bool flag)"""
        return _vsp.SetSetFlag(geom_id, set_index, flag)
    
    @client_wrap
    def CopyPasteSet(self, copyIndex, pasteIndex):
        r"""CopyPasteSet(int copyIndex, int pasteIndex)"""
        return _vsp.CopyPasteSet(copyIndex, pasteIndex)
    
    @client_wrap
    def ScaleSet(self, set_index, scale):
        r"""ScaleSet(int set_index, double scale)"""
        return _vsp.ScaleSet(set_index, scale)
    
    @client_wrap
    def RotateSet(self, set_index, x_rot_deg, y_rot_deg, z_rot_deg):
        r"""RotateSet(int set_index, double x_rot_deg, double y_rot_deg, double z_rot_deg)"""
        return _vsp.RotateSet(set_index, x_rot_deg, y_rot_deg, z_rot_deg)
    
    @client_wrap
    def TranslateSet(self, set_index, translation_vec):
        r"""TranslateSet(int set_index, vec3d translation_vec)"""
        return _vsp.TranslateSet(set_index, translation_vec)
    
    @client_wrap
    def TransformSet(self, set_index, translation_vec, x_rot_deg, y_rot_deg, z_rot_deg, scale, scale_translations_flag):
        r"""TransformSet(int set_index, vec3d translation_vec, double x_rot_deg, double y_rot_deg, double z_rot_deg, double scale, bool scale_translations_flag)"""
        return _vsp.TransformSet(set_index, translation_vec, x_rot_deg, y_rot_deg, z_rot_deg, scale, scale_translations_flag)
    
    @client_wrap
    def ValidParm(self, id):
        r"""ValidParm(std::string const & id) -> bool"""
        return _vsp.ValidParm(id)
    
    @client_wrap
    def SetParmVal(self, *args):
        r"""
        SetParmVal(std::string const & parm_id, double val) -> double
        SetParmVal(std::string const & geom_id, std::string const & name, std::string const & group, double val) -> double
        """
        return _vsp.SetParmVal(*args)
    
    @client_wrap
    def SetParmValLimits(self, parm_id, val, lower_limit, upper_limit):
        r"""SetParmValLimits(std::string const & parm_id, double val, double lower_limit, double upper_limit) -> double"""
        return _vsp.SetParmValLimits(parm_id, val, lower_limit, upper_limit)
    
    @client_wrap
    def SetParmValUpdate(self, *args):
        r"""
        SetParmValUpdate(std::string const & parm_id, double val) -> double
        SetParmValUpdate(std::string const & geom_id, std::string const & parm_name, std::string const & parm_group_name, double val) -> double
        """
        return _vsp.SetParmValUpdate(*args)
    
    @client_wrap
    def GetParmVal(self, *args):
        r"""
        GetParmVal(std::string const & parm_id) -> double
        GetParmVal(std::string const & geom_id, std::string const & name, std::string const & group) -> double
        """
        return _vsp.GetParmVal(*args)
    
    @client_wrap
    def GetIntParmVal(self, parm_id):
        r"""GetIntParmVal(std::string const & parm_id) -> int"""
        return _vsp.GetIntParmVal(parm_id)
    
    @client_wrap
    def GetBoolParmVal(self, parm_id):
        r"""GetBoolParmVal(std::string const & parm_id) -> bool"""
        return _vsp.GetBoolParmVal(parm_id)
    
    @client_wrap
    def SetParmUpperLimit(self, parm_id, val):
        r"""SetParmUpperLimit(std::string const & parm_id, double val)"""
        return _vsp.SetParmUpperLimit(parm_id, val)
    
    @client_wrap
    def GetParmUpperLimit(self, parm_id):
        r"""GetParmUpperLimit(std::string const & parm_id) -> double"""
        return _vsp.GetParmUpperLimit(parm_id)
    
    @client_wrap
    def SetParmLowerLimit(self, parm_id, val):
        r"""SetParmLowerLimit(std::string const & parm_id, double val)"""
        return _vsp.SetParmLowerLimit(parm_id, val)
    
    @client_wrap
    def GetParmLowerLimit(self, parm_id):
        r"""GetParmLowerLimit(std::string const & parm_id) -> double"""
        return _vsp.GetParmLowerLimit(parm_id)
    
    @client_wrap
    def GetParmType(self, parm_id):
        r"""GetParmType(std::string const & parm_id) -> int"""
        return _vsp.GetParmType(parm_id)
    
    @client_wrap
    def GetParmName(self, parm_id):
        r"""GetParmName(std::string const & parm_id) -> std::string"""
        return _vsp.GetParmName(parm_id)
    
    @client_wrap
    def GetParmGroupName(self, parm_id):
        r"""GetParmGroupName(std::string const & parm_id) -> std::string"""
        return _vsp.GetParmGroupName(parm_id)
    
    @client_wrap
    def GetParmDisplayGroupName(self, parm_id):
        r"""GetParmDisplayGroupName(std::string const & parm_id) -> std::string"""
        return _vsp.GetParmDisplayGroupName(parm_id)
    
    @client_wrap
    def GetParmContainer(self, parm_id):
        r"""GetParmContainer(std::string const & parm_id) -> std::string"""
        return _vsp.GetParmContainer(parm_id)
    
    @client_wrap
    def SetParmDescript(self, parm_id, desc):
        r"""SetParmDescript(std::string const & parm_id, std::string const & desc)"""
        return _vsp.SetParmDescript(parm_id, desc)
    
    @client_wrap
    def GetParmDescript(self, parm_id):
        r"""GetParmDescript(std::string const & parm_id) -> std::string"""
        return _vsp.GetParmDescript(parm_id)
    
    @client_wrap
    def FindParm(self, parm_container_id, parm_name, group_name):
        r"""FindParm(std::string const & parm_container_id, std::string const & parm_name, std::string const & group_name) -> std::string"""
        return _vsp.FindParm(parm_container_id, parm_name, group_name)
    
    @client_wrap
    def FindContainers(self, ):
        r"""FindContainers() -> StringVector"""
        return _vsp.FindContainers()
    
    @client_wrap
    def FindContainersWithName(self, name):
        r"""FindContainersWithName(std::string const & name) -> StringVector"""
        return _vsp.FindContainersWithName(name)
    
    @client_wrap
    def FindContainer(self, name, index):
        r"""FindContainer(std::string const & name, int index) -> std::string"""
        return _vsp.FindContainer(name, index)
    
    @client_wrap
    def GetContainerName(self, parm_container_id):
        r"""GetContainerName(std::string const & parm_container_id) -> std::string"""
        return _vsp.GetContainerName(parm_container_id)
    
    @client_wrap
    def FindContainerGroupNames(self, parm_container_id):
        r"""FindContainerGroupNames(std::string const & parm_container_id) -> StringVector"""
        return _vsp.FindContainerGroupNames(parm_container_id)
    
    @client_wrap
    def FindContainerParmIDs(self, parm_container_id):
        r"""FindContainerParmIDs(std::string const & parm_container_id) -> StringVector"""
        return _vsp.FindContainerParmIDs(parm_container_id)
    
    @client_wrap
    def GetVehicleID(self, ):
        r"""GetVehicleID() -> std::string"""
        return _vsp.GetVehicleID()
    
    @client_wrap
    def GetNumUserParms(self, ):
        r"""GetNumUserParms() -> int"""
        return _vsp.GetNumUserParms()
    
    @client_wrap
    def GetNumPredefinedUserParms(self, ):
        r"""GetNumPredefinedUserParms() -> int"""
        return _vsp.GetNumPredefinedUserParms()
    
    @client_wrap
    def GetAllUserParms(self, ):
        r"""GetAllUserParms() -> StringVector"""
        return _vsp.GetAllUserParms()
    
    @client_wrap
    def GetUserParmContainer(self, ):
        r"""GetUserParmContainer() -> std::string"""
        return _vsp.GetUserParmContainer()
    
    @client_wrap
    def AddUserParm(self, type, name, group):
        r"""AddUserParm(int type, string const & name, string const & group) -> string"""
        return _vsp.AddUserParm(type, name, group)
    
    @client_wrap
    def DeleteUserParm(self, id):
        r"""DeleteUserParm(std::string const & id)"""
        return _vsp.DeleteUserParm(id)
    
    @client_wrap
    def DeleteAllUserParm(self, ):
        r"""DeleteAllUserParm()"""
        return _vsp.DeleteAllUserParm()
    
    @client_wrap
    def ComputeMinClearanceDistance(self, *args):
        r"""ComputeMinClearanceDistance(std::string const & geom_id, int set=SET_ALL, bool useMode=False, string const & modeID=std::string()) -> double"""
        return _vsp.ComputeMinClearanceDistance(*args)
    
    @client_wrap
    def SnapParm(self, *args):
        r"""SnapParm(std::string const & parm_id, double target_min_dist, bool inc_flag, int set=SET_ALL, bool useMode=False, string const & modeID=std::string()) -> double"""
        return _vsp.SnapParm(*args)
    
    @client_wrap
    def AddVarPresetGroup(self, group_name):
        r"""AddVarPresetGroup(std::string const & group_name) -> string"""
        return _vsp.AddVarPresetGroup(group_name)
    
    @client_wrap
    def AddVarPresetSetting(self, group_id, setting_name):
        r"""AddVarPresetSetting(std::string const & group_id, std::string const & setting_name) -> string"""
        return _vsp.AddVarPresetSetting(group_id, setting_name)
    
    @client_wrap
    def AddVarPresetParm(self, group_id, parm_id):
        r"""AddVarPresetParm(std::string const & group_id, std::string const & parm_id)"""
        return _vsp.AddVarPresetParm(group_id, parm_id)
    
    @client_wrap
    def DeleteVarPresetGroup(self, group_id):
        r"""DeleteVarPresetGroup(std::string const & group_id)"""
        return _vsp.DeleteVarPresetGroup(group_id)
    
    @client_wrap
    def DeleteVarPresetSetting(self, group_id, setting_id):
        r"""DeleteVarPresetSetting(std::string const & group_id, std::string const & setting_id)"""
        return _vsp.DeleteVarPresetSetting(group_id, setting_id)
    
    @client_wrap
    def DeleteVarPresetParm(self, group_id, parm_id):
        r"""DeleteVarPresetParm(std::string const & group_id, std::string const & parm_id)"""
        return _vsp.DeleteVarPresetParm(group_id, parm_id)
    
    @client_wrap
    def SetVarPresetParmVal(self, group_id, setting_id, parm_id, parm_val):
        r"""SetVarPresetParmVal(std::string const & group_id, std::string const & setting_id, std::string const & parm_id, double parm_val)"""
        return _vsp.SetVarPresetParmVal(group_id, setting_id, parm_id, parm_val)
    
    @client_wrap
    def GetVarPresetParmVal(self, group_id, setting_id, parm_id):
        r"""GetVarPresetParmVal(std::string const & group_id, std::string const & setting_id, std::string const & parm_id) -> double"""
        return _vsp.GetVarPresetParmVal(group_id, setting_id, parm_id)
    
    @client_wrap
    def GetGroupName(self, group_id):
        r"""GetGroupName(std::string const & group_id) -> std::string"""
        return _vsp.GetGroupName(group_id)
    
    @client_wrap
    def GetSettingName(self, setting_id):
        r"""GetSettingName(std::string const & setting_id) -> std::string"""
        return _vsp.GetSettingName(setting_id)
    
    @client_wrap
    def SetGroupName(self, group_id, group_name):
        r"""SetGroupName(std::string const & group_id, std::string const & group_name)"""
        return _vsp.SetGroupName(group_id, group_name)
    
    @client_wrap
    def SetSettingName(self, setting_id, setting_name):
        r"""SetSettingName(std::string const & setting_id, std::string const & setting_name)"""
        return _vsp.SetSettingName(setting_id, setting_name)
    
    @client_wrap
    def GetVarPresetGroups(self, ):
        r"""GetVarPresetGroups() -> StringVector"""
        return _vsp.GetVarPresetGroups()
    
    @client_wrap
    def GetVarPresetSettings(self, group_id):
        r"""GetVarPresetSettings(std::string const & group_id) -> StringVector"""
        return _vsp.GetVarPresetSettings(group_id)
    
    @client_wrap
    def GetVarPresetParmIDs(self, group_id):
        r"""GetVarPresetParmIDs(std::string const & group_id) -> StringVector"""
        return _vsp.GetVarPresetParmIDs(group_id)
    
    @client_wrap
    def GetVarPresetParmVals(self, setting_id):
        r"""GetVarPresetParmVals(std::string const & setting_id) -> DoubleVector"""
        return _vsp.GetVarPresetParmVals(setting_id)
    
    @client_wrap
    def SetVarPresetParmVals(self, setting_id, parm_vals):
        r"""SetVarPresetParmVals(std::string const & setting_id, DoubleVector parm_vals)"""
        return _vsp.SetVarPresetParmVals(setting_id, parm_vals)
    
    @client_wrap
    def SaveVarPresetParmVals(self, group_id, setting_id):
        r"""SaveVarPresetParmVals(std::string const & group_id, std::string const & setting_id)"""
        return _vsp.SaveVarPresetParmVals(group_id, setting_id)
    
    @client_wrap
    def ApplyVarPresetSetting(self, group_id, setting_id):
        r"""ApplyVarPresetSetting(std::string const & group_id, std::string const & setting_id)"""
        return _vsp.ApplyVarPresetSetting(group_id, setting_id)
    
    @client_wrap
    def CreateAndAddMode(self, name, normal_set, degen_set):
        r"""CreateAndAddMode(string const & name, int normal_set, int degen_set) -> string"""
        return _vsp.CreateAndAddMode(name, normal_set, degen_set)
    
    @client_wrap
    def GetNumModes(self, ):
        r"""GetNumModes() -> int"""
        return _vsp.GetNumModes()
    
    @client_wrap
    def GetAllModes(self, ):
        r"""GetAllModes() -> StringVector"""
        return _vsp.GetAllModes()
    
    @client_wrap
    def DelMode(self, mid):
        r"""DelMode(string const & mid)"""
        return _vsp.DelMode(mid)
    
    @client_wrap
    def DelAllModes(self, ):
        r"""DelAllModes()"""
        return _vsp.DelAllModes()
    
    @client_wrap
    def ApplyModeSettings(self, mid):
        r"""ApplyModeSettings(string const & mid)"""
        return _vsp.ApplyModeSettings(mid)
    
    @client_wrap
    def ShowOnlyMode(self, mid):
        r"""ShowOnlyMode(string const & mid)"""
        return _vsp.ShowOnlyMode(mid)
    
    @client_wrap
    def ModeAddGroupSetting(self, mid, gid, sid):
        r"""ModeAddGroupSetting(string const & mid, string const & gid, string const & sid)"""
        return _vsp.ModeAddGroupSetting(mid, gid, sid)
    
    @client_wrap
    def ModeGetGroup(self, mid, indx):
        r"""ModeGetGroup(string const & mid, int indx) -> string"""
        return _vsp.ModeGetGroup(mid, indx)
    
    @client_wrap
    def ModeGetSetting(self, mid, indx):
        r"""ModeGetSetting(string const & mid, int indx) -> string"""
        return _vsp.ModeGetSetting(mid, indx)
    
    @client_wrap
    def ModeGetAllGroups(self, mid):
        r"""ModeGetAllGroups(string const & mid) -> StringVector"""
        return _vsp.ModeGetAllGroups(mid)
    
    @client_wrap
    def ModeGetAllSettings(self, mid):
        r"""ModeGetAllSettings(string const & mid) -> StringVector"""
        return _vsp.ModeGetAllSettings(mid)
    
    @client_wrap
    def RemoveGroupSetting(self, mid, indx):
        r"""RemoveGroupSetting(string const & mid, int indx)"""
        return _vsp.RemoveGroupSetting(mid, indx)
    
    @client_wrap
    def RemoveAllGroupSettings(self, mid):
        r"""RemoveAllGroupSettings(string const & mid)"""
        return _vsp.RemoveAllGroupSettings(mid)
    
    @client_wrap
    def SetPCurve(self, geom_id, pcurveid, tvec, valvec, newtype):
        r"""SetPCurve(std::string const & geom_id, int const & pcurveid, DoubleVector tvec, DoubleVector valvec, int const & newtype)"""
        return _vsp.SetPCurve(geom_id, pcurveid, tvec, valvec, newtype)
    
    @client_wrap
    def PCurveConvertTo(self, geom_id, pcurveid, newtype):
        r"""PCurveConvertTo(std::string const & geom_id, int const & pcurveid, int const & newtype)"""
        return _vsp.PCurveConvertTo(geom_id, pcurveid, newtype)
    
    @client_wrap
    def PCurveGetType(self, geom_id, pcurveid):
        r"""PCurveGetType(std::string const & geom_id, int const & pcurveid) -> int"""
        return _vsp.PCurveGetType(geom_id, pcurveid)
    
    @client_wrap
    def PCurveGetTVec(self, geom_id, pcurveid):
        r"""PCurveGetTVec(std::string const & geom_id, int const & pcurveid) -> DoubleVector"""
        return _vsp.PCurveGetTVec(geom_id, pcurveid)
    
    @client_wrap
    def PCurveGetValVec(self, geom_id, pcurveid):
        r"""PCurveGetValVec(std::string const & geom_id, int const & pcurveid) -> DoubleVector"""
        return _vsp.PCurveGetValVec(geom_id, pcurveid)
    
    @client_wrap
    def PCurveDeletePt(self, geom_id, pcurveid, indx):
        r"""PCurveDeletePt(std::string const & geom_id, int const & pcurveid, int const & indx)"""
        return _vsp.PCurveDeletePt(geom_id, pcurveid, indx)
    
    @client_wrap
    def PCurveSplit(self, geom_id, pcurveid, tsplit):
        r"""PCurveSplit(std::string const & geom_id, int const & pcurveid, double const & tsplit) -> int"""
        return _vsp.PCurveSplit(geom_id, pcurveid, tsplit)
    
    @client_wrap
    def ApproximateAllPropellerPCurves(self, geom_id):
        r"""ApproximateAllPropellerPCurves(std::string const & geom_id)"""
        return _vsp.ApproximateAllPropellerPCurves(geom_id)
    
    @client_wrap
    def ResetPropellerThicknessCurve(self, geom_id):
        r"""ResetPropellerThicknessCurve(std::string const & geom_id)"""
        return _vsp.ResetPropellerThicknessCurve(geom_id)
    
    @client_wrap
    def AutoGroupVSPAEROControlSurfaces(self, ):
        r"""AutoGroupVSPAEROControlSurfaces()"""
        return _vsp.AutoGroupVSPAEROControlSurfaces()
    
    @client_wrap
    def CreateVSPAEROControlSurfaceGroup(self, ):
        r"""CreateVSPAEROControlSurfaceGroup() -> int"""
        return _vsp.CreateVSPAEROControlSurfaceGroup()
    
    @client_wrap
    def AddAllToVSPAEROControlSurfaceGroup(self, CSGroupIndex):
        r"""AddAllToVSPAEROControlSurfaceGroup(int CSGroupIndex)"""
        return _vsp.AddAllToVSPAEROControlSurfaceGroup(CSGroupIndex)
    
    @client_wrap
    def RemoveAllFromVSPAEROControlSurfaceGroup(self, CSGroupIndex):
        r"""RemoveAllFromVSPAEROControlSurfaceGroup(int CSGroupIndex)"""
        return _vsp.RemoveAllFromVSPAEROControlSurfaceGroup(CSGroupIndex)
    
    @client_wrap
    def GetActiveCSNameVec(self, CSGroupIndex):
        r"""GetActiveCSNameVec(int CSGroupIndex) -> StringVector"""
        return _vsp.GetActiveCSNameVec(CSGroupIndex)
    
    @client_wrap
    def GetCompleteCSNameVec(self, ):
        r"""GetCompleteCSNameVec() -> StringVector"""
        return _vsp.GetCompleteCSNameVec()
    
    @client_wrap
    def GetAvailableCSNameVec(self, CSGroupIndex):
        r"""GetAvailableCSNameVec(int CSGroupIndex) -> StringVector"""
        return _vsp.GetAvailableCSNameVec(CSGroupIndex)
    
    @client_wrap
    def SetVSPAEROControlGroupName(self, name, CSGroupIndex):
        r"""SetVSPAEROControlGroupName(string const & name, int CSGroupIndex)"""
        return _vsp.SetVSPAEROControlGroupName(name, CSGroupIndex)
    
    @client_wrap
    def GetVSPAEROControlGroupName(self, CSGroupIndex):
        r"""GetVSPAEROControlGroupName(int CSGroupIndex) -> std::string"""
        return _vsp.GetVSPAEROControlGroupName(CSGroupIndex)
    
    @client_wrap
    def AddSelectedToCSGroup(self, selected, CSGroupIndex):
        r"""AddSelectedToCSGroup(IntVector selected, int CSGroupIndex)"""
        return _vsp.AddSelectedToCSGroup(selected, CSGroupIndex)
    
    @client_wrap
    def RemoveSelectedFromCSGroup(self, selected, CSGroupIndex):
        r"""RemoveSelectedFromCSGroup(IntVector selected, int CSGroupIndex)"""
        return _vsp.RemoveSelectedFromCSGroup(selected, CSGroupIndex)
    
    @client_wrap
    def GetNumControlSurfaceGroups(self, ):
        r"""GetNumControlSurfaceGroups() -> int"""
        return _vsp.GetNumControlSurfaceGroups()
    
    @client_wrap
    def FindActuatorDisk(self, disk_index):
        r"""FindActuatorDisk(int disk_index) -> std::string"""
        return _vsp.FindActuatorDisk(disk_index)
    
    @client_wrap
    def GetNumActuatorDisks(self, ):
        r"""GetNumActuatorDisks() -> int"""
        return _vsp.GetNumActuatorDisks()
    
    @client_wrap
    def FindUnsteadyGroup(self, group_index):
        r"""FindUnsteadyGroup(int group_index) -> std::string"""
        return _vsp.FindUnsteadyGroup(group_index)
    
    @client_wrap
    def GetUnsteadyGroupName(self, group_index):
        r"""GetUnsteadyGroupName(int group_index) -> std::string"""
        return _vsp.GetUnsteadyGroupName(group_index)
    
    @client_wrap
    def GetUnsteadyGroupCompIDs(self, group_index):
        r"""GetUnsteadyGroupCompIDs(int group_index) -> StringVector"""
        return _vsp.GetUnsteadyGroupCompIDs(group_index)
    
    @client_wrap
    def GetUnsteadyGroupSurfIndexes(self, group_index):
        r"""GetUnsteadyGroupSurfIndexes(int group_index) -> IntVector"""
        return _vsp.GetUnsteadyGroupSurfIndexes(group_index)
    
    @client_wrap
    def GetNumUnsteadyGroups(self, ):
        r"""GetNumUnsteadyGroups() -> int"""
        return _vsp.GetNumUnsteadyGroups()
    
    @client_wrap
    def GetNumUnsteadyRotorGroups(self, ):
        r"""GetNumUnsteadyRotorGroups() -> int"""
        return _vsp.GetNumUnsteadyRotorGroups()
    
    @client_wrap
    def AddExcrescence(self, excresName, excresType, excresVal):
        r"""AddExcrescence(std::string const & excresName, int const & excresType, double const & excresVal)"""
        return _vsp.AddExcrescence(excresName, excresType, excresVal)
    
    @client_wrap
    def DeleteExcrescence(self, index):
        r"""DeleteExcrescence(int const & index)"""
        return _vsp.DeleteExcrescence(index)
    
    @client_wrap
    def UpdateParasiteDrag(self, ):
        r"""UpdateParasiteDrag()"""
        return _vsp.UpdateParasiteDrag()
    
    @client_wrap
    def WriteAtmosphereCSVFile(self, file_name, atmos_type):
        r"""WriteAtmosphereCSVFile(std::string const & file_name, int const & atmos_type)"""
        return _vsp.WriteAtmosphereCSVFile(file_name, atmos_type)
    
    @client_wrap
    def CalcAtmosphere(self, alt, delta_temp, atmos_type):
        r"""CalcAtmosphere(double const & alt, double const & delta_temp, int const & atmos_type)"""
        return _vsp.CalcAtmosphere(alt, delta_temp, atmos_type)
    
    @client_wrap
    def WriteBodyFFCSVFile(self, file_name):
        r"""WriteBodyFFCSVFile(std::string const & file_name)"""
        return _vsp.WriteBodyFFCSVFile(file_name)
    
    @client_wrap
    def WriteWingFFCSVFile(self, file_name):
        r"""WriteWingFFCSVFile(std::string const & file_name)"""
        return _vsp.WriteWingFFCSVFile(file_name)
    
    @client_wrap
    def WriteCfEqnCSVFile(self, file_name):
        r"""WriteCfEqnCSVFile(std::string const & file_name)"""
        return _vsp.WriteCfEqnCSVFile(file_name)
    
    @client_wrap
    def WritePartialCfMethodCSVFile(self, file_name):
        r"""WritePartialCfMethodCSVFile(std::string const & file_name)"""
        return _vsp.WritePartialCfMethodCSVFile(file_name)
    
    @client_wrap
    def CompPnt01(self, geom_id, surf_indx, u, w):
        r"""CompPnt01(std::string const & geom_id, int const & surf_indx, double const & u, double const & w) -> vec3d"""
        return _vsp.CompPnt01(geom_id, surf_indx, u, w)
    
    @client_wrap
    def CompNorm01(self, geom_id, surf_indx, u, w):
        r"""CompNorm01(std::string const & geom_id, int const & surf_indx, double const & u, double const & w) -> vec3d"""
        return _vsp.CompNorm01(geom_id, surf_indx, u, w)
    
    @client_wrap
    def CompTanU01(self, geom_id, surf_indx, u, w):
        r"""CompTanU01(std::string const & geom_id, int const & surf_indx, double const & u, double const & w) -> vec3d"""
        return _vsp.CompTanU01(geom_id, surf_indx, u, w)
    
    @client_wrap
    def CompTanW01(self, geom_id, surf_indx, u, w):
        r"""CompTanW01(std::string const & geom_id, int const & surf_indx, double const & u, double const & w) -> vec3d"""
        return _vsp.CompTanW01(geom_id, surf_indx, u, w)
    
    @client_wrap
    def CompCurvature01(self, geom_id, surf_indx, u, w):
        r"""CompCurvature01(std::string const & geom_id, int const & surf_indx, double const & u, double const & w)"""
        return _vsp.CompCurvature01(geom_id, surf_indx, u, w)
    
    @client_wrap
    def ProjPnt01(self, geom_id, surf_indx, pt):
        r"""ProjPnt01(std::string const & geom_id, int const & surf_indx, vec3d pt) -> double"""
        return _vsp.ProjPnt01(geom_id, surf_indx, pt)
    
    @client_wrap
    def ProjPnt01I(self, geom_id, pt):
        r"""ProjPnt01I(std::string const & geom_id, vec3d pt) -> double"""
        return _vsp.ProjPnt01I(geom_id, pt)
    
    @client_wrap
    def ProjPnt01Guess(self, geom_id, surf_indx, pt, u0, w0):
        r"""ProjPnt01Guess(std::string const & geom_id, int const & surf_indx, vec3d pt, double const & u0, double const & w0) -> double"""
        return _vsp.ProjPnt01Guess(geom_id, surf_indx, pt, u0, w0)
    
    @client_wrap
    def AxisProjPnt01(self, geom_id, surf_indx, iaxis, pt):
        r"""AxisProjPnt01(std::string const & geom_id, int const & surf_indx, int const & iaxis, vec3d pt) -> double"""
        return _vsp.AxisProjPnt01(geom_id, surf_indx, iaxis, pt)
    
    @client_wrap
    def AxisProjPnt01I(self, geom_id, iaxis, pt):
        r"""AxisProjPnt01I(std::string const & geom_id, int const & iaxis, vec3d pt) -> double"""
        return _vsp.AxisProjPnt01I(geom_id, iaxis, pt)
    
    @client_wrap
    def AxisProjPnt01Guess(self, geom_id, surf_indx, iaxis, pt, u0, w0):
        r"""AxisProjPnt01Guess(std::string const & geom_id, int const & surf_indx, int const & iaxis, vec3d pt, double const & u0, double const & w0) -> double"""
        return _vsp.AxisProjPnt01Guess(geom_id, surf_indx, iaxis, pt, u0, w0)
    
    @client_wrap
    def InsideSurf(self, geom_id, surf_indx, pt):
        r"""InsideSurf(std::string const & geom_id, int const & surf_indx, vec3d pt) -> bool"""
        return _vsp.InsideSurf(geom_id, surf_indx, pt)
    
    @client_wrap
    def CompPntRST(self, geom_id, surf_indx, r, s, t):
        r"""CompPntRST(std::string const & geom_id, int const & surf_indx, double const & r, double const & s, double const & t) -> vec3d"""
        return _vsp.CompPntRST(geom_id, surf_indx, r, s, t)
    
    @client_wrap
    def FindRST(self, geom_id, surf_indx, pt):
        r"""FindRST(std::string const & geom_id, int const & surf_indx, vec3d pt) -> double"""
        return _vsp.FindRST(geom_id, surf_indx, pt)
    
    @client_wrap
    def FindRSTGuess(self, geom_id, surf_indx, pt, r0, s0, t0):
        r"""FindRSTGuess(std::string const & geom_id, int const & surf_indx, vec3d pt, double const & r0, double const & s0, double const & t0) -> double"""
        return _vsp.FindRSTGuess(geom_id, surf_indx, pt, r0, s0, t0)
    
    @client_wrap
    def ConvertRSTtoLMN(self, geom_id, surf_indx, r, s, t):
        r"""ConvertRSTtoLMN(std::string const & geom_id, int const & surf_indx, double const & r, double const & s, double const & t)"""
        return _vsp.ConvertRSTtoLMN(geom_id, surf_indx, r, s, t)
    
    @client_wrap
    def ConvertRtoL(self, geom_id, surf_indx, r):
        r"""ConvertRtoL(std::string const & geom_id, int const & surf_indx, double const & r)"""
        return _vsp.ConvertRtoL(geom_id, surf_indx, r)
    
    @client_wrap
    def ConvertLMNtoRST(self, geom_id, surf_indx, l, m, n):
        r"""ConvertLMNtoRST(std::string const & geom_id, int const & surf_indx, double const & l, double const & m, double const & n)"""
        return _vsp.ConvertLMNtoRST(geom_id, surf_indx, l, m, n)
    
    @client_wrap
    def ConvertLtoR(self, geom_id, surf_indx, l):
        r"""ConvertLtoR(std::string const & geom_id, int const & surf_indx, double const & l)"""
        return _vsp.ConvertLtoR(geom_id, surf_indx, l)
    
    @client_wrap
    def ConvertUtoEta(self, geom_id, u):
        r"""ConvertUtoEta(std::string const & geom_id, double const & u)"""
        return _vsp.ConvertUtoEta(geom_id, u)
    
    @client_wrap
    def ConvertEtatoU(self, geom_id, eta):
        r"""ConvertEtatoU(std::string const & geom_id, double const & eta)"""
        return _vsp.ConvertEtatoU(geom_id, eta)
    
    @client_wrap
    def CompVecPnt01(self, geom_id, surf_indx, u_in_vec, w_in_vec):
        r"""CompVecPnt01(std::string const & geom_id, int const & surf_indx, DoubleVector u_in_vec, DoubleVector w_in_vec) -> Vec3dVec"""
        return _vsp.CompVecPnt01(geom_id, surf_indx, u_in_vec, w_in_vec)
    
    @client_wrap
    def CompVecNorm01(self, geom_id, surf_indx, us, ws):
        r"""CompVecNorm01(std::string const & geom_id, int const & surf_indx, DoubleVector us, DoubleVector ws) -> Vec3dVec"""
        return _vsp.CompVecNorm01(geom_id, surf_indx, us, ws)
    
    @client_wrap
    def CompVecCurvature01(self, geom_id, surf_indx, us, ws):
        r"""CompVecCurvature01(std::string const & geom_id, int const & surf_indx, DoubleVector us, DoubleVector ws)"""
        return _vsp.CompVecCurvature01(geom_id, surf_indx, us, ws)
    
    @client_wrap
    def ProjVecPnt01(self, geom_id, surf_indx, pts):
        r"""ProjVecPnt01(std::string const & geom_id, int const & surf_indx, Vec3dVec pts)"""
        return _vsp.ProjVecPnt01(geom_id, surf_indx, pts)
    
    @client_wrap
    def ProjVecPnt01Guess(self, geom_id, surf_indx, pts, u0s, w0s):
        r"""ProjVecPnt01Guess(std::string const & geom_id, int const & surf_indx, Vec3dVec pts, DoubleVector u0s, DoubleVector w0s)"""
        return _vsp.ProjVecPnt01Guess(geom_id, surf_indx, pts, u0s, w0s)
    
    @client_wrap
    def AxisProjVecPnt01(self, geom_id, surf_indx, iaxis, pts):
        r"""AxisProjVecPnt01(std::string const & geom_id, int const & surf_indx, int const & iaxis, Vec3dVec pts)"""
        return _vsp.AxisProjVecPnt01(geom_id, surf_indx, iaxis, pts)
    
    @client_wrap
    def AxisProjVecPnt01Guess(self, geom_id, surf_indx, iaxis, pts, u0s, w0s):
        r"""AxisProjVecPnt01Guess(std::string const & geom_id, int const & surf_indx, int const & iaxis, Vec3dVec pts, DoubleVector u0s, DoubleVector w0s)"""
        return _vsp.AxisProjVecPnt01Guess(geom_id, surf_indx, iaxis, pts, u0s, w0s)
    
    @client_wrap
    def VecInsideSurf(self, geom_id, surf_indx, pts):
        r"""VecInsideSurf(std::string const & geom_id, int const & surf_indx, Vec3dVec pts) -> BoolVector"""
        return _vsp.VecInsideSurf(geom_id, surf_indx, pts)
    
    @client_wrap
    def CompVecPntRST(self, geom_id, surf_indx, r_in_vec, s_in_vec, t_in_vec):
        r"""CompVecPntRST(std::string const & geom_id, int const & surf_indx, DoubleVector r_in_vec, DoubleVector s_in_vec, DoubleVector t_in_vec) -> Vec3dVec"""
        return _vsp.CompVecPntRST(geom_id, surf_indx, r_in_vec, s_in_vec, t_in_vec)
    
    @client_wrap
    def FindRSTVec(self, geom_id, surf_indx, pts):
        r"""FindRSTVec(std::string const & geom_id, int const & surf_indx, Vec3dVec pts)"""
        return _vsp.FindRSTVec(geom_id, surf_indx, pts)
    
    @client_wrap
    def FindRSTVecGuess(self, geom_id, surf_indx, pts, r0s, s0s, t0s):
        r"""FindRSTVecGuess(std::string const & geom_id, int const & surf_indx, Vec3dVec pts, DoubleVector r0s, DoubleVector s0s, DoubleVector t0s)"""
        return _vsp.FindRSTVecGuess(geom_id, surf_indx, pts, r0s, s0s, t0s)
    
    @client_wrap
    def ConvertRSTtoLMNVec(self, geom_id, surf_indx, r_vec, s_vec, t_vec):
        r"""ConvertRSTtoLMNVec(std::string const & geom_id, int const & surf_indx, DoubleVector r_vec, DoubleVector s_vec, DoubleVector t_vec)"""
        return _vsp.ConvertRSTtoLMNVec(geom_id, surf_indx, r_vec, s_vec, t_vec)
    
    @client_wrap
    def ConvertLMNtoRSTVec(self, geom_id, surf_indx, l_vec, m_vec, n_vec):
        r"""ConvertLMNtoRSTVec(std::string const & geom_id, int const & surf_indx, DoubleVector l_vec, DoubleVector m_vec, DoubleVector n_vec)"""
        return _vsp.ConvertLMNtoRSTVec(geom_id, surf_indx, l_vec, m_vec, n_vec)
    
    @client_wrap
    def GetUWTess01(self, geom_id, surf_indx):
        r"""GetUWTess01(std::string const & geom_id, int const & surf_indx)"""
        return _vsp.GetUWTess01(geom_id, surf_indx)
    
    @client_wrap
    def AddRuler(self, startgeomid, startsurfindx, startu, startw, endgeomid, endsurfindx, endu, endw, name):
        r"""AddRuler(string const & startgeomid, int startsurfindx, double startu, double startw, string const & endgeomid, int endsurfindx, double endu, double endw, string const & name) -> string"""
        return _vsp.AddRuler(startgeomid, startsurfindx, startu, startw, endgeomid, endsurfindx, endu, endw, name)
    
    @client_wrap
    def GetAllRulers(self, ):
        r"""GetAllRulers() -> StringVector"""
        return _vsp.GetAllRulers()
    
    @client_wrap
    def DelRuler(self, id):
        r"""DelRuler(string const & id)"""
        return _vsp.DelRuler(id)
    
    @client_wrap
    def DeleteAllRulers(self, ):
        r"""DeleteAllRulers()"""
        return _vsp.DeleteAllRulers()
    
    @client_wrap
    def AddProbe(self, geomid, surfindx, u, w, name):
        r"""AddProbe(string const & geomid, int surfindx, double u, double w, string const & name) -> string"""
        return _vsp.AddProbe(geomid, surfindx, u, w, name)
    
    @client_wrap
    def GetAllProbes(self, ):
        r"""GetAllProbes() -> StringVector"""
        return _vsp.GetAllProbes()
    
    @client_wrap
    def DelProbe(self, id):
        r"""DelProbe(string const & id)"""
        return _vsp.DelProbe(id)
    
    @client_wrap
    def DeleteAllProbes(self, ):
        r"""DeleteAllProbes()"""
        return _vsp.DeleteAllProbes()
    
    @client_wrap
    def GetAdvLinkNames(self, ):
        r"""GetAdvLinkNames() -> StringVector"""
        return _vsp.GetAdvLinkNames()
    
    @client_wrap
    def GetLinkIndex(self, name):
        r"""GetLinkIndex(string const & name) -> int"""
        return _vsp.GetLinkIndex(name)
    
    @client_wrap
    def DelAdvLink(self, index):
        r"""DelAdvLink(int index)"""
        return _vsp.DelAdvLink(index)
    
    @client_wrap
    def DelAllAdvLinks(self, ):
        r"""DelAllAdvLinks()"""
        return _vsp.DelAllAdvLinks()
    
    @client_wrap
    def AddAdvLink(self, name):
        r"""AddAdvLink(string const & name)"""
        return _vsp.AddAdvLink(name)
    
    @client_wrap
    def AddAdvLinkInput(self, index, parm_id, var_name):
        r"""AddAdvLinkInput(int index, string const & parm_id, string const & var_name)"""
        return _vsp.AddAdvLinkInput(index, parm_id, var_name)
    
    @client_wrap
    def AddAdvLinkOutput(self, index, parm_id, var_name):
        r"""AddAdvLinkOutput(int index, string const & parm_id, string const & var_name)"""
        return _vsp.AddAdvLinkOutput(index, parm_id, var_name)
    
    @client_wrap
    def DelAdvLinkInput(self, index, var_name):
        r"""DelAdvLinkInput(int index, string const & var_name)"""
        return _vsp.DelAdvLinkInput(index, var_name)
    
    @client_wrap
    def DelAdvLinkOutput(self, index, var_name):
        r"""DelAdvLinkOutput(int index, string const & var_name)"""
        return _vsp.DelAdvLinkOutput(index, var_name)
    
    @client_wrap
    def GetAdvLinkInputNames(self, index):
        r"""GetAdvLinkInputNames(int index) -> StringVector"""
        return _vsp.GetAdvLinkInputNames(index)
    
    @client_wrap
    def GetAdvLinkInputParms(self, index):
        r"""GetAdvLinkInputParms(int index) -> StringVector"""
        return _vsp.GetAdvLinkInputParms(index)
    
    @client_wrap
    def GetAdvLinkOutputNames(self, index):
        r"""GetAdvLinkOutputNames(int index) -> StringVector"""
        return _vsp.GetAdvLinkOutputNames(index)
    
    @client_wrap
    def GetAdvLinkOutputParms(self, index):
        r"""GetAdvLinkOutputParms(int index) -> StringVector"""
        return _vsp.GetAdvLinkOutputParms(index)
    
    @client_wrap
    def ValidateAdvLinkParms(self, index):
        r"""ValidateAdvLinkParms(int index) -> bool"""
        return _vsp.ValidateAdvLinkParms(index)
    
    @client_wrap
    def SetAdvLinkCode(self, index, code):
        r"""SetAdvLinkCode(int index, string const & code)"""
        return _vsp.SetAdvLinkCode(index, code)
    
    @client_wrap
    def GetAdvLinkCode(self, index):
        r"""GetAdvLinkCode(int index) -> std::string"""
        return _vsp.GetAdvLinkCode(index)
    
    @client_wrap
    def SearchReplaceAdvLinkCode(self, index, _from, to):
        r"""SearchReplaceAdvLinkCode(int index, string const & _from, string const & to)"""
        return _vsp.SearchReplaceAdvLinkCode(index, _from, to)
    
    @client_wrap
    def BuildAdvLinkScript(self, index):
        r"""BuildAdvLinkScript(int index) -> bool"""
        return _vsp.BuildAdvLinkScript(index)
    
    @client_wrap
    def AddVec3D(self, INOUT, x, y, z):
        r"""AddVec3D(Vec3dVec INOUT, double x, double y, double z)"""
        return _vsp.AddVec3D(INOUT, x, y, z)
    # Register vec3d in _vsp:
        self.cvar = _vsp.cvar
        
    @client_wrap
    def dist(self, a, b):
        r"""dist(vec3d a, vec3d b) -> double"""
        return _vsp.dist(a, b)
    
    @client_wrap
    def dist_squared(self, a, b):
        r"""dist_squared(vec3d a, vec3d b) -> double"""
        return _vsp.dist_squared(a, b)
    
    @client_wrap
    def dot(self, a, b):
        r"""dot(vec3d a, vec3d b) -> double"""
        return _vsp.dot(a, b)
    
    @client_wrap
    def cross(self, a, b):
        r"""cross(vec3d a, vec3d b) -> vec3d"""
        return _vsp.cross(a, b)
    
    @client_wrap
    def angle(self, a, b):
        r"""angle(vec3d a, vec3d b) -> double"""
        return _vsp.angle(a, b)
    
    @client_wrap
    def signed_angle(self, a, b, ref):
        r"""signed_angle(vec3d a, vec3d b, vec3d ref) -> double"""
        return _vsp.signed_angle(a, b, ref)
    
    @client_wrap
    def cos_angle(self, a, b):
        r"""cos_angle(vec3d a, vec3d b) -> double"""
        return _vsp.cos_angle(a, b)
    
    @client_wrap
    def radius_of_circle(self, p1, p2, p3):
        r"""radius_of_circle(vec3d p1, vec3d p2, vec3d p3) -> double"""
        return _vsp.radius_of_circle(p1, p2, p3)
    
    @client_wrap
    def center_of_circle(self, p1, p2, p3, center):
        r"""center_of_circle(vec3d p1, vec3d p2, vec3d p3, vec3d center)"""
        return _vsp.center_of_circle(p1, p2, p3, center)
    
    @client_wrap
    def dist_pnt_2_plane(self, org, norm, pnt):
        r"""dist_pnt_2_plane(vec3d org, vec3d norm, vec3d pnt) -> double"""
        return _vsp.dist_pnt_2_plane(org, norm, pnt)
    
    @client_wrap
    def dist_pnt_2_line(self, line_pt1, line_pt2, pnt):
        r"""dist_pnt_2_line(vec3d line_pt1, vec3d line_pt2, vec3d pnt) -> double"""
        return _vsp.dist_pnt_2_line(line_pt1, line_pt2, pnt)
    
    @client_wrap
    def proj_pnt_on_line_seg(self, line_pt1, line_pt2, pnt):
        r"""proj_pnt_on_line_seg(vec3d line_pt1, vec3d line_pt2, vec3d pnt) -> vec3d"""
        return _vsp.proj_pnt_on_line_seg(line_pt1, line_pt2, pnt)
    
    @client_wrap
    def proj_pnt_on_ray(self, line_pt1, line_pt2, pnt):
        r"""proj_pnt_on_ray(vec3d line_pt1, vec3d line_pt2, vec3d pnt) -> vec3d"""
        return _vsp.proj_pnt_on_ray(line_pt1, line_pt2, pnt)
    
    @client_wrap
    def proj_pnt_on_line(self, line_pt1, line_pt2, pnt):
        r"""proj_pnt_on_line(vec3d line_pt1, vec3d line_pt2, vec3d pnt) -> vec3d"""
        return _vsp.proj_pnt_on_line(line_pt1, line_pt2, pnt)
    
    @client_wrap
    def proj_pnt_to_plane(self, org, plane_ln1, plane_ln2, pnt):
        r"""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)
    
    @client_wrap
    def proj_vec_to_plane(self, vec, norm):
        r"""proj_vec_to_plane(vec3d vec, vec3d norm) -> vec3d"""
        return _vsp.proj_vec_to_plane(vec, norm)
    
    @client_wrap
    def tri_seg_intersect(self, A, B, C, D, E, u, w, t):
        r"""tri_seg_intersect(vec3d A, vec3d B, vec3d C, vec3d D, vec3d E, double & u, double & w, double & t) -> int"""
        return _vsp.tri_seg_intersect(A, B, C, D, E, u, w, t)
    
    @client_wrap
    def tri_ray_intersect(self, A, B, C, D, E, u, w, t):
        r"""tri_ray_intersect(vec3d A, vec3d B, vec3d C, vec3d D, vec3d E, double & u, double & w, double & t) -> int"""
        return _vsp.tri_ray_intersect(A, B, C, D, E, u, w, t)
    
    @client_wrap
    def plane_ray_intersect(self, *args):
        r"""
        plane_ray_intersect(vec3d A, vec3d B, vec3d C, vec3d D, vec3d E, double & t) -> int
        plane_ray_intersect(vec3d orig, vec3d norm, vec3d D, vec3d E, double & t) -> int
        """
        return _vsp.plane_ray_intersect(*args)
    
    @client_wrap
    def ray_ray_intersect(self, A, B, C, D, int_pnt1, int_pnt2):
        r"""ray_ray_intersect(vec3d A, vec3d B, vec3d C, vec3d D, vec3d int_pnt1, vec3d int_pnt2) -> int"""
        return _vsp.ray_ray_intersect(A, B, C, D, int_pnt1, int_pnt2)
    
    @client_wrap
    def tetra_volume(self, A, B, C):
        r"""tetra_volume(vec3d A, vec3d B, vec3d C) -> double"""
        return _vsp.tetra_volume(A, B, C)
    
    @client_wrap
    def area(self, A, B, C):
        r"""area(vec3d A, vec3d B, vec3d C) -> double"""
        return _vsp.area(A, B, C)
    
    @client_wrap
    def poly_area(self, pnt_vec):
        r"""poly_area(Vec3dVec pnt_vec) -> double"""
        return _vsp.poly_area(pnt_vec)
    
    @client_wrap
    def dist3D_Segment_to_Segment(self, *args):
        r"""
        dist3D_Segment_to_Segment(vec3d S1P0, vec3d S1P1, vec3d S2P0, vec3d S2P1) -> double
        dist3D_Segment_to_Segment(vec3d S1P0, vec3d S1P1, vec3d S2P0, vec3d S2P1, double * Lt, vec3d Ln, double * St, vec3d Sn) -> double
        """
        return _vsp.dist3D_Segment_to_Segment(*args)
    
    @client_wrap
    def nearSegSeg(self, L0, L1, S0, S1, Lt, Ln, St, Sn):
        r"""nearSegSeg(vec3d L0, vec3d L1, vec3d S0, vec3d S1, double * Lt, vec3d Ln, double * St, vec3d Sn) -> double"""
        return _vsp.nearSegSeg(L0, L1, S0, S1, Lt, Ln, St, Sn)
    
    @client_wrap
    def pointLineDistSquared(self, p, lp0, lp1, t):
        r"""pointLineDistSquared(vec3d p, vec3d lp0, vec3d lp1, double * t) -> double"""
        return _vsp.pointLineDistSquared(p, lp0, lp1, t)
    
    @client_wrap
    def pointSegDistSquared(self, p, sp0, sp1, t):
        r"""pointSegDistSquared(vec3d p, vec3d sp0, vec3d sp1, double * t) -> double"""
        return _vsp.pointSegDistSquared(p, sp0, sp1, t)
    
    @client_wrap
    def point_on_line(self, lp0, lp1, t):
        r"""point_on_line(vec3d lp0, vec3d lp1, double const & t) -> vec3d"""
        return _vsp.point_on_line(lp0, lp1, t)
    
    @client_wrap
    def MapToPlane(self, p, planeOrig, planeVec1, planeVec2):
        r"""MapToPlane(vec3d p, vec3d planeOrig, vec3d planeVec1, vec3d planeVec2) -> vec2d"""
        return _vsp.MapToPlane(p, planeOrig, planeVec1, planeVec2)
    
    @client_wrap
    def MapFromPlane(self, uw, planeOrig, planeVec1, planeVec2):
        r"""MapFromPlane(vec2d const & uw, vec3d planeOrig, vec3d planeVec1, vec3d planeVec2) -> vec3d"""
        return _vsp.MapFromPlane(uw, planeOrig, planeVec1, planeVec2)
    
    @client_wrap
    def plane_half_space(self, planeOrig, planeNorm, pnt):
        r"""plane_half_space(vec3d planeOrig, vec3d planeNorm, vec3d pnt) -> int"""
        return _vsp.plane_half_space(planeOrig, planeNorm, pnt)
    
    @client_wrap
    def line_line_intersect(self, p1, p2, p3, p4, s, t):
        r"""line_line_intersect(vec3d p1, vec3d p2, vec3d p3, vec3d p4, double * s, double * t) -> bool"""
        return _vsp.line_line_intersect(p1, p2, p3, p4, s, t)
    
    @client_wrap
    def RotateArbAxis(self, p, theta, r):
        r"""RotateArbAxis(vec3d p, double theta, vec3d r) -> vec3d"""
        return _vsp.RotateArbAxis(p, theta, r)
    
    @client_wrap
    def PtInTri(self, v0, v1, v2, p):
        r"""PtInTri(vec3d v0, vec3d v1, vec3d v2, vec3d p) -> bool"""
        return _vsp.PtInTri(v0, v1, v2, p)
    
    @client_wrap
    def BarycentricWeights(self, v0, v1, v2, p):
        r"""BarycentricWeights(vec3d v0, vec3d v1, vec3d v2, vec3d p) -> vec3d"""
        return _vsp.BarycentricWeights(v0, v1, v2, p)
    
    @client_wrap
    def BilinearWeights(self, p0, p1, p, weights):
        r"""BilinearWeights(vec3d p0, vec3d p1, vec3d p, DoubleVector weights)"""
        return _vsp.BilinearWeights(p0, p1, p, weights)
    
    @client_wrap
    def tri_tri_min_dist(self, v0, v1, v2, v3, v4, v5):
        r"""tri_tri_min_dist(vec3d v0, vec3d v1, vec3d v2, vec3d v3, vec3d v4, vec3d v5) -> double"""
        return _vsp.tri_tri_min_dist(v0, v1, v2, v3, v4, v5)
    
    @client_wrap
    def pnt_tri_min_dist(self, v0, v1, v2, pnt):
        r"""pnt_tri_min_dist(vec3d v0, vec3d v1, vec3d v2, vec3d pnt) -> double"""
        return _vsp.pnt_tri_min_dist(v0, v1, v2, pnt)
    
    @client_wrap
    def slerp(self, a, b, t):
        r"""slerp(vec3d a, vec3d b, double const & t) -> vec3d"""
        return _vsp.slerp(a, b, t)
    
    
    @client_wrap
    def to_string(self, v):
        r"""to_string(vec3d v) -> std::string"""
        return _vsp.to_string(v)
    # Register Matrix4d in _vsp:
    
    @client_wrap
    def Matrix4d_setIdentity(self, m):
        r"""Matrix4d_setIdentity(double * m)"""
        return _vsp.Matrix4d_setIdentity(m)
    
    
    

    # function to send and recieve data from the facade server
    def _send_recieve(self, func_name, args, kwargs):
        b_data = pack_data([func_name, args, kwargs], True)
        self.sock.sendall(b_data)
        result = None
        b_result = []
        while True:
            packet = self.sock.recv(202400)
            if not packet: break
            b_result.append(packet)
            try:
                result = unpack_data(b_result)
                break
            except:
                pass
        if isinstance(result, list) and result[0] == "error":
            sys.excepthook = _exception_hook
            raise Exception(result[1])
        return result

    def IsFacade(self):
        """
        Returns True if the facade API is in use.


        .. code-block:: python

            is_facade = IsFacade()

        """

        return True
    def IsGUIRunning(self):
        """
        Returns True if the GUI event loop is running.


        .. code-block:: python

            is_gui_active = IsGUIRunning()

        """

        return self._send_recieve('IsGUIRunning', [], {})
class _server_controller():
    def __init__(self) -> None:
        print("server controller initialized")
        self._servers = {}
        self.name_num = 1
    def start_vsp_instance(self, name=None) -> _vsp_server:

        if not name:
            name = f"default_name_{self.name_num}"
            while name in self._servers:
                self.name_num += 1
                name = f"default_name_{self.name_num}"

        assert isinstance(name,str), "Name must be a string"
        assert not name in self._servers, f"Server with name {name} already exists"

        self._servers[name] = new_server = _vsp_server(name)

        return new_server

    def get_vsp_instance(self, name):
        return self._servers[name]

    def close_vsp_instance(self, name):
        del self._servers[name]

from openvsp.vsp import ErrorObj
from openvsp.vsp import ErrorMgrSingleton
from openvsp.vsp import vec3d
from openvsp.vsp import Matrix4d
vsp_servers = _server_controller()
