# openvsp package

## degen geom parse

## parasite drag

## surface patches

## utilities

## vsp

`openvsp.vsp.``ABS` = 0

  Absolute position

`openvsp.vsp.``ALIGN_BOTTOM` = 6

  Align to bottom

`openvsp.vsp.``ALIGN_CENTER` = 1

  Align to center

`openvsp.vsp.``ALIGN_LEFT` = 0

  Align to left

`openvsp.vsp.``ALIGN_MIDDLE` = 5

  Align to middle

`openvsp.vsp.``ALIGN_PIXEL` = 3

  Align to specified pixel

`openvsp.vsp.``ALIGN_RIGHT` = 2

  Align to right

`openvsp.vsp.``ALIGN_TOP` = 4

  Align to top

`openvsp.vsp.``ALL_GDEV_TYPES` = 31

  Flag for all GDEV types

`openvsp.vsp.``ALL_GEOM_SCREENS` = 17

  All geom screens

`openvsp.vsp.``ANG_0` = 0

  Zero deg

`openvsp.vsp.``ANG_180` = 2

  180 deg

`openvsp.vsp.``ANG_270` = 3

  270 deg

`openvsp.vsp.``ANG_90` = 1

  90 deg

`openvsp.vsp.``ANG_DEG` = 1

  Degrees

`openvsp.vsp.``ANG_RAD` = 0

  Radians

`openvsp.vsp.``APPROX_CEDIT` = 3

  Approximate curve as Cubic Bezier

`openvsp.vsp.``AREA_WSECT_DRIVER` = 2

  Area driver

`openvsp.vsp.``AR_WSECT_DRIVER` = 0

  Aspect ratio driver

`openvsp.vsp.``ATMOS_TYPE_HERRINGTON_1966` = 1

  USAF 1966

`openvsp.vsp.``ATMOS_TYPE_MANUAL_P_R` = 2

  Manual: pressure and density control

`openvsp.vsp.``ATMOS_TYPE_MANUAL_P_T` = 3

  Manual: pressure and temperature control

`openvsp.vsp.``ATMOS_TYPE_MANUAL_RE_L` = 5

  Manual: Reynolds number and length control

`openvsp.vsp.``ATMOS_TYPE_MANUAL_R_T` = 4

  Manual: density and temperature control

`openvsp.vsp.``ATMOS_TYPE_US_STANDARD_1976` = 0

  US Standard Atmosphere 1976 (default)

`openvsp.vsp.``ATTACH_ROT_COMP` = 1

  Rotation relative to parent body axes

`openvsp.vsp.``ATTACH_ROT_EtaMN` = 5

  Rotation relative to wing parent eta volume coordinate frame

`openvsp.vsp.``ATTACH_ROT_LMN` = 4

  Rotation relative to parent uniform volume coordinate frame

`openvsp.vsp.``ATTACH_ROT_NONE` = 0

  No parent attachment for rotations

`openvsp.vsp.``ATTACH_ROT_NUM_TYPES` = 6

  Number of rotation attachment types

`openvsp.vsp.``ATTACH_ROT_RST` = 3

  Rotation relative to parent per-section volume coordinate frame

`openvsp.vsp.``ATTACH_ROT_UV` = 2

  Rotation relative to parent surface coordinate frame

`openvsp.vsp.``ATTACH_TRANS_COMP` = 1

  Translation relative to parent body axes

`openvsp.vsp.``ATTACH_TRANS_EtaMN` = 5

  Translation relative to wing parent uniform eta volume coordinate frame

`openvsp.vsp.``ATTACH_TRANS_LMN` = 4

  Translation relative to parent uniform volume coordinate frame

`openvsp.vsp.``ATTACH_TRANS_NONE` = 0

  No parent attachment for translations

`openvsp.vsp.``ATTACH_TRANS_NUM_TYPES` = 6

  Number of translation attachment types

`openvsp.vsp.``ATTACH_TRANS_RST` = 3

  Translation relative to parent per-section volume coordinate frame

`openvsp.vsp.``ATTACH_TRANS_UV` = 2

  Translation relative to parent surface coordinate frame

`openvsp.vsp.``AVEC_WSECT_DRIVER` = 4

  Average chord driver

`openvsp.vsp.``AddAdvLink`(string const & name)

`openvsp.vsp.``AddAdvLinkInput`(int index, string const & parm_id, string const & var_name)

`openvsp.vsp.``AddAdvLinkOutput`(int index, string const & parm_id, string const & var_name)

`openvsp.vsp.``AddAllToVSPAEROControlSurfaceGroup`(int CSGroupIndex)

`openvsp.vsp.``AddBackground3D`() → string

`openvsp.vsp.``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)

`openvsp.vsp.``AddDefaultSources`()

`openvsp.vsp.``AddDesignVar`(std::string const & parm_id, int type)

`openvsp.vsp.``AddExcrescence`(std::string const & excresName, int const & excresType, double const & excresVal)

`openvsp.vsp.``AddFeaBC`(string const & fea_struct_id, int type=-1) → std::string

`openvsp.vsp.``AddFeaMaterial`() → std::string

`openvsp.vsp.``AddFeaPart`(std::string const & geom_id, int fea_struct_ind, int type) → std::string

`openvsp.vsp.``AddFeaProperty`(int property_type=0) → std::string

`openvsp.vsp.``AddFeaStruct`(std::string const & geom_id, bool init_skin=True, int surfindex=0) → int

`openvsp.vsp.``AddFeaSubSurf`(std::string const & geom_id, int fea_struct_ind, int type) → std::string

`openvsp.vsp.``AddGeom`(std::string const & type, std::string const & parent=std::string()) → std::string

`openvsp.vsp.``AddMaterial`(string const & name, vec3d ambient, vec3d diffuse, vec3d specular, vec3d emissive, double const & alpha, double const & shininess)

`openvsp.vsp.``AddProbe`(string const & geomid, int surfindx, double u, double w, string const & name) → string

`openvsp.vsp.``AddRuler`(string const & startgeomid, int startsurfindx, double startu, double startw, string const & endgeomid, int endsurfindx, double endu, double endw, string const & name) → string

`openvsp.vsp.``AddSelectedToCSGroup`(IntVector selected, int CSGroupIndex)

`openvsp.vsp.``AddSubSurf`(std::string const & geom_id, int type, int surfindex=0) → std::string

`openvsp.vsp.``AddUserParm`(int type, string const & name, string const & group) → string

`openvsp.vsp.``AddVarPresetGroup`(std::string const & group_name)

`openvsp.vsp.``AddVarPresetParm`(std::string const & parm_id)

  AddVarPresetParm(std::string const & parm_id, std::string const & group_name)

`openvsp.vsp.``AddVarPresetSetting`(std::string const & setting_name)

`openvsp.vsp.``AddVec3D`(Vec3dVec INOUT, double x, double y, double z)

`openvsp.vsp.``ApproximateAllPropellerPCurves`(std::string const & geom_id)

`openvsp.vsp.``AutoGroupVSPAEROControlSurfaces`()

`openvsp.vsp.``AxisProjPnt01`(std::string const & geom_id, int const & surf_indx, int const & iaxis, vec3d pt) → double

`openvsp.vsp.``AxisProjPnt01Guess`(std::string const & geom_id, int const & surf_indx, int const & iaxis, vec3d pt, double const & u0, double const & w0) → double

`openvsp.vsp.``AxisProjPnt01I`(std::string const & geom_id, int const & iaxis, vec3d pt) → double

`openvsp.vsp.``AxisProjVecPnt01`(std::string const & geom_id, int const & surf_indx, int const & iaxis, Vec3dVec pts)

`openvsp.vsp.``AxisProjVecPnt01Guess`(std::string const & geom_id, int const & surf_indx, int const & iaxis, Vec3dVec pts, DoubleVector u0s, DoubleVector w0s)

`openvsp.vsp.``BEZIER_AF_EXPORT` = 1

  Bezier airfoil file format

`openvsp.vsp.``BFT_UNIT` = 3

  FEA Files output in (ft, slug)

`openvsp.vsp.``BIN_UNIT` = 4

  FEA Files output in (in, lbf*sec^2/in)

`openvsp.vsp.``BLANK_GEOM_SCREEN` = 3

  Blank geom screen

`openvsp.vsp.``BLEND_ANGLES` = 1

  Blend based on angles (sweep & dihedral)

`openvsp.vsp.``BLEND_FREE` = 0

  Free blending

`openvsp.vsp.``BLEND_MATCH_IN_ANGLES` = 6

  Match inboard angles

`openvsp.vsp.``BLEND_MATCH_IN_LE_TRAP` = 2

  Match inboard leading edge trapezoid

`openvsp.vsp.``BLEND_MATCH_IN_TE_TRAP` = 3

  Match inboard trailing edge trapezoid

`openvsp.vsp.``BLEND_MATCH_LE_ANGLES` = 7

  Match leading edge angles

`openvsp.vsp.``BLEND_MATCH_OUT_LE_TRAP` = 4

  Match outboard leading edge trapezoid

`openvsp.vsp.``BLEND_MATCH_OUT_TE_TRAP` = 5

  Match outboard trailing edge trapezoid

`openvsp.vsp.``BLEND_NUM_TYPES` = 8

  Number of blending types

`openvsp.vsp.``BOR_FLOWTHROUGH` = 0

  Flowthrough mode (default)

`openvsp.vsp.``BOR_GEOM_SCREEN` = 13

  Body of revolution geom screen

`openvsp.vsp.``BOR_LOWER` = 2

  Lower surface mode

`openvsp.vsp.``BOR_NUM_MODES` = 3

  Number of Body of Revolution modes

`openvsp.vsp.``BOR_UPPER` = 1

  Upper surface mode

`openvsp.vsp.``BOX_SOURCE` = 2

  Box source

`openvsp.vsp.``BarycentricWeights`(vec3d v0, vec3d v1, vec3d v2, vec3d p) → vec3d

`openvsp.vsp.``BilinearWeights`(vec3d p0, vec3d p1, vec3d p, DoubleVector weights)

class `openvsp.vsp.``BoolVector`(*args)

  Bases: `object`

  `append`(x)
  `assign`(n, x)
  `back`()
  `begin`()
  `capacity`()
  `clear`()
  `empty`()
  `end`()
  `erase`(*args)
  `front`()
  `get_allocator`()
  `insert`(*args)
  `iterator`()
  `pop`()
  `pop_back`()
  `push_back`(x)
  `rbegin`()
  `rend`()
  `reserve`(n)
  `resize`(*args)
  `size`()
  `swap`(v)
  property `thisown`

    The membership flag

`openvsp.vsp.``BuildAdvLinkScript`(int index) → bool

`openvsp.vsp.``CAM_BOTTOM` = 5

  Camera bottom view

`openvsp.vsp.``CAM_CENTER` = 9

  Camera center view

`openvsp.vsp.``CAM_FRONT` = 1

  Camera front view

`openvsp.vsp.``CAM_FRONT_YUP` = 2

  Camera front Y-up view

`openvsp.vsp.``CAM_LEFT` = 3

  Camera left view

`openvsp.vsp.``CAM_LEFT_ISO` = 4

  Camera left isometric view

`openvsp.vsp.``CAM_REAR` = 6

  Camera rear view

`openvsp.vsp.``CAM_RIGHT` = 7

  Camera right view

`openvsp.vsp.``CAM_RIGHT_ISO` = 8

  Camera right isometric view

`openvsp.vsp.``CAM_TOP` = 0

  Camera top view

`openvsp.vsp.``CEDIT` = 2

  Cubic Bezier curve type

`openvsp.vsp.``CFD_DAT_FILE_NAME` = 4

  DAT export type

`openvsp.vsp.``CFD_FACET_FILE_NAME` = 8

  FACET export type

`openvsp.vsp.``CFD_FAR_FIELD_FLAG` = 8

  Flag to generate a far field mesh

`openvsp.vsp.``CFD_FAR_HEIGHT` = 15

  Far field height

`openvsp.vsp.``CFD_FAR_LENGTH` = 13

  Far field length

`openvsp.vsp.``CFD_FAR_LOC_MAN_FLAG` = 19

  Far field location flag: centered or manual

`openvsp.vsp.``CFD_FAR_LOC_X` = 20

  Far field X location

`openvsp.vsp.``CFD_FAR_LOC_Y` = 21

  Far field Y location

`openvsp.vsp.``CFD_FAR_LOC_Z` = 22

  Far field Z location

`openvsp.vsp.``CFD_FAR_MAX_EDGE_LEN` = 9

  Maximum far field mesh edge length

`openvsp.vsp.``CFD_FAR_MAX_GAP` = 10

  Maximum far field mesh edge gap

`openvsp.vsp.``CFD_FAR_NUM_CIRCLE_SEGS` = 11

  Number of far field edge segments to resolve circle

`openvsp.vsp.``CFD_FAR_SIZE_ABS_FLAG` = 12

  Relative or absolute size flag

`openvsp.vsp.``CFD_FAR_WIDTH` = 14

  Far field width

`openvsp.vsp.``CFD_FAR_X_SCALE` = 16

  Far field X scale

`openvsp.vsp.``CFD_FAR_Y_SCALE` = 17

  Far field Y scale

`openvsp.vsp.``CFD_FAR_Z_SCALE` = 18

  Far field Z scale

`openvsp.vsp.``CFD_GMSH_FILE_NAME` = 6

  GMSH export type

`openvsp.vsp.``CFD_GROWTH_RATIO` = 4

  Maximum allowed edge growth ratio

`openvsp.vsp.``CFD_HALF_MESH_FLAG` = 7

  Flag to generate a half mesh

`openvsp.vsp.``CFD_INTERSECT_SUBSURFACE_FLAG` = 6

  Flag to intersect sub-surfaces

`openvsp.vsp.``CFD_KEY_FILE_NAME` = 5

  KEY export type

`openvsp.vsp.``CFD_LIMIT_GROWTH_FLAG` = 5

  Rigorous 3D growth limiting flag

`openvsp.vsp.``CFD_MAX_EDGE_LEN` = 1

  Maximum mesh edge length

`openvsp.vsp.``CFD_MAX_GAP` = 2

  Maximum mesh edge gap

`openvsp.vsp.``CFD_MEASURE_DUCT` = 5

  Measure duct cross sectional area surface

`openvsp.vsp.``CFD_MIN_EDGE_LEN` = 0

  Minimum mesh edge length

`openvsp.vsp.``CFD_NEGATIVE` = 1

  Negative volume CFD Mesh surface

`openvsp.vsp.``CFD_NORMAL` = 0

  Normal CFD Mesh surface

`openvsp.vsp.``CFD_NUM_CIRCLE_SEGS` = 3

  Number of edge segments to resolve circle

`openvsp.vsp.``CFD_NUM_FILE_NAMES` = 10

  Number of CFD Mesh export file types

`openvsp.vsp.``CFD_NUM_TYPES` = 6

  Number of CFD Mesh surface types

`openvsp.vsp.``CFD_OBJ_FILE_NAME` = 3

  OBJ export type

`openvsp.vsp.``CFD_POLY_FILE_NAME` = 1

  POLY export type

`openvsp.vsp.``CFD_SRF_XYZ_FLAG` = 23

  Flag to include X,Y,Z intersection curves in export files

`openvsp.vsp.``CFD_STIFFENER` = 4

  FEA stiffener CFD Mesh surface

`openvsp.vsp.``CFD_STL_FILE_NAME` = 0

  STL export type

`openvsp.vsp.``CFD_STRUCTURE` = 3

  FEA structure CFD Mesh surface

`openvsp.vsp.``CFD_TKEY_FILE_NAME` = 7

  TKEY export type

`openvsp.vsp.``CFD_TRANSPARENT` = 2

  Transparent CFD Mesh surface

`openvsp.vsp.``CFD_TRI_FILE_NAME` = 2

  TRI export type

`openvsp.vsp.``CFD_VSPGEOM_FILE_NAME` = 9

  VSPGEOM export type

`openvsp.vsp.``CF_LAM_BLASIUS` = 0

  Blasius laminar Cf equation

`openvsp.vsp.``CF_LAM_BLASIUS_W_HEAT` = 1

  Blasius laminar Cf equation with heat (NOT IMPLEMENTED)

`openvsp.vsp.``CF_TURB_EXPLICIT_FIT_SCHOENHERR` = 2

  Explicit Fit of Schoenherr turbulent Cf equation

`openvsp.vsp.``CF_TURB_EXPLICIT_FIT_SPALDING` = 0

  Explicit Fit of Spalding turbulent Cf equation

`openvsp.vsp.``CF_TURB_EXPLICIT_FIT_SPALDING_CHI` = 1

  Explicit Fit of Spalding and Chi turbulent Cf equation

`openvsp.vsp.``CF_TURB_HEATTRANSFER_WHITE_CHRISTOPH` = 20

  Heat Transfer White-Christoph turbulent Cf equation.

`openvsp.vsp.``CF_TURB_IMPLICIT_KARMAN_SCHOENHERR` = 5

  Implicit Karman-Schoenherr turbulent Cf equation

`openvsp.vsp.``CF_TURB_IMPLICIT_SCHOENHERR` = 4

  Implicit Schoenherr turbulent Cf equation

`openvsp.vsp.``CF_TURB_POWER_LAW_BLASIUS` = 6

  Power Law Blasius turbulent Cf equation

`openvsp.vsp.``CF_TURB_POWER_LAW_PRANDTL_HIGH_RE` = 9

  Power Law Prandtl High Re turbulent Cf equation

`openvsp.vsp.``CF_TURB_POWER_LAW_PRANDTL_LOW_RE` = 7

  Power Law Prandtl Low Re turbulent Cf equation

`openvsp.vsp.``CF_TURB_POWER_LAW_PRANDTL_MEDIUM_RE` = 8

  Power Law Prandtl Medium Re turbulent Cf equation

`openvsp.vsp.``CF_TURB_ROUGHNESS_SCHLICHTING_AVG` = 16

  Roughness Schlichting Avg turbulent Cf equation.

`openvsp.vsp.``CF_TURB_ROUGHNESS_SCHLICHTING_AVG_FLOW_CORRECTION` = 19

  Roughness Schlichting Avg Compressible turbulent Cf equation.

`openvsp.vsp.``CF_TURB_SCHLICHTING_COMPRESSIBLE` = 10

  Schlichting Compressible turbulent Cf equation

`openvsp.vsp.``CF_TURB_SCHULTZ_GRUNOW_SCHOENHERR` = 14

  Schultz-Grunow Estimate of Schoenherr turbulent Cf equation.

`openvsp.vsp.``CGS_UNIT` = 1

  FEA Files output in (cm, g)

`openvsp.vsp.``CHEVRON_FULL` = 2

  Full period of chevrons.

`openvsp.vsp.``CHEVRON_NONE` = 0

  No chevron.

`openvsp.vsp.``CHEVRON_NUM_TYPES` = 3

  Number of chevron types.

`openvsp.vsp.``CHEVRON_PARTIAL` = 1

  One or more chevrons of limited extent.

`openvsp.vsp.``CHEVRON_W01_NUM_MODES` = 2

  Number of chevron W parameter mode types.

`openvsp.vsp.``CLMAX_2D` = 1

  2D Cl Max stall modeling with user defined value

`openvsp.vsp.``CLMAX_CARLSON` = 2

  Carlson’s Pressure Correlation

`openvsp.vsp.``CLMAX_OFF` = 0

  Stall modeling off (Cl Max = 0)

`openvsp.vsp.``CLOSE_EXTRAP` = 4

  Extrapolate closure

`openvsp.vsp.``CLOSE_NONE` = 0

  No closure

`openvsp.vsp.``CLOSE_NUM_TYPES` = 5

  Number of XSec closure types

`openvsp.vsp.``CLOSE_SKEWBOTH` = 3

  Skew both closure

`openvsp.vsp.``CLOSE_SKEWLOW` = 1

  Skew lower closure

`openvsp.vsp.``CLOSE_SKEWUP` = 2

  Skew upper closure

`openvsp.vsp.``COLLISION_CLEAR_NO_SOLUTION` = 2

  Not touching, no solution

`openvsp.vsp.``COLLISION_INTERSECT_NO_SOLUTION` = 1

  Touching, no solution

`openvsp.vsp.``COLLISION_OK` = 0

  No Error.

`openvsp.vsp.``COMPONENT_REF` = 1

  Use a particular wing to calculate the reference area and lengths

`openvsp.vsp.``CONFORMAL_SCREEN` = 11

  Conformal geom screen

`openvsp.vsp.``CONST_U` = 0

  Constant U sub-surface

`openvsp.vsp.``CONST_W` = 1

  Constant W sub-surface

`openvsp.vsp.``CURV_GAP` = 2

  Maximum gap curvature based criteria.

`openvsp.vsp.``CURV_NCIRCSEG` = 3

  Minimum number of segments to define a circle curvature based criteria.

`openvsp.vsp.``CUSTOM_GEOM_SCREEN` = 6

  Custom geom screen

`openvsp.vsp.``CalcAtmosphere`(double const & alt, double const & delta_temp, int const & atmos_type)

`openvsp.vsp.``ChangeBORXSecShape`(string const & bor_id, int type)

`openvsp.vsp.``ChangeXSecShape`(std::string const & xsec_surf_id, int xsec_index, int type)

`openvsp.vsp.``CheckForVSPAERO`(std::string const & path) → bool

`openvsp.vsp.``ClearVSPModel`()

`openvsp.vsp.``CompCurvature01`(std::string const & geom_id, int const & surf_indx, double const & u, double const & w)

`openvsp.vsp.``CompNorm01`(std::string const & geom_id, int const & surf_indx, double const & u, double const & w) → vec3d

`openvsp.vsp.``CompPnt01`(std::string const & geom_id, int const & surf_indx, double const & u, double const & w) → vec3d

`openvsp.vsp.``CompPntRST`(std::string const & geom_id, int const & surf_indx, double const & r, double const & s, double const & t) → vec3d

`openvsp.vsp.``CompTanU01`(std::string const & geom_id, int const & surf_indx, double const & u, double const & w) → vec3d

`openvsp.vsp.``CompTanW01`(std::string const & geom_id, int const & surf_indx, double const & u, double const & w) → vec3d

`openvsp.vsp.``CompVecCurvature01`(std::string const & geom_id, int const & surf_indx, DoubleVector us, DoubleVector ws)

`openvsp.vsp.``CompVecNorm01`(std::string const & geom_id, int const & surf_indx, DoubleVector us, DoubleVector ws) → Vec3dVec

`openvsp.vsp.``CompVecPnt01`(std::string const & geom_id, int const & surf_indx, DoubleVector u_in_vec, DoubleVector w_in_vec) → Vec3dVec

`openvsp.vsp.``CompVecPntRST`(std::string const & geom_id, int const & surf_indx, DoubleVector r_in_vec, DoubleVector s_in_vec, DoubleVector t_in_vec) → Vec3dVec

`openvsp.vsp.``ComputeBORXSecPnt`(std::string const & bor_id, double fract) → vec3d

`openvsp.vsp.``ComputeBORXSecTan`(std::string const & bor_id, double fract) → vec3d

`openvsp.vsp.``ComputeCFDMesh`(int set, int degenset, int file_export_types)

`openvsp.vsp.``ComputeCompGeom`(int set, bool half_mesh, int file_export_types) → std::string

`openvsp.vsp.``ComputeDegenGeom`(int set, int file_export_types)

`openvsp.vsp.``ComputeFeaMesh`(std::string const & geom_id, int fea_struct_ind, int file_type)

  ComputeFeaMesh(std::string const & struct_id, int file_type)

`openvsp.vsp.``ComputeMassProps`(int set, int num_slices, int idir) → std::string

`openvsp.vsp.``ComputeMinClearanceDistance`(std::string const & geom_id, int set=SET_ALL) → double

`openvsp.vsp.``ComputePlaneSlice`(int set, int num_slices, vec3d norm, bool auto_bnd, double start_bnd=0, double end_bnd=0, bool measureduct=False) → std::string

`openvsp.vsp.``ComputeXSecPnt`(std::string const & xsec_id, double fract) → vec3d

`openvsp.vsp.``ComputeXSecTan`(std::string const & xsec_id, double fract) → vec3d

`openvsp.vsp.``ConvertEtatoU`(std::string const & geom_id, double const & eta)

`openvsp.vsp.``ConvertLMNtoRST`(std::string const & geom_id, int const & surf_indx, double const & l, double const & m, double const & n)

`openvsp.vsp.``ConvertLMNtoRSTVec`(std::string const & geom_id, int const & surf_indx, DoubleVector l_vec, DoubleVector m_vec, DoubleVector n_vec)

`openvsp.vsp.``ConvertLtoR`(std::string const & geom_id, int const & surf_indx, double const & l)

`openvsp.vsp.``ConvertRSTtoLMN`(std::string const & geom_id, int const & surf_indx, double const & r, double const & s, double const & t)

`openvsp.vsp.``ConvertRSTtoLMNVec`(std::string const & geom_id, int const & surf_indx, DoubleVector r_vec, DoubleVector s_vec, DoubleVector t_vec)

`openvsp.vsp.``ConvertRtoL`(std::string const & geom_id, int const & surf_indx, double const & r)

`openvsp.vsp.``ConvertUtoEta`(std::string const & geom_id, double const & u)

`openvsp.vsp.``ConvertXSecToEdit`(std::string const & geom_id, int const & indx=0)

`openvsp.vsp.``CopyGeomToClipboard`(std::string const & geom_id)

`openvsp.vsp.``CopyPasteSet`(int copyIndex, int pasteIndex)

`openvsp.vsp.``CopyXSec`(std::string const & geom_id, int index)

`openvsp.vsp.``CreateGeomResults`(std::string const & geom_id, std::string const & name) → std::string

`openvsp.vsp.``CreateVSPAEROControlSurfaceGroup`() → int

`openvsp.vsp.``CutGeomToClipboard`(std::string const & geom_id)

`openvsp.vsp.``CutXSec`(std::string const & geom_id, int index)

`openvsp.vsp.``DELIM_COMMA` = 0

  Comma delimiter

`openvsp.vsp.``DELIM_NONE` = 3

  No delimiter

`openvsp.vsp.``DELIM_NUM_TYPES` = 4

  Number of delimiter types

`openvsp.vsp.``DELIM_SPACE` = 2

  Space delimiter

`openvsp.vsp.``DELIM_USCORE` = 1

  Underscore delimiter

`openvsp.vsp.``DEPTH_FREE` = 2

  Set 3D background at specified location

`openvsp.vsp.``DEPTH_FRONT` = 0

  Set 3D background before model

`openvsp.vsp.``DEPTH_REAR` = 1

  Set 3D background behind model

`openvsp.vsp.``DESIGN_CL` = 1

  Input ideal lift coefficient, calculate maximum camber

`openvsp.vsp.``DISK_SURF` = 2

  Disk VSP surface

`openvsp.vsp.``DISPLAY_BEZIER` = 0

  Display the normal Bezier surface (default)

`openvsp.vsp.``DISPLAY_DEGEN_CAMBER` = 3

  Display as camber Degen Geom

`openvsp.vsp.``DISPLAY_DEGEN_PLATE` = 2

  Display as plate Degen Geom

`openvsp.vsp.``DISPLAY_DEGEN_SURF` = 1

  Display as surface Degen Geom

`openvsp.vsp.``DOUBLE_DATA` = 1

  Double result data type

`openvsp.vsp.``DOUBLE_MATRIX_DATA` = 4

  Double matrix result data type

`openvsp.vsp.``DO_NOT_USE_CF_TURB_IMPLICIT_KARMAN` = 3

  Implicit Karman turbulent Cf equation (DO NOT USE)

`openvsp.vsp.``DO_NOT_USE_CF_TURB_ROUGHNESS_SCHLICHTING_LOCAL` = 17

  Roughness Schlichting Local turbulent Cf equation (DO NOT USE)

`openvsp.vsp.``DO_NOT_USE_CF_TURB_ROUGHNESS_WHITE` = 18

  Roughness White turbulent Cf equation (DO NOT USE)

`openvsp.vsp.``DO_NOT_USE_CF_TURB_SCHLICHTING_INCOMPRESSIBLE` = 11

  Schlichting Incompressible turbulent Cf equation (DO NOT USE)

`openvsp.vsp.``DO_NOT_USE_CF_TURB_SCHLICHTING_PRANDTL` = 12

  Schlichting-Prandtl turbulent Cf equation (DO NOT USE)

`openvsp.vsp.``DO_NOT_USE_CF_TURB_SCHULTZ_GRUNOW_HIGH_RE` = 13

  Schultz-Grunow High Re turbulent Cf equation (DO NOT USE)

`openvsp.vsp.``DO_NOT_USE_CF_TURB_WHITE_CHRISTOPH_COMPRESSIBLE` = 15

  White-Christoph Compressible turbulent Cf equation (DO NOT USE)

`openvsp.vsp.``DelAdvLink`(int index)

`openvsp.vsp.``DelAdvLinkInput`(int index, string const & var_name)

`openvsp.vsp.``DelAdvLinkOutput`(int index, string const & var_name)

`openvsp.vsp.``DelAllAdvLinks`()

`openvsp.vsp.``DelAllBackground3Ds`()

`openvsp.vsp.``DelBackground3D`(string const & id)

`openvsp.vsp.``DelFeaBC`(string const & fea_struct_id, std::string const & bc_id)

`openvsp.vsp.``DelProbe`(string const & id)

`openvsp.vsp.``DelRuler`(string const & id)

`openvsp.vsp.``DeleteAllCFDSources`()

`openvsp.vsp.``DeleteAllDesignVars`()

`openvsp.vsp.``DeleteAllProbes`()

`openvsp.vsp.``DeleteAllResults`()

`openvsp.vsp.``DeleteAllRulers`()

`openvsp.vsp.``DeleteAllUserParm`()

`openvsp.vsp.``DeleteExcrescence`(int const & index)

`openvsp.vsp.``DeleteFeaPart`(std::string const & geom_id, int fea_struct_ind, std::string const & part_id)

`openvsp.vsp.``DeleteFeaStruct`(std::string const & geom_id, int fea_struct_ind)

`openvsp.vsp.``DeleteFeaSubSurf`(std::string const & geom_id, int fea_struct_ind, std::string const & ss_id)

`openvsp.vsp.``DeleteGeom`(std::string const & geom_id)

`openvsp.vsp.``DeleteGeomVec`(StringVector del_vec)

`openvsp.vsp.``DeleteResult`(std::string const & id)

`openvsp.vsp.``DeleteSubSurf`(std::string const & geom_id, std::string const & sub_id)

  DeleteSubSurf(std::string const & sub_id)

`openvsp.vsp.``DeleteUserParm`(std::string const & id)

`openvsp.vsp.``DeleteVarPresetParm`(std::string const & parm_id)

  DeleteVarPresetParm(std::string const & parm_id, std::string const & group_name)

`openvsp.vsp.``DeleteVarPresetSet`(std::string const & group_name, std::string const & setting_name) → bool

`openvsp.vsp.``DemoteBORCSTLower`(std::string const & bor_id)

`openvsp.vsp.``DemoteBORCSTUpper`(std::string const & bor_id)

`openvsp.vsp.``DemoteCSTLower`(std::string const & xsec_id)

`openvsp.vsp.``DemoteCSTUpper`(std::string const & xsec_id)

`openvsp.vsp.``DisableStopGUIMenuItem`()

class `openvsp.vsp.``DoubleVecVec`(*args)

  Bases: `object`

  `append`(x)
  `assign`(n, x)
  `back`()
  `begin`()
  `capacity`()
  `clear`()
  `empty`()
  `end`()
  `erase`(*args)
  `front`()
  `get_allocator`()
  `insert`(*args)
  `iterator`()
  `pop`()
  `pop_back`()
  `push_back`(x)
  `rbegin`()
  `rend`()
  `reserve`(n)
  `resize`(*args)
  `size`()
  `swap`(v)
  property `thisown`

    The membership flag

class `openvsp.vsp.``DoubleVector`(*args)

  Bases: `object`

  `append`(x)
  `assign`(n, x)
  `back`()
  `begin`()
  `capacity`()
  `clear`()
  `empty`()
  `end`()
  `erase`(*args)
  `front`()
  `get_allocator`()
  `insert`(*args)
  `iterator`()
  `pop`()
  `pop_back`()
  `push_back`(x)
  `rbegin`()
  `rend`()
  `reserve`(n)
  `resize`(*args)
  `size`()
  `swap`(v)
  property `thisown`

    The membership flag

`openvsp.vsp.``EDGE_END_CAP` = 3

  Edge end cap

`openvsp.vsp.``EDIT_XSEC_CIRCLE` = 0

  Circle initialized as cubic Bezier type

`openvsp.vsp.``EDIT_XSEC_ELLIPSE` = 1

  Ellipse initialized as PCHIP type

`openvsp.vsp.``EDIT_XSEC_RECTANGLE` = 2

  Rectangle initialized as linear type

`openvsp.vsp.``ELLIPSOID_GEOM_SCREEN` = 12

  Ellipsoid geom screen

`openvsp.vsp.``ENGINE_GEOM_FLOWPATH` = 2

  Component flowpath is modeled.

`openvsp.vsp.``ENGINE_GEOM_FLOWTHROUGH` = 0

  Component is modeled as flowthrough engine.

`openvsp.vsp.``ENGINE_GEOM_INLET` = 1

  Component represents integrated flowpath inlet.

`openvsp.vsp.``ENGINE_GEOM_INLET_OUTLET` = 2

  Component represents integrated flowpath inlet and outlet.

`openvsp.vsp.``ENGINE_GEOM_IO_NUM_TYPES` = 4

  Number of integrated flowpath component types.

`openvsp.vsp.``ENGINE_GEOM_NONE` = 0

  Component is not an integrated flowpath component.

`openvsp.vsp.``ENGINE_GEOM_NUM_TYPES` = 4

  Number of integrated flowpath modeling types.

`openvsp.vsp.``ENGINE_GEOM_OUTLET` = 3

  Component represents integrated flowpath outlet.

`openvsp.vsp.``ENGINE_GEOM_TO_FACE` = 3

  Component is modeled to face.

`openvsp.vsp.``ENGINE_GEOM_TO_LIP` = 1

  Component is modeled to the lip.

`openvsp.vsp.``ENGINE_LOC_INDEX` = 0

  Integrated flowpath key point identified by XSec index.

`openvsp.vsp.``ENGINE_LOC_INLET_FACE` = 1

  Integrated flowpath key point is inlet face.

`openvsp.vsp.``ENGINE_LOC_INLET_LIP` = 0

  Integrated flowpath key point is inlet lip.

`openvsp.vsp.``ENGINE_LOC_NUM` = 4

  Number of integrated flowpath key point locations.

`openvsp.vsp.``ENGINE_LOC_OUTLET_FACE` = 3

  Integrated flowpath key point is outlet face.

`openvsp.vsp.``ENGINE_LOC_OUTLET_LIP` = 2

  Integrated flowpath key point is outlet lip.

`openvsp.vsp.``ENGINE_LOC_U` = 1

  Integrated flowpath key point identified by U parameter.

`openvsp.vsp.``ENGINE_MODE_EXTEND` = 5

  Represent integrated flowpath with farfield extensions.

`openvsp.vsp.``ENGINE_MODE_FLOWTHROUGH` = 0

  Represent integrated flowpath as flowthrough engine.

`openvsp.vsp.``ENGINE_MODE_FLOWTHROUGH_NEG` = 1

  Represent integrated flowpath as flowthrough engine with negative flowpath.

`openvsp.vsp.``ENGINE_MODE_NUM_TYPES` = 6

  Number of integrated flowpath representations.

`openvsp.vsp.``ENGINE_MODE_TO_FACE` = 3

  Represent integrated flowpath to the face.

`openvsp.vsp.``ENGINE_MODE_TO_FACE_NEG` = 4

  Represent integrated flowpath to the face with negative flowpath to the face.

`openvsp.vsp.``ENGINE_MODE_TO_LIP` = 2

  Represent integrated flowpath to the lip.

`openvsp.vsp.``ETA_TRIM` = 2

  Trim by Eta coordinate

`openvsp.vsp.``EXCRESCENCE_CD` = 1

  Drag coefficient excressence type

`openvsp.vsp.``EXCRESCENCE_COUNT` = 0

  Drag counts excressence type

`openvsp.vsp.``EXCRESCENCE_DRAGAREA` = 4

  Drag area (D/q) excressence type

`openvsp.vsp.``EXCRESCENCE_MARGIN` = 3

  Percent margin excressence type

`openvsp.vsp.``EXCRESCENCE_PERCENT_GEOM` = 2

  Percent of parent Geom drag coefficient excressence type

`openvsp.vsp.``EXPORT_AWAVE` = 3

  AWAVE export type (NOT IMPLEMENTED)

`openvsp.vsp.``EXPORT_BEM` = 15

  Blade Element (*.bem) export type

`openvsp.vsp.``EXPORT_BEZIER_AIRFOIL` = 22

  Airfoil curves (*.bz) export type

`openvsp.vsp.``EXPORT_CART3D` = 6

  Cart3D (*.tri) export type

`openvsp.vsp.``EXPORT_DXF` = 16

  AutoCAD (*.dxf) export type

`openvsp.vsp.``EXPORT_FACET` = 17

  Xpatch (*.facet) export type

`openvsp.vsp.``EXPORT_FELISA` = 0

  FELISA export type (NOT IMPLEMENTED)

`openvsp.vsp.``EXPORT_GMSH` = 10

  Gmsh (*.msh) export type

`openvsp.vsp.``EXPORT_IGES` = 14

  IGES (*.igs) export type

`openvsp.vsp.``EXPORT_IGES_STRUCTURE` = 23

  IGES structure (*.igs) export type

`openvsp.vsp.``EXPORT_NASCART` = 4

  NASCART (*.dat) export type

`openvsp.vsp.``EXPORT_OBJ` = 20

  OBJ (*.obj) export type

`openvsp.vsp.``EXPORT_PLOT3D` = 13

  PLOT3D (*.p3d) export type

`openvsp.vsp.``EXPORT_PMARC` = 19

  PMARC 12 (*.pmin) export type

`openvsp.vsp.``EXPORT_POVRAY` = 5

  POVRAY (*.pov) export type

`openvsp.vsp.``EXPORT_SELIG_AIRFOIL` = 21

  Airfoil points (*.dat) export type

`openvsp.vsp.``EXPORT_STEP` = 12

  STEP (*.stp) export type

`openvsp.vsp.``EXPORT_STEP_STRUCTURE` = 24

  STEP structure (*.stp) export type

`openvsp.vsp.``EXPORT_STL` = 2

  Stereolith (*.stl) export type

`openvsp.vsp.``EXPORT_SVG` = 18

  SVG (*.svg) export type

`openvsp.vsp.``EXPORT_VORXSEC` = 8

  VORXSEC export type (NOT IMPLEMENTED)

`openvsp.vsp.``EXPORT_VSPGEOM` = 7

  VSPGeom (*.vspgeom) export type

`openvsp.vsp.``EXPORT_X3D` = 11

  X3D (*.x3d) export type

`openvsp.vsp.``EXPORT_XSEC` = 1

  XSec (*.hrm) export type

`openvsp.vsp.``EXPORT_XSECGEOM` = 9

  XSECGEOM export type (NOT IMPLEMENTED)

`openvsp.vsp.``EditVarPresetParm`(std::string const & parm_id, double parm_val)

  EditVarPresetParm(std::string const & parm_id, double parm_val, std::string const & group_name, std::string const & setting_name)

`openvsp.vsp.``EditXSecConvertTo`(std::string const & xsec_id, int const & newtype)

`openvsp.vsp.``EditXSecDelPnt`(std::string const & xsec_id, int const & indx)

`openvsp.vsp.``EditXSecInitShape`(std::string const & xsec_id)

`openvsp.vsp.``EditXSecSplit01`(std::string const & xsec_id, double const & u) → int

`openvsp.vsp.``EnableStopGUIMenuItem`()

class `openvsp.vsp.``ErrorMgrSingleton`(*args, **kwargs)

  Bases: `object`

  Proxy of C++ vsp::ErrorMgrSingleton class.

  `AddError`(ErrorMgrSingleton self, vsp::ERROR_CODE code, string const & desc)
  `GetErrorLastCallFlag`(ErrorMgrSingleton self) → bool
  `GetLastError`(ErrorMgrSingleton self) → ErrorObj
  `GetNumTotalErrors`(ErrorMgrSingleton self) → int
  `MessageCallback`(ErrorMgrSingleton self, MessageBase const * _from, MessageData const & data)
  `NoError`(ErrorMgrSingleton self)
  `PopErrorAndPrint`(ErrorMgrSingleton self, FILE * stream) → bool
  `PopLastError`(ErrorMgrSingleton self) → ErrorObj
  `PrintOnErrors`(ErrorMgrSingleton self)
  `SilenceErrors`(ErrorMgrSingleton self)
  static `getInstance`() → ErrorMgrSingleton
  property `thisown`

    The membership flag

`openvsp.vsp.``ErrorMgrSingleton_getInstance`() → ErrorMgrSingleton

class `openvsp.vsp.``ErrorObj`(*args)

  Bases: `object`

  Proxy of C++ vsp::ErrorObj class.

  `GetErrorCode`(ErrorObj self) → vsp::ERROR_CODE
  `GetErrorString`(ErrorObj self) → string
  `NoError`(ErrorObj self)
  property `m_ErrorCode`

    m_ErrorCode : vsp::ERROR_CODE

  property `m_ErrorString`

    m_ErrorString : string

  property `thisown`

    The membership flag

`openvsp.vsp.``ExecAnalysis`(std::string const & analysis) → std::string

`openvsp.vsp.``ExportFile`(std::string const & file_name, int thick_set, int file_type, int subsFlag=1, int thin_set=SET_NONE) → std::string

`openvsp.vsp.``FC_NATIVE` = 1

  Operating system’s native file chooser

`openvsp.vsp.``FC_OPENVSP` = 0

  OpenVSP’s own file chooser with directory preferences.

`openvsp.vsp.``FEA_BCM_ALL` = 1

  FEA boundary condition constrains all DOF.

`openvsp.vsp.``FEA_BCM_ASYMM` = 4

  FEA boundary condition antisymmetrical constraints.

`openvsp.vsp.``FEA_BCM_PIN` = 2

  FEA boundary condition pin constraints.

`openvsp.vsp.``FEA_BCM_SYMM` = 3

  FEA boundary condition symmetrical constraints.

`openvsp.vsp.``FEA_BCM_USER` = 0

  FEA boundary condition constraints user defined.

`openvsp.vsp.``FEA_BC_PART` = 1

  FEA boundary condition assigned to part.

`openvsp.vsp.``FEA_BC_STRUCTURE` = 0

  FEA boundary condition assigned to structure.

`openvsp.vsp.``FEA_BC_SUBSURF` = 2

  FEA boundary condition assigned to subsurface.

`openvsp.vsp.``FEA_BEAM` = 1

  Beam FEA element type

`openvsp.vsp.``FEA_CALCULIX_FILE_NAME` = 3

  FEA Mesh Calculix export type

`openvsp.vsp.``FEA_CURV_FILE_NAME` = 7

  FEA Mesh CURV export type

`openvsp.vsp.``FEA_DELETE` = 1

  Delete shell elements

`openvsp.vsp.``FEA_DEPRECATED` = -1

  Flag for deprecated element type option

`openvsp.vsp.``FEA_DOME` = 4

  Dome FEA Part type

`openvsp.vsp.``FEA_ENG_ORTHO` = 1

  Orthotropic material in engineering parameters

`openvsp.vsp.``FEA_ENG_ORTHO_TRANS_ISO` = 2

  Orthotropic material with transverse isotropy assumed in engineering parameters

`openvsp.vsp.``FEA_FIX_POINT` = 3

  Fixed Point FEA Part type

`openvsp.vsp.``FEA_FIX_PT_DELTA_UVN` = 3

  Delta UVN off body fixed point type

`openvsp.vsp.``FEA_FIX_PT_DELTA_XYZ` = 2

  Delta XYZ off body fixed point type

`openvsp.vsp.``FEA_FIX_PT_GEOM_CG` = 5

  Geom CG off body fixed point type

`openvsp.vsp.``FEA_FIX_PT_GEOM_ORIGIN` = 4

  Geom origin off body fixed point type

`openvsp.vsp.``FEA_FIX_PT_GLOBAL_XYZ` = 1

  Global XYZ off body fixed point type

`openvsp.vsp.``FEA_FIX_PT_ON_BODY` = 0

  On body fixed point type

`openvsp.vsp.``FEA_GMSH_FILE_NAME` = 5

  FEA Mesh GMSH export type

`openvsp.vsp.``FEA_IGES_FILE_NAME` = 9

  FEA Mesh trimmed IGES export type

`openvsp.vsp.``FEA_ISOTROPIC` = 0

  Isotropic material

`openvsp.vsp.``FEA_KEEP` = 0

  Keep shell elements

`openvsp.vsp.``FEA_LAMINATE` = 3

  Laminate buildup material

`openvsp.vsp.``FEA_MASS_FILE_NAME` = 0

  FEA Mesh mass export type

`openvsp.vsp.``FEA_NASTRAN_FILE_NAME` = 1

  FEA Mesh NASTRAN export type

`openvsp.vsp.``FEA_NKEY_FILE_NAME` = 2

  FEA Mesh NKey export type

`openvsp.vsp.``FEA_NO_ELEMENTS` = 3

  FEA part with no elements

`openvsp.vsp.``FEA_NUM_BCM_MODES` = 5

  Number of FEA boundary condition constraint types.

`openvsp.vsp.``FEA_NUM_BC_TYPES` = 3

  Number of FEA boundary condition definition types.

`openvsp.vsp.``FEA_NUM_ELEMENT_TYPES` = 4

  Number of FEA element type choices

`openvsp.vsp.``FEA_NUM_FILE_NAMES` = 11

  Number of FEA Mesh export type.

`openvsp.vsp.``FEA_NUM_FIX_PT_TYPES` = 6

  Number of off body fixed point types

`openvsp.vsp.``FEA_NUM_MAT_TYPES` = 4

  Number of FEA material types

`openvsp.vsp.``FEA_NUM_ORIENT_TYPES` = 13

  Number of FEA material orientation types

`openvsp.vsp.``FEA_NUM_SHELL_TREATMENT_TYPES` = 2

  Number of FEA subsurface treatment choices

`openvsp.vsp.``FEA_NUM_TYPES` = 9

  Number of FEA Part types

`openvsp.vsp.``FEA_ORIENT_COMP_X` = 3

  FEA Comp X material orientation

`openvsp.vsp.``FEA_ORIENT_COMP_Y` = 4

  FEA Comp Y material orientation

`openvsp.vsp.``FEA_ORIENT_COMP_Z` = 5

  FEA Comp Z material orientation

`openvsp.vsp.``FEA_ORIENT_GLOBAL_X` = 0

  FEA Global X material orientation

`openvsp.vsp.``FEA_ORIENT_GLOBAL_Y` = 1

  FEA Global Y material orientation

`openvsp.vsp.``FEA_ORIENT_GLOBAL_Z` = 2

  FEA Global Z material orientation

`openvsp.vsp.``FEA_ORIENT_OML_R` = 10

  FEA OML R material orientation

`openvsp.vsp.``FEA_ORIENT_OML_S` = 11

  FEA OML S material orientation

`openvsp.vsp.``FEA_ORIENT_OML_T` = 12

  FEA OML T material orientation

`openvsp.vsp.``FEA_ORIENT_OML_U` = 8

  FEA OML U material orientation

`openvsp.vsp.``FEA_ORIENT_OML_V` = 9

  FEA OML V material orientation

`openvsp.vsp.``FEA_ORIENT_PART_U` = 6

  FEA Part U material orientation

`openvsp.vsp.``FEA_ORIENT_PART_V` = 7

  FEA Part V material orientation

`openvsp.vsp.``FEA_PLOT3D_FILE_NAME` = 8

  FEA Mesh PLOT3D export type

`openvsp.vsp.``FEA_RIB` = 1

  Rib FEA Part type

`openvsp.vsp.``FEA_RIB_ARRAY` = 5

  Rib array FEA Part type

`openvsp.vsp.``FEA_SHELL` = 0

  Shell (tris) FEA element type

`openvsp.vsp.``FEA_SHELL_AND_BEAM` = 2

  Both Shell and Beam FEA element types

`openvsp.vsp.``FEA_SKIN` = 7

  Skin FEA Part type

`openvsp.vsp.``FEA_SLICE` = 0

  Slice FEA Part type

`openvsp.vsp.``FEA_SLICE_ARRAY` = 6

  Slice array FEA Part type

`openvsp.vsp.``FEA_SPAR` = 2

  Spar FEA Part type

`openvsp.vsp.``FEA_SRF_FILE_NAME` = 6

  FEA Mesh SRF export type

`openvsp.vsp.``FEA_STEP_FILE_NAME` = 10

  FEA Mesh trimmed STEP export type

`openvsp.vsp.``FEA_STL_FILE_NAME` = 4

  FEA Mesh STL export type

`openvsp.vsp.``FEA_TRIM` = 8

  Trim FEA Part type

`openvsp.vsp.``FEA_XSEC_BOX` = 5

  Box XSec type

`openvsp.vsp.``FEA_XSEC_CIRC` = 1

  Circle XSec type

`openvsp.vsp.``FEA_XSEC_GENERAL` = 0

  General XSec type

`openvsp.vsp.``FEA_XSEC_I` = 3

  I XSec type

`openvsp.vsp.``FEA_XSEC_PIPE` = 2

  Pipe XSec type

`openvsp.vsp.``FEA_XSEC_RECT` = 4

  Rectangle XSec type

`openvsp.vsp.``FEMALE` = 1

  Female Human component

`openvsp.vsp.``FF_B_COVERT` = 6

  Covert FF equation

`openvsp.vsp.``FF_B_HOERNER_STREAMBODY` = 3

  Hoerner Streamlined Body FF equation

`openvsp.vsp.``FF_B_JENKINSON_AFT_FUSE_NACELLE` = 9

  Jenkinson Aft Fuselage Nacelle FF equation

`openvsp.vsp.``FF_B_JENKINSON_FUSE` = 7

  Jenkinson Fuselage FF equation

`openvsp.vsp.``FF_B_JENKINSON_WING_NACELLE` = 8

  Jenkinson Wing Nacelle FF equation

`openvsp.vsp.``FF_B_MANUAL` = 0

  Manual FF equation

`openvsp.vsp.``FF_B_SCHEMENSKY_FUSE` = 1

  Schemensky Fuselage FF equation

`openvsp.vsp.``FF_B_SCHEMENSKY_NACELLE` = 2

  Schemensky Nacelle FF equation

`openvsp.vsp.``FF_B_SHEVELL` = 5

  Shevell FF equation

`openvsp.vsp.``FF_B_TORENBEEK` = 4

  Torenbeek FF equation

`openvsp.vsp.``FF_W_COVERT` = 4

  Covert FF equation

`openvsp.vsp.``FF_W_DATCOM` = 8

  DATCOM FF equation

`openvsp.vsp.``FF_W_EDET_ADV` = 2

  EDET Advanced Airfoil FF equation

`openvsp.vsp.``FF_W_EDET_CONV` = 1

  EDET Conventional Airfoil FF equation

`openvsp.vsp.``FF_W_HOERNER` = 3

  Hoerner FF equation

`openvsp.vsp.``FF_W_JENKINSON_TAIL` = 12

  Jenkinson Tail FF equation

`openvsp.vsp.``FF_W_JENKINSON_WING` = 11

  Jenkinson Wing FF equation

`openvsp.vsp.``FF_W_KROO` = 6

  Kroo FF equation

`openvsp.vsp.``FF_W_MANUAL` = 0

  Manual FF equation

`openvsp.vsp.``FF_W_SCHEMENSKY_4_SERIES_AF` = 10

  Schemensky 4 Series Airfoil FF equation

`openvsp.vsp.``FF_W_SCHEMENSKY_6_SERIES_AF` = 9

  Schemensky 6 Series Airfoil FF equation

`openvsp.vsp.``FF_W_SCHEMENSKY_SUPERCRITICAL_AF` = 13

  Schemensky Supercritical Airfoil FF equation

`openvsp.vsp.``FF_W_SHEVELL` = 5

  Shevell FF equation

`openvsp.vsp.``FF_W_TORENBEEK` = 7

  Torenbeek FF equation

`openvsp.vsp.``FLAT_END_CAP` = 1

  Flat end cap

`openvsp.vsp.``FUSELAGE_GEOM_SCREEN` = 1

  Fuselage geom screen

`openvsp.vsp.``FindActuatorDisk`(int disk_index) → std::string

`openvsp.vsp.``FindContainer`(std::string const & name, int index) → std::string

`openvsp.vsp.``FindContainerGroupNames`(std::string const & parm_container_id) → StringVector

`openvsp.vsp.``FindContainerParmIDs`(std::string const & parm_container_id) → StringVector

`openvsp.vsp.``FindContainers`() → StringVector

`openvsp.vsp.``FindContainersWithName`(std::string const & name) → StringVector

`openvsp.vsp.``FindGeom`(std::string const & name, int index) → std::string

`openvsp.vsp.``FindGeoms`() → StringVector

`openvsp.vsp.``FindGeomsWithName`(std::string const & name) → StringVector

`openvsp.vsp.``FindLatestResultsID`(std::string const & name) → std::string

`openvsp.vsp.``FindParm`(std::string const & parm_container_id, std::string const & parm_name, std::string const & group_name) → std::string

`openvsp.vsp.``FindRST`(std::string const & geom_id, int const & surf_indx, vec3d pt) → double

`openvsp.vsp.``FindRSTGuess`(std::string const & geom_id, int const & surf_indx, vec3d pt, double const & r0, double const & s0, double const & t0) → double

`openvsp.vsp.``FindRSTVec`(std::string const & geom_id, int const & surf_indx, Vec3dVec pts)

`openvsp.vsp.``FindRSTVecGuess`(std::string const & geom_id, int const & surf_indx, Vec3dVec pts, DoubleVector r0s, DoubleVector s0s, DoubleVector t0s)

`openvsp.vsp.``FindResultsID`(std::string const & name, int index=0) → std::string

`openvsp.vsp.``FindUnsteadyGroup`(int group_index) → std::string

`openvsp.vsp.``FitAfCST`(std::string const & xsec_surf_id, int xsec_index, int deg)

`openvsp.vsp.``FitAllViews`()

`openvsp.vsp.``FitBORAfCST`(std::string const & bor_id, int deg)

`openvsp.vsp.``GDEV_ADD_CHOICE_ITEM` = 16

  Add item to custom GUI Choice

`openvsp.vsp.``GDEV_BEGIN_SAME_LINE` = 26

  Set begin same line flag for custom GUI

`openvsp.vsp.``GDEV_CHECK_BUTTON` = 8

  Custom GUI CheckButton

`openvsp.vsp.``GDEV_CHECK_BUTTON_BIT` = 9

  Custom GUI CheckButtonBit

`openvsp.vsp.``GDEV_CHOICE` = 15

  Custom GUI Choice

`openvsp.vsp.``GDEV_COLOR_PICKER` = 23

  Custom GUI ColorPicker

`openvsp.vsp.``GDEV_COUNTER` = 14

  Custom GUI Counter

`openvsp.vsp.``GDEV_DIVIDER_BOX` = 25

  Custom GUI divider box

`openvsp.vsp.``GDEV_END_SAME_LINE` = 27

  Set end same line flag for custom GUI

`openvsp.vsp.``GDEV_FORCE_WIDTH` = 28

  Set forced width for custom GUI

`openvsp.vsp.``GDEV_FRACT_PARM_SLIDER` = 20

  Custom GUI FractParmSlider

`openvsp.vsp.``GDEV_GROUP` = 2

  Custom GUI Group

`openvsp.vsp.``GDEV_INDEX_SELECTOR` = 22

  Custom GUI IndexSelector

`openvsp.vsp.``GDEV_INPUT` = 4

  Custom GUI Input

`openvsp.vsp.``GDEV_OUTPUT` = 5

  Custom GUI Output

`openvsp.vsp.``GDEV_PARM_BUTTON` = 3

  Custom GUI ParmButton

`openvsp.vsp.``GDEV_RADIO_BUTTON` = 10

  Custom GUI RadioButton

`openvsp.vsp.``GDEV_SCROLL_TAB` = 1

  Custom GUI Fl_Scroll and Tab

`openvsp.vsp.``GDEV_SET_FORMAT` = 29

  Set format label for custom GUI

`openvsp.vsp.``GDEV_SLIDER` = 6

  Custom GUI Slider

`openvsp.vsp.``GDEV_SLIDER_ADJ_RANGE` = 7

  Custom GUI SliderAdjRangeInput

`openvsp.vsp.``GDEV_SLIDER_ADJ_RANGE_INPUT` = 18

  Custom GUI SliderAdjRangeInput

`openvsp.vsp.``GDEV_SLIDER_ADJ_RANGE_TWO_INPUT` = 19

  Custom GUI SliderAdjRangeInput with two inputs (NOT IMPLEMENTED)

`openvsp.vsp.``GDEV_SLIDER_INPUT` = 17

  Custom GUI SliderInput

`openvsp.vsp.``GDEV_STRING_INPUT` = 21

  Custom GUI StringInput

`openvsp.vsp.``GDEV_TAB` = 0

  Custom GUI Tab

`openvsp.vsp.``GDEV_TOGGLE_BUTTON` = 11

  Custom GUI ToggleButton

`openvsp.vsp.``GDEV_TOGGLE_RADIO_GROUP` = 12

  Custom GUI ToggleRadioGroup (NOT IMPLEMENTED)

`openvsp.vsp.``GDEV_TRIGGER_BUTTON` = 13

  Custom GUI TriggerButton

`openvsp.vsp.``GDEV_YGAP` = 24

  Custom GUI Y gap

`openvsp.vsp.``GEOM_BOUNDARY` = 2

  Geom boundary

`openvsp.vsp.``GEOM_DRAW_HIDDEN` = 1

  Draw the hidden mesh

`openvsp.vsp.``GEOM_DRAW_NONE` = 4

  Do not draw anything

`openvsp.vsp.``GEOM_DRAW_SHADE` = 2

  Draw the shaded mesh

`openvsp.vsp.``GEOM_DRAW_TEXTURE` = 3

  Draw the textured mesh

`openvsp.vsp.``GEOM_DRAW_WIRE` = 0

  Draw the wireframe mesh (see through)

`openvsp.vsp.``GEOM_PROJ` = 3

  Project toward a Geom

`openvsp.vsp.``GEOM_TARGET` = 1

  Geom target type

`openvsp.vsp.``GEOM_XSECS` = 2

  GeomXSec Geom type

`openvsp.vsp.``GROW_LIMIT_CURV_GAP` = 10

  Maximum growth limit from maximum gap.

`openvsp.vsp.``GROW_LIMIT_CURV_NCIRCSEG` = 11

  Maximum growth limit from number of segments to define a circle.

`openvsp.vsp.``GROW_LIMIT_INCREMENT` = 8

  Reason increment when adding growth limit constraint.

`openvsp.vsp.``GROW_LIMIT_MAX_LEN_CONSTRAINT` = 9

  Maximum growth limit from maximum edge length (not used, growth limited small to large).

`openvsp.vsp.``GROW_LIMIT_MIN_LEN_CONSTRAINT` = 13

  Maximum growth limit from minimum length constraint.

`openvsp.vsp.``GROW_LIMIT_MIN_LEN_CONSTRAINT_CURV_GAP` = 14

  Maximum growth limit from maximum gap constrained by minimum length.

`openvsp.vsp.``GROW_LIMIT_MIN_LEN_CONSTRAINT_CURV_NCIRCSEG` = 15

  Maximum growth limit from number of segments to define a circle constrained by minimum length.

`openvsp.vsp.``GROW_LIMIT_MIN_LEN_CONSTRAINT_SOURCES` = 16

  Maximum growth limit from sources constrained by minimum length.

`openvsp.vsp.``GROW_LIMIT_SOURCES` = 12

  Maximum growth limit from mesh sources.

`openvsp.vsp.``GetActiveCSNameVec`(int CSGroupIndex) → StringVector

`openvsp.vsp.``GetAdvLinkCode`(int index) → std::string

`openvsp.vsp.``GetAdvLinkInputNames`(int index) → StringVector

`openvsp.vsp.``GetAdvLinkInputParms`(int index) → StringVector

`openvsp.vsp.``GetAdvLinkNames`() → StringVector

`openvsp.vsp.``GetAdvLinkOutputNames`(int index) → StringVector

`openvsp.vsp.``GetAdvLinkOutputParms`(int index) → StringVector

`openvsp.vsp.``GetAirfoilCoordinates`(std::string const & geom_id, double const & foilsurf_u) → Vec3dVec

`openvsp.vsp.``GetAirfoilLowerPnts`(std::string const & xsec_id) → Vec3dVec

`openvsp.vsp.``GetAirfoilUpperPnts`(std::string const & xsec_id) → Vec3dVec

`openvsp.vsp.``GetAllBackground3DAbsolutePaths`() → StringVector

`openvsp.vsp.``GetAllBackground3DRelativePaths`() → StringVector

`openvsp.vsp.``GetAllBackground3Ds`() → StringVector

`openvsp.vsp.``GetAllDataNames`(std::string const & results_id) → StringVector

`openvsp.vsp.``GetAllProbes`() → StringVector

`openvsp.vsp.``GetAllResultsNames`() → StringVector

`openvsp.vsp.``GetAllRulers`() → StringVector

`openvsp.vsp.``GetAllSubSurfIDs`() → StringVector

`openvsp.vsp.``GetAllUserParms`() → StringVector

`openvsp.vsp.``GetAnalysisDoc`(std::string const & analysis) → std::string

`openvsp.vsp.``GetAnalysisInputDoc`(std::string const & analysis, std::string const & name) → std::string

`openvsp.vsp.``GetAnalysisInputNames`(std::string const & analysis) → StringVector

`openvsp.vsp.``GetAnalysisInputType`(std::string const & analysis, std::string const & name) → int

`openvsp.vsp.``GetAndResetUpdateCount`() → int

`openvsp.vsp.``GetAvailableCSNameVec`(int CSGroupIndex) → StringVector

`openvsp.vsp.``GetBORAirfoilLowerPnts`(std::string const & bor_id) → Vec3dVec

`openvsp.vsp.``GetBORAirfoilUpperPnts`(std::string const & bor_id) → Vec3dVec

`openvsp.vsp.``GetBORLowerCSTCoefs`(std::string const & bor_id) → DoubleVector

`openvsp.vsp.``GetBORLowerCSTDegree`(std::string const & bor_id) → int

`openvsp.vsp.``GetBORUpperCSTCoefs`(std::string const & bor_id) → DoubleVector

`openvsp.vsp.``GetBORUpperCSTDegree`(std::string const & bor_id) → int

`openvsp.vsp.``GetBORXSecShape`(string const & bor_id) → int

`openvsp.vsp.``GetBackground3DAbsolutePath`(string const & id) → string

`openvsp.vsp.``GetBackground3DRelativePath`(string const & id) → string

`openvsp.vsp.``GetBoolParmVal`(std::string const & parm_id) → bool

`openvsp.vsp.``GetCompleteCSNameVec`() → StringVector

`openvsp.vsp.``GetContainerName`(std::string const & parm_container_id) → std::string

`openvsp.vsp.``GetCurrentGroupName`() → std::string

`openvsp.vsp.``GetCurrentSettingName`() → std::string

`openvsp.vsp.``GetDesignVar`(int index) → std::string

`openvsp.vsp.``GetDesignVarType`(int index) → int

`openvsp.vsp.``GetDoubleAnalysisInput`(std::string const & analysis, std::string const & name, int index=0) → DoubleVector

`openvsp.vsp.``GetDoubleMatResults`(std::string const & id, std::string const & name, int index=0) → DoubleVecVec

`openvsp.vsp.``GetDoubleResults`(std::string const & id, std::string const & name, int index=0) → DoubleVector

`openvsp.vsp.``GetEditXSecCtrlVec`(std::string const & xsec_id, bool non_dimensional=True) → Vec3dVec

`openvsp.vsp.``GetEditXSecFixedUVec`(std::string const & xsec_id) → BoolVector

`openvsp.vsp.``GetEditXSecUVec`(std::string const & xsec_id) → DoubleVector

`openvsp.vsp.``GetEllipsoidCpDist`(Vec3dVec surf_pnt_vec, vec3d abc_rad, vec3d V_inf) → DoubleVector

`openvsp.vsp.``GetEllipsoidSurfPnts`(vec3d center, vec3d abc_rad, int u_npts=20, int w_npts=20) → Vec3dVec

`openvsp.vsp.``GetFeaBCIDVec`(string const & fea_struct_id) → StringVector

`openvsp.vsp.``GetFeaPartID`(std::string const & fea_struct_id, int fea_part_index) → std::string

`openvsp.vsp.``GetFeaPartIDVec`(std::string const & fea_struct_id) → StringVector

`openvsp.vsp.``GetFeaPartName`(std::string const & part_id) → std::string

`openvsp.vsp.``GetFeaPartPerpendicularSparID`(std::string const & part_id) → std::string

`openvsp.vsp.``GetFeaPartType`(std::string const & part_id) → int

`openvsp.vsp.``GetFeaStructID`(std::string const & geom_id, int fea_struct_ind) → std::string

`openvsp.vsp.``GetFeaStructIDVec`() → StringVector

`openvsp.vsp.``GetFeaStructIndex`(std::string const & struct_id) → int

`openvsp.vsp.``GetFeaStructName`(std::string const & geom_id, int fea_struct_ind) → std::string

`openvsp.vsp.``GetFeaStructParentGeomID`(std::string const & struct_id) → std::string

`openvsp.vsp.``GetFeaSubSurfIDVec`(std::string const & fea_struct_id) → StringVector

`openvsp.vsp.``GetFeaSubSurfIndex`(string const & ss_id) → int

`openvsp.vsp.``GetFeaSubSurfName`(std::string const & subsurf_id) → std::string

`openvsp.vsp.``GetFeatureLinePnts`(string const & geom_id) → Vec3dVec

`openvsp.vsp.``GetGeomBBoxMax`(std::string const & geom_id, int main_surf_ind=0, bool ref_frame_is_absolute=True) → vec3d

`openvsp.vsp.``GetGeomBBoxMin`(std::string const & geom_id, int main_surf_ind=0, bool ref_frame_is_absolute=True) → vec3d

`openvsp.vsp.``GetGeomChildren`(std::string const & geom_id) → StringVector

`openvsp.vsp.``GetGeomName`(std::string const & geom_id) → std::string

`openvsp.vsp.``GetGeomParent`(std::string const & geom_id) → std::string

`openvsp.vsp.``GetGeomParmIDs`(std::string const & geom_id) → StringVector

`openvsp.vsp.``GetGeomSet`(std::string const & name) → StringVector

`openvsp.vsp.``GetGeomSetAtIndex`(int index) → StringVector

`openvsp.vsp.``GetGeomTypeName`(std::string const & geom_id) → std::string

`openvsp.vsp.``GetGeomTypes`() → StringVector

`openvsp.vsp.``GetGeomVSPSurfCfdType`(std::string const & geom_id, int main_surf_ind=0) → int

`openvsp.vsp.``GetGeomVSPSurfType`(std::string const & geom_id, int main_surf_ind=0) → int

`openvsp.vsp.``GetHersheyBarDragDist`(int const & npts, double const & alpha, double const & Vinf, double const & span, bool full_span_flag=False) → Vec3dVec

`openvsp.vsp.``GetHersheyBarLiftDist`(int const & npts, double const & alpha, double const & Vinf, double const & span, bool full_span_flag=False) → Vec3dVec

`openvsp.vsp.``GetIntAnalysisInput`(std::string const & analysis, std::string const & name, int index=0) → IntVector

`openvsp.vsp.``GetIntParmVal`(std::string const & parm_id) → int

`openvsp.vsp.``GetIntResults`(std::string const & id, std::string const & name, int index=0) → IntVector

`openvsp.vsp.``GetLinkIndex`(string const & name) → int

`openvsp.vsp.``GetLowerCSTCoefs`(std::string const & xsec_id) → DoubleVector

`openvsp.vsp.``GetLowerCSTDegree`(std::string const & xsec_id) → int

`openvsp.vsp.``GetMaterialNames`() → StringVector

`openvsp.vsp.``GetNumActuatorDisks`() → int

`openvsp.vsp.``GetNumAnalysis`() → int

`openvsp.vsp.``GetNumAnalysisInputData`(std::string const & analysis, std::string const & name) → int

`openvsp.vsp.``GetNumBackground3Ds`() → int

`openvsp.vsp.``GetNumControlSurfaceGroups`() → int

`openvsp.vsp.``GetNumData`(std::string const & results_id, std::string const & data_name) → int

`openvsp.vsp.``GetNumDesignVars`() → int

`openvsp.vsp.``GetNumMainSurfs`(std::string const & geom_id) → int

`openvsp.vsp.``GetNumPredefinedUserParms`() → int

`openvsp.vsp.``GetNumResults`(std::string const & name) → int

`openvsp.vsp.``GetNumSets`() → int

`openvsp.vsp.``GetNumSubSurf`(std::string const & geom_id) → int

`openvsp.vsp.``GetNumUnsteadyGroups`() → int

`openvsp.vsp.``GetNumUnsteadyRotorGroups`() → int

`openvsp.vsp.``GetNumUserParms`() → int

`openvsp.vsp.``GetNumXSec`(std::string const & xsec_surf_id) → int

`openvsp.vsp.``GetNumXSecSurfs`(std::string const & geom_id) → int

`openvsp.vsp.``GetParm`(std::string const & geom_id, std::string const & name, std::string const & group) → std::string

`openvsp.vsp.``GetParmContainer`(std::string const & parm_id) → std::string

`openvsp.vsp.``GetParmDescript`(std::string const & parm_id) → std::string

`openvsp.vsp.``GetParmDisplayGroupName`(std::string const & parm_id) → std::string

`openvsp.vsp.``GetParmGroupName`(std::string const & parm_id) → std::string

`openvsp.vsp.``GetParmLowerLimit`(std::string const & parm_id) → double

`openvsp.vsp.``GetParmName`(std::string const & parm_id) → std::string

`openvsp.vsp.``GetParmType`(std::string const & parm_id) → int

`openvsp.vsp.``GetParmUpperLimit`(std::string const & parm_id) → double

`openvsp.vsp.``GetParmVal`(std::string const & parm_id) → double

  GetParmVal(std::string const & geom_id, std::string const & name, std::string const & group) -> double

`openvsp.vsp.``GetResultsEntryDoc`(std::string const & results_id, std::string const & data_name) → std::string

`openvsp.vsp.``GetResultsName`(std::string const & results_id) → std::string

`openvsp.vsp.``GetResultsSetDoc`(std::string const & results_id) → std::string

`openvsp.vsp.``GetResultsType`(std::string const & results_id, std::string const & data_name) → int

`openvsp.vsp.``GetSetFlag`(std::string const & geom_id, int set_index) → bool

`openvsp.vsp.``GetSetIndex`(std::string const & name) → int

`openvsp.vsp.``GetSetName`(int index) → std::string

`openvsp.vsp.``GetStringAnalysisInput`(std::string const & analysis, std::string const & name, int index=0) → StringVector

`openvsp.vsp.``GetStringResults`(std::string const & id, std::string const & name, int index=0) → StringVector

`openvsp.vsp.``GetSubSurf`(std::string const & geom_id, int index) → std::string

  GetSubSurf(std::string const & geom_id, std::string const & name) -> StringVector

`openvsp.vsp.``GetSubSurfIDVec`(std::string const & geom_id) → StringVector

`openvsp.vsp.``GetSubSurfIndex`(std::string const & sub_id) → int

`openvsp.vsp.``GetSubSurfName`(std::string const & geom_id, std::string const & sub_id) → std::string

  GetSubSurfName(std::string const & sub_id) -> std::string

`openvsp.vsp.``GetSubSurfParmIDs`(std::string const & sub_id) → StringVector

`openvsp.vsp.``GetSubSurfType`(std::string const & sub_id) → int

`openvsp.vsp.``GetTotalNumSurfs`(std::string const & geom_id) → int

`openvsp.vsp.``GetUWTess01`(std::string const & geom_id, int const & surf_indx)

`openvsp.vsp.``GetUnsteadyGroupCompIDs`(int group_index) → StringVector

`openvsp.vsp.``GetUnsteadyGroupName`(int group_index) → std::string

`openvsp.vsp.``GetUnsteadyGroupSurfIndexes`(int group_index) → IntVector

`openvsp.vsp.``GetUpperCSTCoefs`(std::string const & xsec_id) → DoubleVector

`openvsp.vsp.``GetUpperCSTDegree`(std::string const & xsec_id) → int

`openvsp.vsp.``GetUserParmContainer`() → std::string

`openvsp.vsp.``GetVKTAirfoilCpDist`(double const & alpha, double const & epsilon, double const & kappa, double const & tau, Vec3dVec xyz_data) → DoubleVector

`openvsp.vsp.``GetVKTAirfoilPnts`(int const & npts, double const & alpha, double const & epsilon, double const & kappa, double const & tau) → Vec3dVec

`openvsp.vsp.``GetVSPAEROControlGroupName`(int CSGroupIndex) → std::string

`openvsp.vsp.``GetVSPAEROPath`() → std::string

`openvsp.vsp.``GetVSPAERORefWingID`() → string

`openvsp.vsp.``GetVSPExePath`() → std::string

`openvsp.vsp.``GetVSPFileName`() → std::string

`openvsp.vsp.``GetVSPVersion`() → std::string

`openvsp.vsp.``GetVSPVersionChange`() → int

`openvsp.vsp.``GetVSPVersionMajor`() → int

`openvsp.vsp.``GetVSPVersionMinor`() → int

`openvsp.vsp.``GetVarPresetGroupNames`() → StringVector

`openvsp.vsp.``GetVarPresetParmIDs`() → StringVector

`openvsp.vsp.``GetVarPresetParmIDsWName`(std::string const & group_name) → StringVector

`openvsp.vsp.``GetVarPresetParmVals`() → DoubleVector

`openvsp.vsp.``GetVarPresetParmValsWNames`(std::string const & group_name, std::string const & setting_name) → DoubleVector

`openvsp.vsp.``GetVarPresetSettingNamesWIndex`(int group_index) → StringVector

`openvsp.vsp.``GetVarPresetSettingNamesWName`(std::string const & group_name) → StringVector

`openvsp.vsp.``GetVec3dAnalysisInput`(std::string const & analysis, std::string const & name, int index=0) → Vec3dVec

`openvsp.vsp.``GetVec3dResults`(std::string const & id, std::string const & name, int index=0) → Vec3dVec

`openvsp.vsp.``GetVehicleID`() → std::string

`openvsp.vsp.``GetXSec`(std::string const & xsec_surf_id, int xsec_index) → std::string

`openvsp.vsp.``GetXSecHeight`(std::string const & xsec_id) → double

`openvsp.vsp.``GetXSecParm`(std::string const & xsec_id, std::string const & name) → std::string

`openvsp.vsp.``GetXSecParmIDs`(std::string const & xsec_id) → StringVector

`openvsp.vsp.``GetXSecShape`(std::string const & xsec_id) → int

`openvsp.vsp.``GetXSecSurf`(std::string const & geom_id, int index) → std::string

`openvsp.vsp.``GetXSecSurfGlobalXForm`(std::string const & xsec_surf_id) → Matrix4d

`openvsp.vsp.``GetXSecWidth`(std::string const & xsec_id) → double

`openvsp.vsp.``HEIGHT_XSEC_DRIVER` = 2

  Height driver

`openvsp.vsp.``HINGE_GEOM_SCREEN` = 9

  Hinge geom screen

`openvsp.vsp.``HUMAN_GEOM_SCREEN` = 15

  Human geom screen

`openvsp.vsp.``HWRATIO_XSEC_DRIVER` = 3

  Height/width ratio driver

`openvsp.vsp.``HideAllBackground3Ds`()

`openvsp.vsp.``IMPORT_BEM` = 6

  Blade Element (*.bem) import

`openvsp.vsp.``IMPORT_CART3D_TRI` = 2

  Cart3D (*.try) import

`openvsp.vsp.``IMPORT_NASCART` = 1

  NASCART (*.dat) import

`openvsp.vsp.``IMPORT_P3D_WIRE` = 8

  Plot3D as Wireframe (*.p3d) import

`openvsp.vsp.``IMPORT_PTS` = 4

  Point Cloud (*.pts) import

`openvsp.vsp.``IMPORT_STL` = 0

  Stereolith (*.stl) import

`openvsp.vsp.``IMPORT_V2` = 5

  OpenVSP v2 (*.vsp) import

`openvsp.vsp.``IMPORT_XSEC_MESH` = 3

  XSec as Tri Mesh (*.hrm) import

`openvsp.vsp.``IMPORT_XSEC_WIRE` = 7

  XSec as Wireframe (*.hrm) import

`openvsp.vsp.``INSIDE` = 0

  The interior of the sub-surface is its surface

`openvsp.vsp.``INTERSECT_CURV_FILE_NAME` = 1

  CURV intersection file type

`openvsp.vsp.``INTERSECT_IGES_FILE_NAME` = 3

  IGES intersection file type

`openvsp.vsp.``INTERSECT_NUM_FILE_NAMES` = 5

  Number of surface intersection file types

`openvsp.vsp.``INTERSECT_PLOT3D_FILE_NAME` = 2

  PLOT3D intersection file type

`openvsp.vsp.``INTERSECT_SRF_FILE_NAME` = 0

  SRF intersection file type

`openvsp.vsp.``INTERSECT_STEP_FILE_NAME` = 4

  STEP intersection file type

`openvsp.vsp.``INT_DATA` = 0

  Integer result data type

`openvsp.vsp.``INVALID_TYPE` = -1

  Invalid result data type

`openvsp.vsp.``ImportFile`(std::string const & file_name, int file_type, std::string const & parent) → std::string

`openvsp.vsp.``InsertVSPFile`(std::string const & file_name, std::string const & parent_geom_id)

`openvsp.vsp.``InsertXSec`(std::string const & geom_id, int index, int type)

`openvsp.vsp.``InsideSurf`(std::string const & geom_id, int const & surf_indx, vec3d pt) → bool

class `openvsp.vsp.``IntVector`(*args)

  Bases: `object`

  `append`(x)
  `assign`(n, x)
  `back`()
  `begin`()
  `capacity`()
  `clear`()
  `empty`()
  `end`()
  `erase`(*args)
  `front`()
  `get_allocator`()
  `insert`(*args)
  `iterator`()
  `pop`()
  `pop_back`()
  `push_back`(x)
  `rbegin`()
  `rend`()
  `reserve`(n)
  `resize`(*args)
  `size`()
  `swap`(v)
  property `thisown`

    The membership flag

`openvsp.vsp.``IntegrateEllipsoidFlow`(vec3d abc_rad, int const & abc_index) → double

`openvsp.vsp.``IsEventLoopRunning`() → bool

`openvsp.vsp.``IsFacade`()

  Returns True if the facade API is in use.

      is_facade = IsFacade()

`openvsp.vsp.``IsGUIBuild`() → bool

`openvsp.vsp.``IsGUIRunning`()

  Returns True if the GUI event loop is running.

      is_gui_active = IsGUIRunning()

`openvsp.vsp.``LEN_CM` = 1

  Centimeter

`openvsp.vsp.``LEN_FT` = 4

  Feet

`openvsp.vsp.``LEN_IN` = 3

  Inch

`openvsp.vsp.``LEN_M` = 2

  Meter

`openvsp.vsp.``LEN_MM` = 0

  Millimeter

`openvsp.vsp.``LEN_UNITLESS` = 6

  Unitless

`openvsp.vsp.``LEN_YD` = 5

  Yard

`openvsp.vsp.``LE_NORMAL` = 1

  FEA Rib or Rib Array is set perpendicular to the leading edge

`openvsp.vsp.``LINEAR` = 0

  Linear curve type

`openvsp.vsp.``LINE_SOURCE` = 1

  Line source

`openvsp.vsp.``L_TRIM` = 1

  Trim by L coordinate

`openvsp.vsp.``ListAnalysis`() → StringVector

`openvsp.vsp.``Lock`()

`openvsp.vsp.``MALE` = 0

  Male Human component

`openvsp.vsp.``MANUAL_REF` = 0

  Manually specify the reference areas and lengths

`openvsp.vsp.``MASS_LBFSEC2IN` = 5

  lbf*sec^2/in

`openvsp.vsp.``MASS_UNIT_G` = 0

  Gram

`openvsp.vsp.``MASS_UNIT_KG` = 1

  Kilogram

`openvsp.vsp.``MASS_UNIT_LBM` = 3

  Pound-mass

`openvsp.vsp.``MASS_UNIT_SLUG` = 4

  Slug

`openvsp.vsp.``MASS_UNIT_TONNE` = 2

  Tonne

`openvsp.vsp.``MAX_CAMB` = 0

  Input maximum camber, calculate ideal lift coefficient

`openvsp.vsp.``MAX_LEN_CONSTRAINT` = 1

  Maximum edge length.

`openvsp.vsp.``MAX_NUM_SETS` = 1000

  Maximum possible number of sets

`openvsp.vsp.``MESH_GEOM_SCREEN` = 4

  Mesh geom screen

`openvsp.vsp.``MESH_INDEXED_TRI` = 0

  Indexed triangulated mesh Geom type

`openvsp.vsp.``MESH_INDEX_AND_SLICE_TRI` = 3

  Both indexed and sliced triangulated mesh Geom type

`openvsp.vsp.``MESH_SLICE_TRI` = 1

  Sliced Triangulated mesh Geom type

`openvsp.vsp.``MIN_GROW_LIMIT` = 10

  Reason marker for minimum reason to apply growth limit.

`openvsp.vsp.``MIN_LEN_CONSTRAINT` = 5

  Minimum edge length.

`openvsp.vsp.``MIN_LEN_CONSTRAINT_CURV_GAP` = 6

  Maximum gap constrained by minimum length.

`openvsp.vsp.``MIN_LEN_CONSTRAINT_CURV_NCIRCSEG` = 7

  Number of segments to define a circle constrained by minimum length.

`openvsp.vsp.``MIN_LEN_CONSTRAINT_SOURCES` = 8

  Mesh sources constrained by minimum length (not applied).

`openvsp.vsp.``MIN_LEN_INCREMENT` = 4

  Reason increment when adding minimum length constraint.

`openvsp.vsp.``MIN_NUM_USER` = 20

  Minimum number of user sets

`openvsp.vsp.``MPA_UNIT` = 2

  FEA Files output in (mm, tonne)

`openvsp.vsp.``MS_WING_GEOM_SCREEN` = 2

  Wing geom screen

`openvsp.vsp.``MULT_GEOM_SCREEN` = 10

  Multiple geom screen

`openvsp.vsp.``MapFromPlane`(vec2d const & uw, vec3d planeOrig, vec3d planeVec1, vec3d planeVec2) → vec3d

`openvsp.vsp.``MapToPlane`(vec3d p, vec3d planeOrig, vec3d planeVec1, vec3d planeVec2) → vec2d

class `openvsp.vsp.``Matrix4d`

  Bases: `object`

  Proxy of C++ Matrix4d class.

  `affineInverse`(Matrix4d self)
  `buildXForm`(Matrix4d self, vec3d pos, vec3d rot, vec3d cent_rot)
  `data`(Matrix4d self) → double *
  `flipx`(Matrix4d self)
  `getAngles`(Matrix4d self) → vec3d
  `getBasis`(Matrix4d self, vec3d xdir, vec3d ydir, vec3d zdir)
  `getMat`(Matrix4d self, double * m)
  `getTranslation`(Matrix4d self) → vec3d
  `initMat`(Matrix4d self, double const * m)

    initMat(Matrix4d self, Matrix4d m)

  `loadIdentity`(Matrix4d self)
  `loadXYRef`(Matrix4d self)
  `loadXZRef`(Matrix4d self)
  `loadYZRef`(Matrix4d self)
  `matMult`(Matrix4d self, double const * m)

    matMult(Matrix4d self, Matrix4d m)

  `mult`(Matrix4d self, double const [4] _in, double [4] out)
  `postMult`(Matrix4d self, double const * m)

    postMult(Matrix4d self, Matrix4d m)

  `rotate`(Matrix4d self, double const & angle, vec3d axis)
  `rotateX`(Matrix4d self, double const & ang)
  `rotateY`(Matrix4d self, double const & ang)
  `rotateZ`(Matrix4d self, double const & ang)
  `rotatealongX`(Matrix4d self, vec3d dir1)
  `scale`(Matrix4d self, double const & scale)
  `scalex`(Matrix4d self, double const & scalex)
  `scaley`(Matrix4d self, double const & scaley)
  `scalez`(Matrix4d self, double const & scalez)
  `setBasis`(Matrix4d self, vec3d xdir, vec3d ydir, vec3d zdir)
  static `setIdentity`(double * m)
  property `thisown`

    The membership flag

  `toQuat`(Matrix4d self, double & qw, double & qx, double & qy, double & qz, double & tx, double & ty, double & tz)
  `translatef`(Matrix4d self, double const & x, double const & y, double const & z)
  `translatev`(Matrix4d self, vec3d v)
  `xform`(Matrix4d self, vec3d _in) → vec3d
  `xformmat`(Matrix4d self, std::vector< std::vector< vec3d, std::allocator< vec3d > >, std::allocator< std::vector< vec3d, std::allocator< vec3d > > > > & _in)
  `xformnorm`(Matrix4d self, vec3d _in) → vec3d
  `xformnormmat`(Matrix4d self, std::vector< std::vector< vec3d, std::allocator< vec3d > >, std::allocator< std::vector< vec3d, std::allocator< vec3d > > > > & _in)
  `xformnormvec`(Matrix4d self, Vec3dVec _in)
  `xformvec`(Matrix4d self, Vec3dVec _in)
  `zeroTranslations`(Matrix4d self)

class `openvsp.vsp.``Matrix4dVec`(*args)

  Bases: `object`

  `append`(x)
  `assign`(n, x)
  `back`()
  `begin`()
  `capacity`()
  `clear`()
  `empty`()
  `end`()
  `erase`(*args)
  `front`()
  `get_allocator`()
  `insert`(*args)
  `iterator`()
  `pop`()
  `pop_back`()
  `push_back`(x)
  `rbegin`()
  `rend`()
  `reserve`(n)
  `resize`(*args)
  `size`()
  `swap`(v)
  property `thisown`

    The membership flag

`openvsp.vsp.``Matrix4d_setIdentity`(double * m)

`openvsp.vsp.``MoveEditXSecPnt`(std::string const & xsec_id, int const & indx, vec3d new_pnt)

`openvsp.vsp.``NOISE_ENGLISH` = 1

  Assume geometry and VSPAERO inputs in english (ft lbf slug s) units, will convert to SI (m N kg s) for PSU-WOPWOP

`openvsp.vsp.``NOISE_FLYBY` = 0

  Set up fly by noise analysis in VSPAERO for PSU-WOPWOP

`openvsp.vsp.``NOISE_FOOTPRINT` = 1

  Set up footprint noise analysis in VSPAERO for PSU-WOPWOP

`openvsp.vsp.``NOISE_SI` = 0

  Assume geometry and VSPAERO inputs in SI (m N kg s) for PSU-WOPWOP

`openvsp.vsp.``NOISE_STEADY` = 2

  Set up steady state noise analysis in VSPAERO for PSU-WOPWOP

`openvsp.vsp.``NONE` = 2

  No part of the parent surface belongs to the sub-surface

`openvsp.vsp.``NORMAL_SURF` = 0

  Normal VSP surface

`openvsp.vsp.``NO_BOUNDARY` = 0

  No boundary

`openvsp.vsp.``NO_END_CAP` = 0

  No end cap

`openvsp.vsp.``NO_FILE_TYPE` = 0

  No export file type

`openvsp.vsp.``NO_NORMAL` = 0

  FEA Rib or Rib Array has no set perpendicular edge

`openvsp.vsp.``NO_REASON` = 0

  No reason determined.

`openvsp.vsp.``NUM_ALIGN_TYPE` = 7

  Number of alignment types

`openvsp.vsp.``NUM_ANG` = 4

  Number of angle choices

`openvsp.vsp.``NUM_DEPTH_TYPE` = 3

  Number of depth types

`openvsp.vsp.``NUM_END_CAP_OPTIONS` = 10

  Number of end cap options

`openvsp.vsp.``NUM_FILE_CHOOSER_MODES` = 2

  Number of file chooser modes

`openvsp.vsp.``NUM_FILE_CHOOSER_TYPES` = 2

  Number of file chooser types

`openvsp.vsp.``NUM_GDEV_TYPES` = 30

  Number of GDEV types

`openvsp.vsp.``NUM_GEOM_SCREENS` = 16

  Number of geom screens

`openvsp.vsp.``NUM_LEN_UNIT` = 7

  Number of length unit types

`openvsp.vsp.``NUM_MASS_UNIT` = 6

  Number of mass unit types

`openvsp.vsp.``NUM_MESH_REASON` = 17

  Number of reasons that can set the mesh local minimum edge length.

`openvsp.vsp.``NUM_PCURV_TYPE` = 4

  Number of curve types

`openvsp.vsp.``NUM_PRES_UNIT` = 11

  Number of pressure unit choices

`openvsp.vsp.``NUM_PROJ_BNDY_OPTIONS` = 3

  Number of projected area boundary options

`openvsp.vsp.``NUM_PROJ_DIR_OPTIONS` = 5

  Number of Projected Area direction types

`openvsp.vsp.``NUM_PROJ_TGT_OPTIONS` = 2

  Number of Projected Area target types

`openvsp.vsp.``NUM_PROP_AZI` = 3

  Number of propeller blade azimuth modes

`openvsp.vsp.``NUM_PROP_PCURVE` = 9

  Number of propeller blade curve parameterization options

`openvsp.vsp.``NUM_REF_TYPES` = 2

  Number of wing reference types

`openvsp.vsp.``NUM_REORDER_TYPES` = 4

  Number reordering instructions

`openvsp.vsp.``NUM_RHO_UNIT` = 7

  Number of density unit options

`openvsp.vsp.``NUM_SCALE_TYPES` = 4

  Number of ways to scale 3D background image.

`openvsp.vsp.``NUM_SOURCE_TYPES` = 5

  Number of CFD Mesh source types

`openvsp.vsp.``NUM_SURF_TYPES` = 3

  Number of VSP surface types

`openvsp.vsp.``NUM_TEMP_UNIT` = 4

  Number of temperature unit choices

`openvsp.vsp.``NUM_TRIM_TYPES` = 3

  Number of conformal component trim types

`openvsp.vsp.``NUM_WSECT_DRIVER` = 8

  Number of wing section drivers

`openvsp.vsp.``NUM_XSEC_DRIVER` = 4

  Number of XSec drivers

`openvsp.vsp.``NumFeaBCs`(string const & fea_struct_id) → int

`openvsp.vsp.``NumFeaParts`(std::string const & fea_struct_id) → int

`openvsp.vsp.``NumFeaStructures`() → int

`openvsp.vsp.``NumFeaSubSurfs`(std::string const & fea_struct_id) → int

`openvsp.vsp.``OPEN` = 0

  Browse files that already exist

`openvsp.vsp.``OUTSIDE` = 1

  The exterior of the sub-surface is its surface

`openvsp.vsp.``PANEL` = 1

  VSPAERO panel method

`openvsp.vsp.``PARM_BOOL_TYPE` = 2

  Bool Parm type (BoolParm)

`openvsp.vsp.``PARM_DOUBLE_TYPE` = 0

  Double Parm type (Parm)

`openvsp.vsp.``PARM_FRACTION_TYPE` = 3

  Fraction Parm type (FractionParm)

`openvsp.vsp.``PARM_INT_TYPE` = 1

  Integer Parm type (IntParm)

`openvsp.vsp.``PARM_LIMITED_INT_TYPE` = 4

  Limited integer Parm type (LimIntParm)

`openvsp.vsp.``PARM_NOTEQ_TYPE` = 5

  Not equal Parm type (NotEqParm)

`openvsp.vsp.``PARM_POWER_INT_TYPE` = 6

  Power integer Parm type (PowIntParm)

`openvsp.vsp.``PATCH_COPY` = 3

  Copy patch type

`openvsp.vsp.``PATCH_HALFWAY` = 4

  Halfway patch type

`openvsp.vsp.``PATCH_LINE` = 2

  Line patch type

`openvsp.vsp.``PATCH_NONE` = 0

  No patch

`openvsp.vsp.``PATCH_NUM_TYPES` = 5

  Number of patch types

`openvsp.vsp.``PATCH_POINT` = 1

  Point patch type

`openvsp.vsp.``PCHIP` = 1

  Piecewise Cubic Hermite Interpolating Polynomial curve type

`openvsp.vsp.``PCurveConvertTo`(std::string const & geom_id, int const & pcurveid, int const & newtype)

`openvsp.vsp.``PCurveDeletePt`(std::string const & geom_id, int const & pcurveid, int const & indx)

`openvsp.vsp.``PCurveGetTVec`(std::string const & geom_id, int const & pcurveid) → DoubleVector

`openvsp.vsp.``PCurveGetType`(std::string const & geom_id, int const & pcurveid) → int

`openvsp.vsp.``PCurveGetValVec`(std::string const & geom_id, int const & pcurveid) → DoubleVector

`openvsp.vsp.``PCurveSplit`(std::string const & geom_id, int const & pcurveid, double const & tsplit) → int

`openvsp.vsp.``PD_UNITS_IMPERIAL` = 0

  Imperial unit system

`openvsp.vsp.``PD_UNITS_METRIC` = 1

  Metric unit system

`openvsp.vsp.``POD_GEOM_SCREEN` = 0

  Pod geom screen

`openvsp.vsp.``POINT_SOURCE` = 0

  Point source

`openvsp.vsp.``PRECON_JACOBI` = 1

  Jacobi preconditioner

`openvsp.vsp.``PRECON_MATRIX` = 0

  Matrix preconditioner

`openvsp.vsp.``PRECON_SSOR` = 2

  Symmetric successive over-relaxation preconditioner

`openvsp.vsp.``PRES_UNIT_ATM` = 10

  Atmosphere

`openvsp.vsp.``PRES_UNIT_BA` = 2

  Barye

`openvsp.vsp.``PRES_UNIT_INCHHG` = 6

  Inch of mercury

`openvsp.vsp.``PRES_UNIT_KPA` = 4

  Kilopascal

`openvsp.vsp.``PRES_UNIT_MB` = 9

  Millibar

`openvsp.vsp.``PRES_UNIT_MMH20` = 8

  Millimeter of water

`openvsp.vsp.``PRES_UNIT_MMHG` = 7

  Millimeter of mercury

`openvsp.vsp.``PRES_UNIT_MPA` = 5

  Megapascal

`openvsp.vsp.``PRES_UNIT_PA` = 3

  Pascal

`openvsp.vsp.``PRES_UNIT_PSF` = 0

  Pounds per square foot

`openvsp.vsp.``PRES_UNIT_PSI` = 1

  Pounds per square inch

`openvsp.vsp.``PROP_AXIAL` = 7

  Axial parameterization

`openvsp.vsp.``PROP_AZI_BALANCED` = 2

  Propeller blade balance is enforced

`openvsp.vsp.``PROP_AZI_FREE` = 1

  Propeller blades are free to spaced arbitrarially

`openvsp.vsp.``PROP_AZI_UNIFORM` = 0

  Propeller blades are uniformly spaced

`openvsp.vsp.``PROP_BLADES` = 0

  Propeller Geom is defined by individual propeller blades

`openvsp.vsp.``PROP_BOTH` = 1

  Propeller Geom is defined by blades and a disk together

`openvsp.vsp.``PROP_CHORD` = 0

  Chord parameterization

`openvsp.vsp.``PROP_CLI` = 6

  Induced lift coefficient parameterization

`openvsp.vsp.``PROP_DISK` = 2

  Propeller Geom is defined by a flat circular disk

`openvsp.vsp.``PROP_GEOM_SCREEN` = 8

  Propeller geom screen

`openvsp.vsp.``PROP_RAKE` = 2

  Rake parameterization

`openvsp.vsp.``PROP_SKEW` = 3

  Skew parameterization

`openvsp.vsp.``PROP_SWEEP` = 4

  Sweep parameterization

`openvsp.vsp.``PROP_TANGENTIAL` = 8

  Tangential parameterization

`openvsp.vsp.``PROP_THICK` = 5

  Thickness parameterization

`openvsp.vsp.``PROP_TWIST` = 1

  Twist parameterization

`openvsp.vsp.``PT_CLOUD_GEOM_SCREEN` = 7

  Point cloud geom screen

`openvsp.vsp.``PasteGeomClipboard`(std::string const & parent=std::string()) → StringVector

`openvsp.vsp.``PasteXSec`(std::string const & geom_id, int index)

`openvsp.vsp.``PopupMsg`(std::string const & msg)

`openvsp.vsp.``PrintAnalysisDocs`(std::string const & analysis_name)

`openvsp.vsp.``PrintAnalysisInputs`(std::string const & analysis_name)

`openvsp.vsp.``PrintResults`(std::string const & results_id)

`openvsp.vsp.``PrintResultsDocs`(std::string const & results_id)

`openvsp.vsp.``ProjPnt01`(std::string const & geom_id, int const & surf_indx, vec3d pt) → double

`openvsp.vsp.``ProjPnt01Guess`(std::string const & geom_id, int const & surf_indx, vec3d pt, double const & u0, double const & w0) → double

`openvsp.vsp.``ProjPnt01I`(std::string const & geom_id, vec3d pt) → double

`openvsp.vsp.``ProjVecPnt01`(std::string const & geom_id, int const & surf_indx, Vec3dVec pts)

`openvsp.vsp.``ProjVecPnt01Guess`(std::string const & geom_id, int const & surf_indx, Vec3dVec pts, DoubleVector u0s, DoubleVector w0s)

`openvsp.vsp.``PromoteBORCSTLower`(std::string const & bor_id)

`openvsp.vsp.``PromoteBORCSTUpper`(std::string const & bor_id)

`openvsp.vsp.``PromoteCSTLower`(std::string const & xsec_id)

`openvsp.vsp.``PromoteCSTUpper`(std::string const & xsec_id)

`openvsp.vsp.``PtInTri`(vec3d v0, vec3d v1, vec3d v2, vec3d p) → bool

`openvsp.vsp.``REASON` = 1

  Color mesh by local edge length reason

`openvsp.vsp.``REL` = 1

  Relative position

`openvsp.vsp.``REORDER_MOVE_BOTTOM` = 3

  Move to bottom

`openvsp.vsp.``REORDER_MOVE_DOWN` = 1

  Move down one position

`openvsp.vsp.``REORDER_MOVE_TOP` = 2

  Move to top

`openvsp.vsp.``REORDER_MOVE_UP` = 0

  Move up one position

`openvsp.vsp.``RHO_UNIT_G_CM3` = 1

  Gram per cubic centimeter

`openvsp.vsp.``RHO_UNIT_KG_M3` = 2

  Kilogram per cubic meter

`openvsp.vsp.``RHO_UNIT_LBFSEC2_IN4` = 5

  Pound-force-second squared per inch to the fourth

`openvsp.vsp.``RHO_UNIT_LBM_FT3` = 4

  Pound-mass per cubic foot

`openvsp.vsp.``RHO_UNIT_LBM_IN3` = 6

  Pound-mass per cubic inch

`openvsp.vsp.``RHO_UNIT_SLUG_FT3` = 0

  Slug per cubic foot

`openvsp.vsp.``RHO_UNIT_TONNE_MM3` = 3

  Tonne per cubic millimeter

`openvsp.vsp.``ROOTC_WSECT_DRIVER` = 5

  Root chord driver

`openvsp.vsp.``ROT_0` = 0

  No rotation

`openvsp.vsp.``ROT_180` = 2

  180 degree rotation

`openvsp.vsp.``ROT_270` = 3

  270 degree rotation

`openvsp.vsp.``ROT_90` = 1

  90 degree rotation

`openvsp.vsp.``ROUND_END_CAP` = 2

  Round end cap

`openvsp.vsp.``ROUND_EXT_END_CAP_BOTH` = 9

  Extended round end cap, extend both

`openvsp.vsp.``ROUND_EXT_END_CAP_LE` = 7

  Extended round end cap, extend LE

`openvsp.vsp.``ROUND_EXT_END_CAP_NONE` = 6

  Extended round end cap, but not extended

`openvsp.vsp.``ROUND_EXT_END_CAP_TE` = 8

  Extended round end cap, extend TE

`openvsp.vsp.``ReadApplyDESFile`(std::string const & file_name)

`openvsp.vsp.``ReadApplyXDDMFile`(std::string const & file_name)

`openvsp.vsp.``ReadBORFileAirfoil`(std::string const & bor_id, std::string const & file_name)

`openvsp.vsp.``ReadBORFileXSec`(std::string const & bor_id, std::string const & file_name) → Vec3dVec

`openvsp.vsp.``ReadFileAirfoil`(std::string const & xsec_id, std::string const & file_name)

`openvsp.vsp.``ReadFileXSec`(std::string const & xsec_id, std::string const & file_name) → Vec3dVec

`openvsp.vsp.``ReadVSPFile`(std::string const & file_name)

`openvsp.vsp.``RegisterCFDMeshAnalyses`()

`openvsp.vsp.``RemoveAllFromVSPAEROControlSurfaceGroup`(int CSGroupIndex)

`openvsp.vsp.``RemoveSelectedFromCSGroup`(IntVector selected, int CSGroupIndex)

`openvsp.vsp.``ReparameterizeEditXSec`(std::string const & xsec_id)

`openvsp.vsp.``ResetPropellerThicknessCurve`(std::string const & geom_id)

`openvsp.vsp.``ResetViews`()

`openvsp.vsp.``ResetXSecSkinParms`(std::string const & xsec_id)

`openvsp.vsp.``RotateArbAxis`(vec3d p, double theta, vec3d r) → vec3d

`openvsp.vsp.``RotateSet`(int set_index, double x_rot_deg, double y_rot_deg, double z_rot_deg)

`openvsp.vsp.``SAVE` = 1

  Browse file system and enter file name

`openvsp.vsp.``SCALE_HEIGHT` = 1

  Scale image to match desired height

`openvsp.vsp.``SCALE_RESOLUTION` = 3

  Scale image to specified resolution

`openvsp.vsp.``SCALE_WIDTH` = 0

  Scale image to match desired width

`openvsp.vsp.``SCALE_WIDTH_HEIGHT` = 2

  Scale image to match desired width and height

`openvsp.vsp.``SECSWEEP_WSECT_DRIVER` = 7

  Section sweep driver

`openvsp.vsp.``SELIG_AF_EXPORT` = 0

  Selig airfoil file format

`openvsp.vsp.``SET_2D` = 1

  2D DXF export

`openvsp.vsp.``SET_3D` = 0

  3D DXF export (default)

`openvsp.vsp.``SET_ALL` = 0

  All set

`openvsp.vsp.``SET_BOUNDARY` = 1

  Set boundary

`openvsp.vsp.``SET_FIRST_USER` = 3

  First user-defined set

`openvsp.vsp.``SET_NONE` = -1

  None set

`openvsp.vsp.``SET_NOT_SHOWN` = 2

  Not shown set

`openvsp.vsp.``SET_SHOWN` = 1

  Shown set

`openvsp.vsp.``SET_TARGET` = 0

  Set target type

`openvsp.vsp.``SHARP_END_CAP` = 4

  Sharp end cap

`openvsp.vsp.``SI_UNIT` = 0

  FEA Files output in (m, kg)

`openvsp.vsp.``SOURCES` = 4

  Mesh sources.

`openvsp.vsp.``SPAN_WSECT_DRIVER` = 1

  Span driver

`openvsp.vsp.``SPAR_NORMAL` = 3

  FEA Rib or Rib Array is set perpendicular to an FEA Spar

`openvsp.vsp.``SPINE_NORMAL` = 6

  Slice is perpendicular to thespine of the parent Geom

`openvsp.vsp.``SS_CONTROL` = 3

  Control sub-surface type

`openvsp.vsp.``SS_ELLIPSE` = 2

  Ellipse sub-surface type

`openvsp.vsp.``SS_FINITE_LINE` = 5

  Finite line sub-surface type

`openvsp.vsp.``SS_INC_SEPARATE_TREATMENT` = 1

  Treat the sub-surface separately from the parent

`openvsp.vsp.``SS_INC_TREAT_AS_PARENT` = 0

  Treat the sub-surface the same as the parent

`openvsp.vsp.``SS_INC_ZERO_DRAG` = 2

  No drag contribution for the sub-surface

`openvsp.vsp.``SS_LINE` = 0

  Line sub-surface type

`openvsp.vsp.``SS_LINE_ARRAY` = 4

  Line array sub-surface type

`openvsp.vsp.``SS_NUM_TYPES` = 6

  Number of sub-surface types

`openvsp.vsp.``SS_RECTANGLE` = 1

  Rectangle sub-surface type

`openvsp.vsp.``STABILITY_DEFAULT` = 1

  Steady 6DOF stability analysis

`openvsp.vsp.``STABILITY_NUM_TYPES` = 6

  Number of stability analysis types

`openvsp.vsp.``STABILITY_OFF` = 0

  No stability analysis (off)

`openvsp.vsp.``STABILITY_PITCH` = 5

  Simplified pitch stability analysis

`openvsp.vsp.``STABILITY_P_ANALYSIS` = 2

  Unsteady roll stability analysis

`openvsp.vsp.``STABILITY_Q_ANALYSIS` = 3

  Unsteady pitch stability analysis

`openvsp.vsp.``STABILITY_R_ANALYSIS` = 4

  Unsteady yaw stability analysis

`openvsp.vsp.``STACK_GEOM_SCREEN` = 5

  Stack geom screen

`openvsp.vsp.``STEP_BREP` = 1

  Manifold solid BREP STEP file representation

`openvsp.vsp.``STEP_SHELL` = 0

  Manifold shell surface STEP file representation

`openvsp.vsp.``STRING_DATA` = 2

  String result data type

`openvsp.vsp.``SYM_ALL` = 3

  All cross section symmetry.

`openvsp.vsp.``SYM_NONE` = 0

  No cross section symmetry.

`openvsp.vsp.``SYM_NUM_TYPES` = 6

  Number of symmetry types.

`openvsp.vsp.``SYM_PLANAR_TYPES` = 3

  Number of planar symmetry types.

`openvsp.vsp.``SYM_RL` = 1

  Right/left cross section symmetry.

`openvsp.vsp.``SYM_ROT_X` = 8

  X rotational symmetry.

`openvsp.vsp.``SYM_ROT_Y` = 16

  Y rotational symmetry.

`openvsp.vsp.``SYM_ROT_Z` = 32

  Z rotational symmetry.

`openvsp.vsp.``SYM_TB` = 2

  Top/bottom cross section symmetry.

`openvsp.vsp.``SYM_XY` = 1

  XY planar symmetry.

`openvsp.vsp.``SYM_XZ` = 2

  XZ planar symmetry.

`openvsp.vsp.``SYM_YZ` = 4

  YZ planar symmetry.

`openvsp.vsp.``ScaleSet`(int set_index, double scale)

`openvsp.vsp.``ScreenGrab`(string const & fname, int w, int h, bool transparentBG, bool autocrop=False)

`openvsp.vsp.``SearchReplaceAdvLinkCode`(int index, string const & _from, string const & to)

`openvsp.vsp.``SetAdvLinkCode`(int index, string const & code)

`openvsp.vsp.``SetAirfoilLowerPnts`(std::string const & xsec_id, Vec3dVec low_pnt_vec)

`openvsp.vsp.``SetAirfoilPnts`(std::string const & xsec_id, Vec3dVec up_pnt_vec, Vec3dVec low_pnt_vec)

`openvsp.vsp.``SetAirfoilUpperPnts`(std::string const & xsec_id, Vec3dVec up_pnt_vec)

`openvsp.vsp.``SetAllViews`(int view)

`openvsp.vsp.``SetAnalysisInputDefaults`(std::string const & analysis)

`openvsp.vsp.``SetBEMPropID`(string const & prop_id)

`openvsp.vsp.``SetBORAirfoilLowerPnts`(std::string const & bor_id, Vec3dVec low_pnt_vec)

`openvsp.vsp.``SetBORAirfoilPnts`(std::string const & bor_id, Vec3dVec up_pnt_vec, Vec3dVec low_pnt_vec)

`openvsp.vsp.``SetBORAirfoilUpperPnts`(std::string const & bor_id, Vec3dVec up_pnt_vec)

`openvsp.vsp.``SetBORLowerCST`(std::string const & bor_id, int deg, DoubleVector coefs)

`openvsp.vsp.``SetBORUpperCST`(std::string const & bor_id, int deg, DoubleVector coefs)

`openvsp.vsp.``SetBORXSecPnts`(std::string const & bor_id, Vec3dVec pnt_vec)

`openvsp.vsp.``SetBackground`(double r, double g, double b)

`openvsp.vsp.``SetBackground3DAbsolutePath`(string const & id, string const & fname)

`openvsp.vsp.``SetBackground3DRelativePath`(string const & id, string const & fname)

`openvsp.vsp.``SetCFDMeshVal`(int type, double val)

`openvsp.vsp.``SetCFDWakeFlag`(std::string const & geom_id, bool flag)

`openvsp.vsp.``SetComputationFileName`(int file_type, std::string const & file_name)

`openvsp.vsp.``SetDoubleAnalysisInput`(std::string const & analysis, std::string const & name, DoubleVector indata, int index=0)

`openvsp.vsp.``SetDriverGroup`(std::string const & geom_id, int section_index, int driver_0, int driver_1=-1, int driver_2=-1)

`openvsp.vsp.``SetEditXSecFixedUVec`(std::string const & xsec_id, BoolVector fixed_u_vec)

`openvsp.vsp.``SetEditXSecPnts`(std::string const & xsec_id, DoubleVector u_vec, Vec3dVec control_pts, DoubleVector r_vec)

`openvsp.vsp.``SetFeaMeshFileName`(std::string const & geom_id, int fea_struct_ind, int file_type, string const & file_name)

`openvsp.vsp.``SetFeaMeshStructIndex`(int struct_index)

`openvsp.vsp.``SetFeaMeshVal`(std::string const & geom_id, int fea_struct_ind, int type, double val)

`openvsp.vsp.``SetFeaPartName`(std::string const & part_id, std::string const & name)

`openvsp.vsp.``SetFeaPartPerpendicularSparID`(std::string const & part_id, std::string const & perpendicular_spar_id)

`openvsp.vsp.``SetFeaStructName`(std::string const & geom_id, int fea_struct_ind, std::string const & name)

`openvsp.vsp.``SetFeaSubSurfName`(std::string const & subsurf_id, std::string const & name)

`openvsp.vsp.``SetGUIElementDisable`(int e, bool state)

`openvsp.vsp.``SetGUIScreenDisable`(int s, bool state)

`openvsp.vsp.``SetGeomDisplayType`(string const & geom_id, int type)

`openvsp.vsp.``SetGeomDrawType`(string const & geom_id, int type)

`openvsp.vsp.``SetGeomMaterialName`(string const & geom_id, string const & name)

`openvsp.vsp.``SetGeomName`(std::string const & geom_id, std::string const & name)

`openvsp.vsp.``SetGeomScreenDisable`(int s, bool state)

`openvsp.vsp.``SetGeomWireColor`(string const & geom_id, int r, int g, int b)

`openvsp.vsp.``SetIntAnalysisInput`(std::string const & analysis, std::string const & name, IntVector indata, int index=0)

`openvsp.vsp.``SetLowerCST`(std::string const & xsec_id, int deg, DoubleVector coefs)

`openvsp.vsp.``SetPCurve`(std::string const & geom_id, int const & pcurveid, DoubleVector tvec, DoubleVector valvec, int const & newtype)

`openvsp.vsp.``SetParmDescript`(std::string const & parm_id, std::string const & desc)

`openvsp.vsp.``SetParmLowerLimit`(std::string const & parm_id, double val)

`openvsp.vsp.``SetParmUpperLimit`(std::string const & parm_id, double val)

`openvsp.vsp.``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

`openvsp.vsp.``SetParmValLimits`(std::string const & parm_id, double val, double lower_limit, double upper_limit) → double

`openvsp.vsp.``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

`openvsp.vsp.``SetSetFlag`(std::string const & geom_id, int set_index, bool flag)

`openvsp.vsp.``SetSetName`(int index, std::string const & name)

`openvsp.vsp.``SetShowBorders`(bool brdr)

`openvsp.vsp.``SetStringAnalysisInput`(std::string const & analysis, std::string const & name, StringVector indata, int index=0)

`openvsp.vsp.``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)

`openvsp.vsp.``SetUpperCST`(std::string const & xsec_id, int deg, DoubleVector coefs)

`openvsp.vsp.``SetVSP3FileName`(std::string const & file_name)

`openvsp.vsp.``SetVSPAEROControlGroupName`(string const & name, int CSGroupIndex)

`openvsp.vsp.``SetVSPAEROPath`(std::string const & path) → bool

`openvsp.vsp.``SetVSPAERORefWingID`(std::string const & geom_id) → string

`openvsp.vsp.``SetVec3dAnalysisInput`(std::string const & analysis, std::string const & name, Vec3dVec indata, int index=0)

`openvsp.vsp.``SetView`(int viewport, int view)

`openvsp.vsp.``SetViewAxis`(bool vaxis)

`openvsp.vsp.``SetWindowLayout`(int r, int c)

`openvsp.vsp.``SetXSecContinuity`(std::string const & xsec_id, int cx)

`openvsp.vsp.``SetXSecCurvatures`(std::string const & xsec_id, int side, double top, double right, double bottom, double left)

`openvsp.vsp.``SetXSecHeight`(std::string const & xsec_id, double h)

`openvsp.vsp.``SetXSecPnts`(std::string const & xsec_id, Vec3dVec pnt_vec)

`openvsp.vsp.``SetXSecSurfGlobalXForm`(std::string const & xsec_surf_id, Matrix4d mat)

`openvsp.vsp.``SetXSecTanAngles`(std::string const & xsec_id, int side, double top, double right, double bottom, double left)

`openvsp.vsp.``SetXSecTanSlews`(std::string const & xsec_id, int side, double top, double right, double bottom, double left)

`openvsp.vsp.``SetXSecTanStrengths`(std::string const & xsec_id, int side, double top, double right, double bottom, double left)

`openvsp.vsp.``SetXSecWidth`(std::string const & xsec_id, double w)

`openvsp.vsp.``SetXSecWidthHeight`(std::string const & xsec_id, double w, double h)

`openvsp.vsp.``ShowAllBackground3Ds`()

`openvsp.vsp.``SnapParm`(std::string const & parm_id, double target_min_dist, bool inc_flag, int set=SET_ALL) → double

`openvsp.vsp.``StartGUI`()

`openvsp.vsp.``StopGUI`()

class `openvsp.vsp.``StringVector`(*args)

  Bases: `object`

  `append`(x)
  `assign`(n, x)
  `back`()
  `begin`()
  `capacity`()
  `clear`()
  `empty`()
  `end`()
  `erase`(*args)
  `front`()
  `get_allocator`()
  `insert`(*args)
  `iterator`()
  `pop`()
  `pop_back`()
  `push_back`(x)
  `rbegin`()
  `rend`()
  `reserve`(n)
  `resize`(*args)
  `size`()
  `swap`(v)
  property `thisown`

    The membership flag

class `openvsp.vsp.``SwigPyIterator`(*args, **kwargs)

  Bases: `object`

  `advance`(n)
  `copy`()
  `decr`(n=1)
  `distance`(x)
  `equal`(x)
  `incr`(n=1)
  `next`()
  `previous`()
  property `thisown`

    The membership flag

  `value`()

`openvsp.vsp.``SwitchVarPreset`(std::string const & group_name, std::string const & setting_name)

`openvsp.vsp.``TAG` = 0

  Color mesh by tag value (component, subsurface, part, etc)

`openvsp.vsp.``TAPER_WSECT_DRIVER` = 3

  Taper driver

`openvsp.vsp.``TEMP_UNIT_C` = 1

  Celsius

`openvsp.vsp.``TEMP_UNIT_F` = 2

  Fahrenheit

`openvsp.vsp.``TEMP_UNIT_K` = 0

  Kelvin

`openvsp.vsp.``TEMP_UNIT_R` = 3

  Rankine

`openvsp.vsp.``TE_NORMAL` = 2

  FEA Rib or Rib Array is set perpendicular to the trailing edge

`openvsp.vsp.``TIPC_WSECT_DRIVER` = 6

  Tip chord driver

`openvsp.vsp.``TRIM_NONE` = 0

  No trimming

`openvsp.vsp.``TRIM_NUM_TYPES` = 3

  Number of trimming types

`openvsp.vsp.``TRIM_THICK` = 2

  Trim XSec by thickness

`openvsp.vsp.``TRIM_X` = 1

  Trim XSec by X

`openvsp.vsp.``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)

`openvsp.vsp.``TranslateSet`(int set_index, vec3d translation_vec)

`openvsp.vsp.``ULINE_SOURCE` = 3

  Constant U Line source

`openvsp.vsp.``U_TRIM` = 0

  Trim by U coordinate

`openvsp.vsp.``Unlock`()

`openvsp.vsp.``Update`(bool update_managers=True)

`openvsp.vsp.``UpdateGUI`()

`openvsp.vsp.``UpdateGeom`(std::string const & geom_id)

`openvsp.vsp.``UpdateParasiteDrag`()

`openvsp.vsp.``VEC3D_DATA` = 3

  Vec3d result data type

`openvsp.vsp.``VEC_PROJ` = 4

  Project along a 3D vector

`openvsp.vsp.``VIEW_1` = 0

  One 2D view

`openvsp.vsp.``VIEW_2HOR` = 1

  Two horizontal 2D views

`openvsp.vsp.``VIEW_2VER` = 2

  Two vertical 2D views

`openvsp.vsp.``VIEW_4` = 3

  Four 2D views

`openvsp.vsp.``VIEW_BOTTOM` = 3

  Bottom 2D view type

`openvsp.vsp.``VIEW_FRONT` = 4

  Front 2D view type

`openvsp.vsp.``VIEW_LEFT` = 0

  Left 2D view type

`openvsp.vsp.``VIEW_NONE` = 6

  No 2D view type

`openvsp.vsp.``VIEW_NUM_TYPES` = 7

  Number of 2D view types

`openvsp.vsp.``VIEW_REAR` = 5

  Rear 2D view type

`openvsp.vsp.``VIEW_RIGHT` = 1

  Right 2D view type

`openvsp.vsp.``VIEW_TOP` = 2

  Top 2D view type

`openvsp.vsp.``VORTEX_LATTICE` = 0

  VSPAERO vortex lattice method

`openvsp.vsp.``VSPCheckSetup`()

`openvsp.vsp.``VSPExit`(int error_code)

`openvsp.vsp.``VSPRenew`()

`openvsp.vsp.``VSP_ADV_LINK_BUILD_FAIL` = 25

  Advanced link build failure

`openvsp.vsp.``VSP_ADV_LINK_SCREEN` = 0

  Advanced linking screen

`openvsp.vsp.``VSP_ADV_LINK_VAR_RENAME_SCREEN` = 1

  Advanced link variable rename screen

`openvsp.vsp.``VSP_AERO_STRUCT_SCREEN` = 2

  Aero / structural analysis screen

`openvsp.vsp.``VSP_AIRFOIL_CURVES_EXPORT_SCREEN` = 3

  Airfoil curves export screen

`openvsp.vsp.``VSP_AIRFOIL_POINTS_EXPORT_SCREEN` = 4

  Airfoil points screen

`openvsp.vsp.``VSP_ALL_SCREENS` = 60

  Flag for all screens

`openvsp.vsp.``VSP_AMBIGUOUS_SUBSURF` = 17

  Ambiguous flow-through sub-surface error

`openvsp.vsp.``VSP_BACKGROUND3D_PREVIEW_SCREEN` = 7

  Background3D preview screen

`openvsp.vsp.``VSP_BACKGROUND3D_SCREEN` = 6

  Background3D control screen

`openvsp.vsp.``VSP_BACKGROUND_SCREEN` = 5

  Background control screen

`openvsp.vsp.``VSP_BEM_OPTIONS_SCREEN` = 8

  Blade element method options screen

`openvsp.vsp.``VSP_CANT_FIND_NAME` = 5

  Can’t find name error

`openvsp.vsp.``VSP_CANT_FIND_PARM` = 4

  Can’t find parm error

`openvsp.vsp.``VSP_CANT_FIND_TYPE` = 3

  Can’t find type error

`openvsp.vsp.``VSP_CANT_SET_NOT_EQ_PARM` = 16

  Can’t set NotEqParm error

`openvsp.vsp.``VSP_CFD_MESH_SCREEN` = 9

  CFD Mesh screen

`openvsp.vsp.``VSP_CLIPPING_SCREEN` = 10

  Clipping screen

`openvsp.vsp.``VSP_COMP_GEOM_SCREEN` = 11

  CompGeom screen

`openvsp.vsp.``VSP_CONFORMAL_PARENT_UNSUPPORTED` = 20

  Unsupported Conformal Geom parent error

`openvsp.vsp.``VSP_COR_SCREEN` = 12

  Center of rotation screen

`openvsp.vsp.``VSP_COULD_NOT_CREATE_BACKGROUND3D` = 30

  Could not create and add Background3D

`openvsp.vsp.``VSP_CURVE_EDIT_SCREEN` = 13

  Curve edit screen

`openvsp.vsp.``VSP_DEGEN_GEOM_SCREEN` = 14

  Degen geom screen

`openvsp.vsp.``VSP_DEPRECATED` = 26

  This capability has been deprecated and is not longer supported

`openvsp.vsp.``VSP_DESIGN_VAR_SCREEN` = 15

  Design variables screen

`openvsp.vsp.``VSP_DUPLICATE_NAME` = 28

  A duplicate name has been provided

`openvsp.vsp.``VSP_DXF_OPTIONS_SCREEN` = 16

  DXF options screen

`openvsp.vsp.``VSP_EXPORT_CUSTOM_SCRIPT` = 23

  Custom geom export screen

`openvsp.vsp.``VSP_EXPORT_SCREEN` = 17

  Export screen

`openvsp.vsp.``VSP_FEA_PART_EDIT_SCREEN` = 18

  FEA Part edit screen

`openvsp.vsp.``VSP_FEA_XSEC_SCREEN` = 19

  FEA XSec screen

`openvsp.vsp.``VSP_FILE_DOES_NOT_EXIST` = 7

  File does not exist error

`openvsp.vsp.``VSP_FILE_READ_FAILURE` = 9

  File read failure error

`openvsp.vsp.``VSP_FILE_WRITE_FAILURE` = 8

  File write failure error

`openvsp.vsp.``VSP_FIT_MODEL_SCREEN` = 20

  Fit model screen

`openvsp.vsp.``VSP_GUI_DEVICE_DEACTIVATED` = 29

  A deactivated GUI device was touched

`openvsp.vsp.``VSP_IGES_OPTIONS_SCREEN` = 21

  IGES options screen

`openvsp.vsp.``VSP_IGES_STRUCTURE_OPTIONS_SCREEN` = 22

  IGES structure options screen

`openvsp.vsp.``VSP_IMPORT_SCREEN` = 24

  Import screen

`openvsp.vsp.``VSP_INDEX_OUT_RANGE` = 13

  Index out of range error

`openvsp.vsp.``VSP_INVALID_CF_EQN` = 23

  Invalid friction coefficient equation error

`openvsp.vsp.``VSP_INVALID_DRIVERS` = 24

  Invalid drivers for driver group

`openvsp.vsp.``VSP_INVALID_GEOM_ID` = 6

  Invalid Geom ID error

`openvsp.vsp.``VSP_INVALID_ID` = 15

  Invalid ID error

`openvsp.vsp.``VSP_INVALID_INPUT_VAL` = 22

  Invalid input value error

`openvsp.vsp.``VSP_INVALID_PTR` = 1

  Invalid pointer error

`openvsp.vsp.``VSP_INVALID_TYPE` = 2

  Invalid type error

`openvsp.vsp.``VSP_INVALID_VARPRESET_GROUPNAME` = 19

  Invalid Variable Preset group name error

`openvsp.vsp.``VSP_INVALID_VARPRESET_SETNAME` = 18

  Invalid Variable Preset set name error

`openvsp.vsp.``VSP_INVALID_XSEC_ID` = 14

  Invalid XSec ID error

`openvsp.vsp.``VSP_LIGHTING_SCREEN` = 25

  Lighting screen

`openvsp.vsp.``VSP_LINK_LOOP_DETECTED` = 27

  A parameter link loop was detected and stopped

`openvsp.vsp.``VSP_MAIN_SCREEN` = 58

  Main screen

`openvsp.vsp.``VSP_MANAGE_GEOM_SCREEN` = 26

  Manage geom screen

`openvsp.vsp.``VSP_MANAGE_TEXTURE_SCREEN` = 27

  Texture mapping screen

`openvsp.vsp.``VSP_MASS_PROP_SCREEN` = 28

  Mass properties screen

`openvsp.vsp.``VSP_MATERIAL_EDIT_SCREEN` = 29

  Material edit screen

`openvsp.vsp.``VSP_MEASURE_SCREEN` = 30

  Measure screen

`openvsp.vsp.``VSP_NERF_MANAGE_GEOM_SCREEN` = 31

  NERF’ed (limited to make safe) Manage geom screen

`openvsp.vsp.``VSP_NUM_ERROR_CODE` = 31

  Total number of VSP error codes

`openvsp.vsp.``VSP_NUM_SCREENS` = 59

  Number of screens

`openvsp.vsp.``VSP_OK` = 0

  No error

`openvsp.vsp.``VSP_PARASITE_DRAG_SCREEN` = 33

  Parasite drg screen

`openvsp.vsp.``VSP_PARM_DEBUG_SCREEN` = 34

  Parameter debug screen

`openvsp.vsp.``VSP_PARM_LINK_SCREEN` = 35

  Parameter linking screen

`openvsp.vsp.``VSP_PARM_SCREEN` = 36

  Parameter screen

`openvsp.vsp.``VSP_PICK_SET_SCREEN` = 37

  Pick set screen

`openvsp.vsp.``VSP_PREFERENCES_SCREEN` = 38

  Preferences screen

`openvsp.vsp.``VSP_PROJECTION_SCREEN` = 39

  Projected area screen

`openvsp.vsp.``VSP_PSLICE_SCREEN` = 40

  Planar slicing screen

`openvsp.vsp.``VSP_SCREENSHOT_SCREEN` = 41

  Screenshot screen

`openvsp.vsp.``VSP_SELECT_FILE_SCREEN` = 42

  Select file screen

`openvsp.vsp.``VSP_SET_EDITOR_SCREEN` = 43

  Set editor screen

`openvsp.vsp.``VSP_SNAP_TO_SCREEN` = 32

  Snap to screen

`openvsp.vsp.``VSP_STEP_OPTIONS_SCREEN` = 44

  STEP options screen

`openvsp.vsp.``VSP_STEP_STRUCTURE_OPTIONS_SCREEN` = 45

  STEP structure options screen

`openvsp.vsp.``VSP_STL_OPTIONS_SCREEN` = 46

  STL options screen

`openvsp.vsp.``VSP_STRUCT_ASSEMBLY_SCREEN` = 48

  Structure assembly screen

`openvsp.vsp.``VSP_STRUCT_SCREEN` = 47

  Structure definition screen

`openvsp.vsp.``VSP_SURFACE_INTERSECTION_SCREEN` = 49

  Surface intersection screen

`openvsp.vsp.``VSP_SVG_OPTIONS_SCREEN` = 50

  SVG options screen

`openvsp.vsp.``VSP_UNEXPECTED_RESET_REMAP_ID` = 21

  Unexpected reset remap ID error

`openvsp.vsp.``VSP_USER_PARM_SCREEN` = 51

  User parameter screen

`openvsp.vsp.``VSP_VAR_PRESET_SCREEN` = 52

  Variable presets screen

`openvsp.vsp.``VSP_VIEW_SCREEN` = 53

  Adjust viewpoint screen

`openvsp.vsp.``VSP_VSPAERO_PLOT_SCREEN` = 54

  VSPAERO results manager screen

`openvsp.vsp.``VSP_VSPAERO_SCREEN` = 55

  VSPAERO screen

`openvsp.vsp.``VSP_WAVEDRAG_SCREEN` = 57

  Wave drag screen

`openvsp.vsp.``VSP_WRONG_FILE_TYPE` = 12

  Wrong file type error

`openvsp.vsp.``VSP_WRONG_GEOM_TYPE` = 10

  Wrong Geom type error

`openvsp.vsp.``VSP_WRONG_XSEC_TYPE` = 11

  Wrong XSec type error

`openvsp.vsp.``VSP_XSEC_SCREEN` = 56

  XSec screen

`openvsp.vsp.``V_UNIT_FT_S` = 0

  Feet per second

`openvsp.vsp.``V_UNIT_KEAS` = 4

  Knots equivalent airspeed

`openvsp.vsp.``V_UNIT_KM_HR` = 3

  Kilometer per hour

`openvsp.vsp.``V_UNIT_KTAS` = 5

  Knots true airspeed

`openvsp.vsp.``V_UNIT_MACH` = 6

  Mach

`openvsp.vsp.``V_UNIT_MPH` = 2

  Mile per hour

`openvsp.vsp.``V_UNIT_M_S` = 1

  Meter per second

`openvsp.vsp.``ValidParm`(std::string const & id) → bool

`openvsp.vsp.``ValidateAdvLinkParms`(int index) → bool

class `openvsp.vsp.``Vec3dVec`(*args)

  Bases: `object`

  `append`(x)
  `assign`(n, x)
  `back`()
  `begin`()
  `capacity`()
  `clear`()
  `empty`()
  `end`()
  `erase`(*args)
  `front`()
  `get_allocator`()
  `insert`(*args)
  `iterator`()
  `pop`()
  `pop_back`()
  `push_back`(x)
  `rbegin`()
  `rend`()
  `reserve`(n)
  `resize`(*args)
  `size`()
  `swap`(v)
  property `thisown`

    The membership flag

`openvsp.vsp.``VecInsideSurf`(std::string const & geom_id, int const & surf_indx, Vec3dVec pts) → BoolVector

`openvsp.vsp.``WING_SURF` = 1

  Wing VSP surface

`openvsp.vsp.``WIRE_FRAME_GEOM_SCREEN` = 14

  Wireframe geom screen

`openvsp.vsp.``WLINE_SOURCE` = 4

  Constant W Line source

`openvsp.vsp.``W_BOTTOM` = 1

  Chevron start/ends at bottom of cross section

`openvsp.vsp.``W_FREE` = 5

  Chevron start/ends at user specified point on cross section

`openvsp.vsp.``W_LEFT` = 2

  Chevron start/ends at left of cross section

`openvsp.vsp.``W_RIGHT_0` = 0

  Chevron start/ends at right (W = 0) of cross section

`openvsp.vsp.``W_RIGHT_1` = 4

  Chevron start/ends at right (W = 1) of cross section

`openvsp.vsp.``W_TOP` = 3

  Chevron start/ends at top of cross section

`openvsp.vsp.``WriteAtmosphereCSVFile`(std::string const & file_name, int const & atmos_type)

`openvsp.vsp.``WriteBezierAirfoil`(std::string const & file_name, std::string const & geom_id, double const & foilsurf_u)

`openvsp.vsp.``WriteBodyFFCSVFile`(std::string const & file_name)

`openvsp.vsp.``WriteCfEqnCSVFile`(std::string const & file_name)

`openvsp.vsp.``WriteDESFile`(std::string const & file_name)

`openvsp.vsp.``WritePartialCfMethodCSVFile`(std::string const & file_name)

`openvsp.vsp.``WriteResultsCSVFile`(std::string const & id, std::string const & file_name)

`openvsp.vsp.``WriteSeligAirfoil`(std::string const & file_name, std::string const & geom_id, double const & foilsurf_u)

`openvsp.vsp.``WriteTestResults`()

`openvsp.vsp.``WriteVSPFile`(std::string const & file_name, int set=SET_ALL)

`openvsp.vsp.``WriteWingFFCSVFile`(std::string const & file_name)

`openvsp.vsp.``WriteXDDMFile`(std::string const & file_name)

`openvsp.vsp.``XDDM_CONST` = 1

  Constant XDDM type

`openvsp.vsp.``XDDM_VAR` = 0

  Variable XDDM type

`openvsp.vsp.``XSEC_BOTH_SIDES` = 0

  Both sides

`openvsp.vsp.``XSEC_CUSTOM` = 3

  Custom XSec Geom

`openvsp.vsp.``XSEC_FUSE` = 0

  Fuselage XSec Geom

`openvsp.vsp.``XSEC_LEFT_SIDE` = 1

  Left side

`openvsp.vsp.``XSEC_NUM_TYPES` = 5

  Number of XSec types

`openvsp.vsp.``XSEC_PROP` = 4

  Propeller XSec Geom

`openvsp.vsp.``XSEC_RIGHT_SIDE` = 2

  Right side

`openvsp.vsp.``XSEC_STACK` = 1

  Stack XSec Geom

`openvsp.vsp.``XSEC_WING` = 2

  Wing XSec Geom

`openvsp.vsp.``XS_BICONVEX` = 9

  Biconvex XSec

`openvsp.vsp.``XS_CIRCLE` = 1

  Circle XSec

`openvsp.vsp.``XS_CST_AIRFOIL` = 13

  CST airfoil XSec

`openvsp.vsp.``XS_EDIT_CURVE` = 11

  Generic Edit Curve XSec

`openvsp.vsp.``XS_ELLIPSE` = 2

  Ellipse XSec

`openvsp.vsp.``XS_FILE_AIRFOIL` = 12

  Airfoil file XSec

`openvsp.vsp.``XS_FILE_FUSE` = 6

  Fuselage file XSec

`openvsp.vsp.``XS_FIVE_DIGIT` = 16

  Five digit XSec

`openvsp.vsp.``XS_FIVE_DIGIT_MOD` = 17

  Five digit modified XSec

`openvsp.vsp.``XS_FOUR_DIGIT_MOD` = 15

  Four digit modified XSec

`openvsp.vsp.``XS_FOUR_SERIES` = 7

  Four series XSec

`openvsp.vsp.``XS_GENERAL_FUSE` = 5

  General fuselage XSec

`openvsp.vsp.``XS_NUM_TYPES` = 19

  Number of XSec types

`openvsp.vsp.``XS_ONE_SIX_SERIES` = 18

  One six series XSec

`openvsp.vsp.``XS_POINT` = 0

  Point XSec

`openvsp.vsp.``XS_ROUNDED_RECTANGLE` = 4

  Rounded rectangle XSec

`openvsp.vsp.``XS_SHIFT_LE` = 0

  Shift leading edge

`openvsp.vsp.``XS_SIX_SERIES` = 8

  Six series XSec

`openvsp.vsp.``XS_SUPER_ELLIPSE` = 3

  Super ellipse XSec

`openvsp.vsp.``XS_VKT_AIRFOIL` = 14

  VKT airfoil XSec

`openvsp.vsp.``XS_WEDGE` = 10

  Wedge XSec

`openvsp.vsp.``XY_ABS` = 3

  Slice is parallel to absolute XY plane

`openvsp.vsp.``XY_BODY` = 0

  Slice is parallel to parent Geom body XY plane

`openvsp.vsp.``XZ_ABS` = 5

  Slice is parallel to absolute XZ plane

`openvsp.vsp.``XZ_BODY` = 2

  Slice is parallel to parent Geom body XZ plane

`openvsp.vsp.``X_DIR` = 0

  X direction

`openvsp.vsp.``X_PROJ` = 0

  Project in X axis direction

`openvsp.vsp.``YZ_ABS` = 4

  Slice is parallel to absolute YZ plane

`openvsp.vsp.``YZ_BODY` = 1

  Slice is parallel to parent Geom body YZ plane

`openvsp.vsp.``Y_PROJ` = 1

  Project in Y axis direction

`openvsp.vsp.``Z_PROJ` = 2

  Project in Z axis direction

`openvsp.vsp.``angle`(vec3d a, vec3d b) → double

`openvsp.vsp.``area`(vec3d A, vec3d B, vec3d C) → double

`openvsp.vsp.``center_of_circle`(vec3d p1, vec3d p2, vec3d p3, vec3d center)

`openvsp.vsp.``cos_angle`(vec3d a, vec3d b) → double

`openvsp.vsp.``cross`(vec3d a, vec3d b) → vec3d

`openvsp.vsp.``dist`(vec3d a, vec3d b) → double

`openvsp.vsp.``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

`openvsp.vsp.``dist_pnt_2_line`(vec3d line_pt1, vec3d line_pt2, vec3d pnt) → double

`openvsp.vsp.``dist_pnt_2_plane`(vec3d org, vec3d norm, vec3d pnt) → double

`openvsp.vsp.``dist_squared`(vec3d a, vec3d b) → double

`openvsp.vsp.``dot`(vec3d a, vec3d b) → double

`openvsp.vsp.``line_line_intersect`(vec3d p1, vec3d p2, vec3d p3, vec3d p4, double * s, double * t) → bool

`openvsp.vsp.``nearSegSeg`(vec3d L0, vec3d L1, vec3d S0, vec3d S1, double * Lt, vec3d Ln, double * St, vec3d Sn) → double

`openvsp.vsp.``plane_half_space`(vec3d planeOrig, vec3d planeNorm, vec3d pnt) → int

`openvsp.vsp.``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

`openvsp.vsp.``pnt_tri_min_dist`(vec3d v0, vec3d v1, vec3d v2, vec3d pnt) → double

`openvsp.vsp.``pointLineDistSquared`(vec3d p, vec3d lp0, vec3d lp1, double * t) → double

`openvsp.vsp.``pointSegDistSquared`(vec3d p, vec3d sp0, vec3d sp1, double * t) → double

`openvsp.vsp.``point_on_line`(vec3d lp0, vec3d lp1, double const & t) → vec3d

`openvsp.vsp.``poly_area`(Vec3dVec pnt_vec) → double

`openvsp.vsp.``proj_pnt_on_line`(vec3d line_pt1, vec3d line_pt2, vec3d pnt) → vec3d

`openvsp.vsp.``proj_pnt_on_line_seg`(vec3d line_pt1, vec3d line_pt2, vec3d pnt) → vec3d

`openvsp.vsp.``proj_pnt_on_ray`(vec3d line_pt1, vec3d line_pt2, vec3d pnt) → vec3d

`openvsp.vsp.``proj_pnt_to_plane`(vec3d org, vec3d plane_ln1, vec3d plane_ln2, vec3d pnt) → vec3d

`openvsp.vsp.``proj_vec_to_plane`(vec3d vec, vec3d norm) → vec3d

`openvsp.vsp.``radius_of_circle`(vec3d p1, vec3d p2, vec3d p3) → double

`openvsp.vsp.``ray_ray_intersect`(vec3d A, vec3d B, vec3d C, vec3d D, vec3d int_pnt1, vec3d int_pnt2) → int

`openvsp.vsp.``signed_angle`(vec3d a, vec3d b, vec3d ref) → double

`openvsp.vsp.``slerp`(vec3d a, vec3d b, double const & t) → vec3d

`openvsp.vsp.``tetra_volume`(vec3d A, vec3d B, vec3d C) → double

`openvsp.vsp.``to_string`(vec3d v) → std::string

`openvsp.vsp.``tri_ray_intersect`(vec3d A, vec3d B, vec3d C, vec3d D, vec3d E, double & u, double & w, double & t) → int

`openvsp.vsp.``tri_seg_intersect`(vec3d A, vec3d B, vec3d C, vec3d D, vec3d E, double & u, double & w, double & t) → int

`openvsp.vsp.``tri_tri_min_dist`(vec3d v0, vec3d v1, vec3d v2, vec3d v3, vec3d v4, vec3d v5) → double

class `openvsp.vsp.``vec3d`(*args)

  Bases: `object`

  Proxy of C++ vec3d class.

  `as_vec2d_xy`(vec3d self) → vec2d
  `data`(vec3d self) → double *
  `get_pnt`(vec3d self, double [3] pnt)

    get_pnt(vec3d self, float [3] pnt) get_pnt(vec3d self, threed_point_type & pnt)

  `isfinite`(vec3d self) → bool
  `isinf`(vec3d self) → bool
  `isnan`(vec3d self) → bool
  `mag`(vec3d self) → double
  `major_comp`(vec3d self) → int
  `minor_comp`(vec3d self) → int
  `normalize`(vec3d self)
  `offset_i`(vec3d self, double offset, int idir)
  `offset_x`(vec3d self, double offset)
  `offset_y`(vec3d self, double offset)
  `offset_z`(vec3d self, double offset)
  `reflect_xy`(vec3d self) → vec3d
  `reflect_xz`(vec3d self) → vec3d
  `reflect_yz`(vec3d self) → vec3d
  `rotate_x`(vec3d self, double cos_alpha, double sin_alpha)
  `rotate_y`(vec3d self, double cos_alpha, double sin_alpha)
  `rotate_z`(vec3d self, double cos_alpha, double sin_alpha)
  `rotate_z_zero_x`(vec3d self, double cos_alpha, double sin_alpha)
  `rotate_z_zero_y`(vec3d self, double cos_alpha, double sin_alpha)
  `scale_x`(vec3d self, double scale)
  `scale_y`(vec3d self, double scale)
  `scale_z`(vec3d self, double scale)
  `set_arr`(vec3d self, double const [] a) → vec3d

    set_arr(vec3d self, float const [] a) -> vec3d

  `set_refx`(vec3d self, vec3d a) → vec3d
  `set_refy`(vec3d self, vec3d a) → vec3d
  `set_refz`(vec3d self, vec3d a) → vec3d
  `set_vec`(vec3d self, DoubleVector a) → vec3d
  `set_x`(vec3d self, double xx) → vec3d
  `set_xyz`(vec3d self, double xx, double yy, double zz) → vec3d
  `set_y`(vec3d self, double yy) → vec3d
  `set_z`(vec3d self, double zz) → vec3d
  `swap_xy`(vec3d self) → vec3d
  `swap_xz`(vec3d self) → vec3d
  `swap_yz`(vec3d self) → vec3d
  property `thisown`

    The membership flag

  property `v`

    v : a(3).double

  `x`(vec3d self) → double
  `y`(vec3d self) → double
  `z`(vec3d self) → double