# openvsp package

## degen geom parse

openvsp.degen_geom_parse.parse_degen_geom(degen_geom_res_id, vsp_instance=None)

## parasite drag

class openvsp.parasite_drag.ParasiteDragResults(results)

  Bases: `object`

  Class that contains all of the results from a parasite drag sweep in OpenVSP

  build_interpolator()

    Returns interpolator to interpolate results as a function of speed and altitude

  plot(ax=None)

    Creates plot of CD0 vs speed and altitude

openvsp.parasite_drag.parasitedrag_sweep(speeds, alts_ft, sref=None, length_unit=None, speed_unit=6, set=None, vsp_instance=None)

  Runs a parasite drag sweep over a range of speeds and altitudes. For subsonic data only.

  Parameters:

    - speeds – list of speeds to sweep over

    - alts_ft – list of altitudes to sweep over

    - speed_unit – units of speed array

    - set – vsp geometry set to use for build up

    - length_unit – length unit of the vsp model

    - sref – reference area

    - vsp_instance – optional instance of vsp if using the multifacade

  Returns:

    named tuple with results

## surface patches

class openvsp.surface_patches.Surface(comp_id, surf_index, patches)

  Bases: `object`

class openvsp.surface_patches.SurfaceComponent(name, id, surfaces)

  Bases: `object`

class openvsp.surface_patches.SurfacePatch(comp_id, surf_index, patch_index, x, y, z, nx, ny, nz)

  Bases: `object`

openvsp.surface_patches.export_surface_patches(export_set: int, remove_degenerate=True, vsp_instance=None)

  Function that export surfaces patches of current set :param export_set: vsp set to export :param remove_degenerate: if true, degenerate surface patches are removed :param vsp_instance: optional instance of vsp if using the multifacade :return: list components with surface patches

openvsp.surface_patches.plot_surface_components(components: List[SurfaceComponent], plot_normals=True, quiver_len=0.2, vsp_instance=None)

  Plots a list of surface components :param components: list of surface components to plot :param plot_normals: set to true to plot normal vectors, set to false to turn off normal vector plotting :param vsp_instance: optional instance of vsp if using the multifacade :return: handle to plotted figure

## utilities

class openvsp.utilities.PropInfo(geom_id, thrust_vector, rotation_direction, hub_center, transmat, diameter)

  Bases: `object`

  property area

openvsp.utilities.convert_double_tuple_to_list_matrix(tuple_matrix)

  Converts a double matrix of tuples into a maxtrix of lists :param tuple_matrix: matrix of tuples :return: matrix of lists

openvsp.utilities.convert_vec3d_array_to_list_matrix(vec3d_array)

  Converts an array of vec3d objects into a list of x,y,z points :param vec3d_array: array of vec3d objects :return: list of x,y,z pairs

openvsp.utilities.export_airfoils(set=0, vsp_instance=None, **kwargs)

openvsp.utilities.genX3d(file=None, set=0, dims=[1000, 400], vsp_instance=None, **kwargs)

openvsp.utilities.get_propeller_thrust_vectors(prop_set, alternate_rotation_direction=False, vsp_instance=None)

  Returns propeller thrust vector directions and rotation direction for all propellers in the input set :param prop_set: set containing all propellers (no other geometries should be included) :param vsp_instance: optional instance of vsp if using the multifacade :return: Named Tuple with (geom_id, thrust_vector, rotation_direction, hub_center)

openvsp.utilities.get_single_propeller_info(prop_dg, vsp_instance=None)

  Gets propeller info for a single propeller degen geom object :param prop_dg: propeller degen geom object :param vsp_instance: optional instance of vsp if using the multifacade :return: propeller info named tuple

openvsp.utilities.get_wing_reference_quantities(wing_name=None, wing_id=None, vsp_instance=None)

  Gets wing reference area, reference span, and reference chord (sref, bref, cref) from the TotalArea, TotalSpan, and TotalChord properties of Wing component

  Parameters:

    - wing_name – Name of the wing (will find the first wing with this name)

    - wing_id – ID of the wing object, if None wing name will be used to find the wing id. Wing ID takes precedence over wing_name

    - vsp_instance – optional instance of vsp if using the multifacade

  Returns:

    sref, bref, and cref

openvsp.utilities.parse_results_object(res_id, vsp_instance=None)

  Function to parse a generic results object from openvsp results manager :param res_id: id of the results object to parse :param vsp_instance: optional instance of vsp if using the multifacade :return: named tuple of results values

openvsp.utilities.plot_propeller_info(prop_infos, vector_scale=10.0, markersize=2.0, mutation_scale=20.0)

  Plots an array of propeller info tuples to visually inspect thrust and rotation directions :param prop_infos: array of prop info tuples :param vector_scale: length of each thrust vector :param markersize: size of marker for hub location :param mutation_scale: mutation scale applied to arrow objects :return: figure handle

openvsp.utilities.run_degen_geom(set_index=None, set_name=None, vsp_instance=None)

  Runs degen geom on input set :param set_index: set index, will take precedence if both set index and set name are specified :param set_name: name of set, will be used if set index is not specified :param vsp_instance: optional instance of vsp if using the multifacade :return: degen geom manager object

openvsp.utilities.set_3d_axis_equal(ax)

  Sets axis aspect ratio to equal :param ax: 3d axis object :return:

## vsp

openvsp.vsp.ABS = 0

  Absolute position

openvsp.vsp.AERO_CENTER = 19

  Calculate aero center of single lifting surface

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 = 32

  Flag for all GDEV types

openvsp.vsp.ALL_GEOM_SCREENS = 22

  All geom screens

openvsp.vsp.ALTERNATE_FRAGMENT = 2

  Alternate rotor fragment model

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.AREA_XSEC_DRIVER = 1

  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.ATTROBJ_ADVLINK = 6

  Adv Link

openvsp.vsp.ATTROBJ_ATTR = 7

  Attribute

openvsp.vsp.ATTROBJ_COLLECTION = 8

  Attribute Collection

openvsp.vsp.ATTROBJ_FREE = 15

  Unattached attribute

openvsp.vsp.ATTROBJ_GEOM = 1

  Geom

openvsp.vsp.ATTROBJ_LINK = 5

  Link

openvsp.vsp.ATTROBJ_MEASURE = 4

  Measure

openvsp.vsp.ATTROBJ_MODE = 11

  Mode

openvsp.vsp.ATTROBJ_PARM = 0

  Parm

openvsp.vsp.ATTROBJ_SEC = 10

  Wing Section

openvsp.vsp.ATTROBJ_SET = 12

  Geom Set

openvsp.vsp.ATTROBJ_SUBSURF = 3

  SubSurf

openvsp.vsp.ATTROBJ_VARGROUP = 13

  Var Preset Group

openvsp.vsp.ATTROBJ_VARSETTING = 14

  Var Preset Setting

openvsp.vsp.ATTROBJ_VEH = 2

  Vehicle

openvsp.vsp.ATTROBJ_XSEC = 9

  Cross Section

openvsp.vsp.ATTR_COLLECTION_DATA = 8

  Attribute collection data type

openvsp.vsp.ATTR_GROUP_NONE = -1

  No event (user attributes)

openvsp.vsp.ATTR_GROUP_WATERMARK = 0

  Watermark group

openvsp.vsp.AUXILIARY_GEOM_SCREEN = 18

  Auxiliary geom screen

openvsp.vsp.AUX_GEOM_ONE_PT_GROUND = 4

  One contact point ground plane

openvsp.vsp.AUX_GEOM_ROTOR_BURST = 1

  Rotor burst zone

openvsp.vsp.AUX_GEOM_ROTOR_FRAGMENT = 8

  AC 20-128 A rotor fragment

openvsp.vsp.AUX_GEOM_ROTOR_TIP_PATH = 0

  Rotor tip path

openvsp.vsp.AUX_GEOM_SINGLE_GEAR = 7

  Single (potentially) off nominal gear

openvsp.vsp.AUX_GEOM_SUPER_CONE = 6

  Super cone (XSecCurve based profile)

openvsp.vsp.AUX_GEOM_THREE_PT_CCE = 5

  Three contact point composite clearance envelope

openvsp.vsp.AUX_GEOM_THREE_PT_GROUND = 2

  Three contact point ground plane

openvsp.vsp.AUX_GEOM_THROWN_BLADE = 9

  AC 25.905-1 thrown blade

openvsp.vsp.AUX_GEOM_TIRE_SPRAY = 10

  ESDU 83042a Tire spray pattern

openvsp.vsp.AUX_GEOM_TWO_PT_GROUND = 3

  Two contact point ground plane

openvsp.vsp.AUX_GEOM_WHEEL_TIRE_FAILURE = 11

  AMC 25.734 Wheel and tire failure models

openvsp.vsp.AVEC_WSECT_DRIVER = 4

  Average chord driver

openvsp.vsp.AddAdvLink(name)

  Add an advanced link

      pod = AddGeom( "POD", "" )
      length = FindParm( pod, "Length", "Design" )
      x_pos = GetParm( pod, "X_Rel_Location", "XForm" )

      AddAdvLink( "ExampleLink" )
      indx = GetLinkIndex( "ExampleLink" )
      AddAdvLinkInput( indx, length, "len" )
      AddAdvLinkOutput( indx, x_pos, "x" )

      SetAdvLinkCode( indx, "x = 10.0 - len;" )

      BuildAdvLinkScript( indx )

  Parameters:

    [in] – name string Name for advanced link

openvsp.vsp.AddAdvLinkInput(index, parm_id, var_name)

  Add an input variable to an advanced link

      pod = AddGeom( "POD", "" )
      length = FindParm( pod, "Length", "Design" )
      x_pos = GetParm( pod, "X_Rel_Location", "XForm" )

      AddAdvLink( "ExampleLink" )
      indx = GetLinkIndex( "ExampleLink" )
      AddAdvLinkInput( indx, length, "len" )
      AddAdvLinkOutput( indx, x_pos, "x" )

      SetAdvLinkCode( indx, "x = 10.0 - len;" )

      BuildAdvLinkScript( indx )

  Parameters:

    - [in] – index int Advanced link index

    - [in] – parm_id string Parameter ID for advanced link input variable

    - [in] – var_name string Name for advanced link input variable

openvsp.vsp.AddAdvLinkOutput(index, parm_id, var_name)

  Add an output variable to an advanced link

      pod = AddGeom( "POD", "" )
      length = FindParm( pod, "Length", "Design" )
      x_pos = GetParm( pod, "X_Rel_Location", "XForm" )

      AddAdvLink( "ExampleLink" )
      indx = GetLinkIndex( "ExampleLink" )
      AddAdvLinkInput( indx, length, "len" )
      AddAdvLinkOutput( indx, x_pos, "x" )

      SetAdvLinkCode( indx, "x = 10.0 - len;" )

      BuildAdvLinkScript( indx )

  Parameters:

    - [in] – index int Advanced link index

    - [in] – parm_id string Parameter ID for advanced link output variable

    - [in] – var_name string Name for advanced link output variable

openvsp.vsp.AddAllToVSPAEROControlSurfaceGroup(CSGroupIndex)

  Add all available control surfaces to the control surface group at the specified index

      wid = AddGeom( "WING", "" )                             # Add Wing

      aileron_id = AddSubSurf( wid, SS_CONTROL )                      # Add Control Surface Sub-Surface

      group_index = CreateVSPAEROControlSurfaceGroup() # Empty control surface group

      AddAllToVSPAEROControlSurfaceGroup( group_index )

  Parameters:

    [in] – CSGroupIndex int Index of the control surface group

openvsp.vsp.AddAttributeBool(collID, attributeName, value)

  Add a boolean attribute by name to an attribute collection

      ##==== Attribute: AddAttributeBool  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      InitVal = True
      AttrID = AddAttributeBool( CollID, "TestBoolAttr", InitVal )

      GetVal = GetAttributeBoolVal( AttrID )
      if GetVal[0] == InitVal:
          print( "Added Bool Attribute" )
      else:
          print( "AddAttributeBool error!" )

  Parameters:

    - [in] – collID string ID of attribute collection

    - [in] – attributeName string name of new attribute

    - [in] – value bool boolean value of new attribute

openvsp.vsp.AddAttributeDouble(collID, attributeName, value)

  Add a double attribute by name to an attribute collection

      ##==== Attribute: AddAttributeDouble  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      AttrName = 'Example_Double_Attr'
      DoubleValue = 3.14159
      AttrID = AddAttributeDouble( CollID, AttrName, DoubleValue )

      GetVal = GetAttributeDoubleVal( AttrID )
      if GetVal[0] == DoubleValue:
          print( "Added Double Attribute" )
      else:
          print( "AddAttributeDouble error!" )

  Parameters:

    - [in] – collID string ID of attribute collection

    - [in] – attributeName string name of new attribute

    - [in] – value double value of new attribute

openvsp.vsp.AddAttributeDoubleMatrix(collID, attributeName, value)

  Add an Double Matrix attribute by name to an attribute collection use nested vectors/arrays of ints for matrix argument

      ##==== Attribute: AddAttributeDoubleMatrix  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      AttrName = 'Example_DoubleMat_Attr'
      DoubleMatrix = [[0.,1.5],[8.4,1.1566]]
      AttrID = AddAttributeDoubleMatrix( CollID, AttrName, DoubleMatrix )

      DoubleMatrixVal = GetAttributeDoubleMatrixVal( AttrID )
      DoubleMatrixVal = [list(row) for row in DoubleMatrixVal]

      if DoubleMatrixVal == DoubleMatrix:
          print( "Added DoubleMatrix Attribute" )
      else:
          print( "AddAttributeDoubleMatrix error!" )

  Parameters:

    - [in] – collID string ID of attribute collection

    - [in] – attributeName string name of new attribute

    - [in] – value vector <vector <double>> Double matrix value of new attribute

openvsp.vsp.AddAttributeGroup(collID, attributeName)

  Add an empty Attribute Group-type attribute by name to an attribute collection

      ##==== Attribute: AddAttributeGroup  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      AttrName = 'Example_Attr_Group'
      AttrID = AddAttributeGroup( CollID, AttrName )
      if GetAttributeType( AttrID ) == ATTR_COLLECTION_DATA:
          print( "Added Attribute Group" )
      else:
          print( "AddAttributeGroup error!" )

  Parameters:

    - [in] – collID string ID of attribute collection

    - [in] – attributeName string name of new attribute group

openvsp.vsp.AddAttributeInt(collID, attributeName, value)

  Add a integer attribute by name to an attribute collection

      ##==== Attribute: AddAttributeInt  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      InitVal = 55
      AttrID = AddAttributeInt( CollID, "TestIntAttr", InitVal )

      GetVal = GetAttributeIntVal( AttrID )
      if GetVal[0] == InitVal:
          print( "Added Int Attribute" )
      else:
          print( "AddAttributeInt error!" )

  Parameters:

    - [in] – collID string ID of attribute collection

    - [in] – attributeName string name of new attribute

    - [in] – value int integer value of new attribute

openvsp.vsp.AddAttributeIntMatrix(collID, attributeName, value)

  Add an Int Matrix attribute by name to an attribute collection use nested vectors/arrays of ints for matrix argument

      ##==== Attribute: AddAttributeIntMatrix  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      AttrName = 'Example_IntMatrix_Attr'
      IntMatrix = [[1,5],[-8,0]]
      AttrID = AddAttributeIntMatrix( CollID, AttrName, IntMatrix )

      IntMatrixVal = GetAttributeIntMatrixVal( AttrID )
      IntMatrixVal = [list(row) for row in IntMatrixVal]

      if IntMatrixVal == IntMatrix:
          print( "Added IntMatrix Attribute" )
      else:
          print( "AddAttributeIntMatrix error!" )

  Parameters:

    - [in] – collID string ID of attribute collection

    - [in] – attributeName string name of new attribute

    - [in] – value int matrix value of new attribute

openvsp.vsp.AddAttributeParm(collID, attributeName, parmID)

  Add a parm attribute by name to an attribute collection

      ##==== Attribute: AddAttributeParm  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      pid = AddGeom( "POD", "" )
      print( "---> Test Add Parm Attr" )
      parm_array = GetGeomParmIDs( pid )
      AttrName = 'Example_Parm_Attr'
      ParmID = parm_array[0]
      AttrID = AddAttributeParm( CollID, AttrName, ParmID )

      GetVal = GetAttributeParmID( AttrID )
      if GetVal[0] == ParmID:
          print( "Added Parm Attribute" )
      else:
          print( "AddAttributeParm error!" )

  Parameters:

    - [in] – collID string ID of attribute collection

    - [in] – attributeName string name of new attribute

    - [in] – parmID string Parm ID to add to attribute

openvsp.vsp.AddAttributeString(collID, attributeName, value)

  Add a string attribute by name to an attribute collection

      ##==== Attribute: AddAttributeString  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      AttrName = 'Example_String_Attr'
      StringValue = 'Example_String_Attr_DataVal'
      AttrID = AddAttributeString( CollID, AttrName, StringValue )

      GetVal = GetAttributeStringVal( AttrID )
      if GetVal[0] == StringValue:
          print( "Added String Attribute" )
      else:
          print( "AddAttributeString error!" )

  Parameters:

    - [in] – collID string ID of attribute collection

    - [in] – attributeName string name of new attribute

    - [in] – value string value of new attribute

openvsp.vsp.AddAttributeVec3d(collID, attributeName, value)

  Add a Vec3d attribute by name to an attribute collection use vec3d() to create a vec3d object to pass into the args!

      ##==== Attribute: AddAttributeVec3d  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      AttrName = 'Example_Vec3D_Attr'
      Vec3dVal = vec3d( 0.5, 0.75, -0.4 )
      AttrID = AddAttributeVec3d( CollID, AttrName, [Vec3dVal] )

      GetVal = GetAttributeVec3dVal( AttrID )
      if ( GetVal[0].x() == Vec3dVal.x() ) and ( GetVal[0].y() == Vec3dVal.y() ) and ( GetVal[0].z() == Vec3dVal.z() ):
          print( "Added Vec3d Attribute" )
      else:
          print( "AddAttributeVec3d error!" )

  Parameters:

    - [in] – collID string ID of attribute collection

    - [in] – attributeName string name of new attribute

    - [in] – value vector <vec3d> Vec3d value of new attribute

openvsp.vsp.AddBackground3D()

  Add a Background3D to model

      nbg = GetNumBackground3Ds()

      # Add Background3D
      bg_id = AddBackground3D()

      if GetNumBackground3Ds() != nbg + 1 :
          print( "ERROR: AddBackground3D" )

      DelBackground3D( bg_id )

  Return type:

    string

  Returns:

    string ID for added Background3D

openvsp.vsp.AddCFDSource(type, geom_id, surf_index, l1, r1, u1, w1, l2=0, r2=0, u2=0, w2=0)

  Add a CFD Mesh default source for the indicated Geom. Note, certain input params may not be used depending on the source type

      #==== Add Pod Geom ====//
      pid = AddGeom( "POD", "" )

      AddCFDSource( POINT_SOURCE, pid, 0, 0.25, 2.0, 0.5, 0.5 )      # Add A Point Source

  See also: CFD_MESH_SOURCE_TYPE :param [in]: type int CFD Mesh source type( i.e.BOX_SOURCE ) :param [in]: geom_id string Geom ID :param [in]: surf_index int Main surface index :param [in]: l1 double Source first edge length :param [in]: r1 double Source first radius :param [in]: u1 double Source first U location :param [in]: w1 double Source first W location :param [in]: l2 double Source second edge length :param [in]: r2 double Source second radius :param [in]: u2 double Source second U location :param [in]: w2 double Source second W location

openvsp.vsp.AddDefaultSources()

  Add default CFD Mesh sources for all Geoms

      #==== Add Pod Geom ====//
      pid = AddGeom( "POD", "" )

      AddDefaultSources() # 3 Sources: Def_Fwd_PS, Def_Aft_PS, Def_Fwd_Aft_LS

openvsp.vsp.AddDesignVar(parm_id, type)

  Add a design variable See also: XDDM_QUANTITY_TYPE :param [in]: parm_id string Parm ID :param [in]: type int XDDM type enum (XDDM_VAR or XDDM_CONST)

openvsp.vsp.AddExcrescence(excresName, excresType, excresVal)

  Add an Excresence to the Parasite Drag Tool

      AddExcrescence( "Miscellaneous", EXCRESCENCE_COUNT, 8.5 )

      AddExcrescence( "Cowl Boattail", EXCRESCENCE_CD, 0.0003 )

  See also: EXCRES_TYPE :param [in]: excresName string Name of the Excressence :param [in]: excresType int Excressence type enum (i.e. EXCRESCENCE_PERCENT_GEOM) :param [in]: excresVal double Excressence value

openvsp.vsp.AddFeaBC(fea_struct_id, type=-1)

  Add an FEA BC to a Structure

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      struct_id = GetFeaStructID( pod_id, struct_ind );

      #==== Add BC ====//
      bc_id = AddFeaBC( struct_id, FEA_BC_STRUCTURE )

  See also: FEA_BC_TYPE :param [in]: fea_struct_id string FEA Structure ID :param [in]: type int FEA BC type enum ( i.e. FEA_BC_STRUCTURE ) :rtype: string :return: string FEA BC ID

openvsp.vsp.AddFeaMaterial()

  Add an FEA Material the FEA Mesh material library. Materials are available across all Geoms and Structures.

      #==== Create FeaMaterial ====//
      mat_id = AddFeaMaterial()

      SetParmVal( FindParm( mat_id, "MassDensity", "FeaMaterial" ), 0.016 )

  Return type:

    string

  Returns:

    string FEA Material ID

openvsp.vsp.AddFeaPart(geom_id, fea_struct_ind, type)

  Add an FEA Part to a Structure

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      #==== Add Bulkead ====//
      bulkhead_id = AddFeaPart( pod_id, struct_ind, FEA_SLICE )

      SetParmVal( FindParm( bulkhead_id, "IncludedElements", "FeaPart" ), FEA_SHELL_AND_BEAM )

      SetParmVal( FindParm( bulkhead_id, "RelCenterLocation", "FeaPart" ), 0.15 )

  See also: FEA_PART_TYPE :param [in]: geom_id string Parent Geom ID :param [in]: fea_struct_ind int FEA Structure index :param [in]: type int FEA Part type enum (i.e. FEA_RIB) :rtype: string :return: string FEA Part ID

openvsp.vsp.AddFeaPolySparPt(pspar_id)

  Add a point to the end of an FEA Poly Spar and return its ID. The new point is appended after all existing points.

      wing_id = AddGeom( "WING" )

      struct_ind = AddFeaStruct( wing_id )

      pspar_id = AddFeaPart( wing_id, struct_ind, FEA_POLY_SPAR )

      pt_id = AddFeaPolySparPt( pspar_id )

      if GetFeaPolySparNumPt( pspar_id ) != 3:
          print( "Error: AddFeaPolySparPt" )

  See also: InsertFeaPolySparPt, DelFeaPolySparPt, GetFeaPolySparNumPt :param [in]: pspar_id string FEA Poly Spar part ID :rtype: string :return: string ID of the newly added Poly Spar point

openvsp.vsp.AddFeaProperty(property_type=0)

  Add aa FEA Property the FEA Mesh property library. Properties are available across all Geoms and Structures. Currently only beam and shell properties are available. Note FEA_SHELL_AND_BEAM is not a valid property type.

      #==== Create FeaProperty ====//
      prop_id = AddFeaProperty()

      SetParmVal( FindParm( prop_id, "Thickness", "FeaProperty" ), 0.01 )

  See also: FEA_PART_ELEMENT_TYPE :param [in]: property_type int FEA Property type enum (i.e. FEA_SHELL). :rtype: string :return: string FEA Property ID

openvsp.vsp.AddFeaStruct(geom_id, init_skin=True, surfindex=0)

  Add an FEA Structure to a specified Geom Warning: init_skin should ALWAYS be set to true.

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – init_skin bool Flag to initialize the FEA Structure by creating an FEA Skin from the parent Geom’s OML at surfindex

    - [in] – surfindex int Main surface index for the FEA Structure

  Return type:

    int

  Returns:

    int FEA Structure index

openvsp.vsp.AddFeaSubSurf(geom_id, fea_struct_ind, type)

  Add an FEA SubSurface to a Structure

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      #==== Add LineArray ====//
      line_array_id = AddFeaSubSurf( pod_id, struct_ind, SS_LINE_ARRAY )

      SetParmVal( FindParm( line_array_id, "ConstLineType", "SS_LineArray" ), 1 ) # Constant W

      SetParmVal( FindParm( line_array_id, "Spacing", "SS_LineArray" ), 0.25 )

  See also: SUBSURF_TYPE :param [in]: geom_id string Parent Geom ID :param [in]: fea_struct_ind int FEA Structure index :param [in]: type int FEA SubSurface type enum (i.e. SS_ELLIPSE) :rtype: string :return: string FEA SubSurface ID

openvsp.vsp.AddGeom(*args)

  Add a new Geom of given type as a child of the specified parent. If no parent or an invalid parent is given, the Geom is placed at the top level

      #==== Add Wing Geometry ====//
      wing_id = AddGeom( "WING" )

  Parameters:

    - [in] – type string Geom type (i.e FUSELAGE, POD, etc.)

    - [in] – parent string Parent Geom ID

  Return type:

    string

  Returns:

    string Geom ID

openvsp.vsp.AddGeometryAnalysis()

  Add a new Geometry Analysis case to the Geometry Analysis Manager. The Geometry Analysis Manager allows users to configure and execute geometric analysis tasks typical of the aircraft design process, such as wetted area, projected area, mass properties, clearance, and visibility analyses.

      ##==== GeometryAnalysis: Add and configure a case ====##
      ga_id = AddGeometryAnalysis()
      print( "Added Geometry Analysis: ", ga_id )

  See also: DeleteGeometryAnalysis, DeleteAllGeometryAnalyses, GetAllGeometryAnalysesIDVec :rtype: string :return: string ID of the newly created Geometry Analysis case

openvsp.vsp.AddMaterial(name, ambient, diffuse, specular, emissive, alpha, shininess)

  Set the visualization material the specified geometry

      pid = AddGeom( "POD" )

      AddMaterial( "RedGlass", vec3d( 44, 2, 2 ), vec3d( 156, 10, 10 ), vec3d( 185, 159, 159 ), vec3d( 44, 2, 2 ), 30, 0.4 )

      SetGeomMaterialName( pid, "RedGlass" )

  Parameters:

    - [in] – name string Material name

    - [in] – ambient vec3d Ambient color RGB triple on scale [0, 255]

    - [in] – diffuse vec3d Diffuse color RGB triple on scale [0, 255]

    - [in] – specular vec3d Specular color RGB triple on scale [0, 255]

    - [in] – emissive vec3d Emissive color RGB triple on scale [0, 255]

    - [in] – shininess double Shininess exponent on scale [0, 127]

    - [in] – alpha double Transparency factor on scale [0, 1]

openvsp.vsp.AddProbe(geomid, surfindx, u, w, name)

  Create a new Probe and add it to the Measure Tool

      pid1 = AddGeom( "POD", "" )

      SetParmVal( pid1, "Y_Rel_Location", "XForm", 2.0 )

      probe_id = AddProbe( pid1, 0, 0.5, 0.8, "Probe 1" )

      SetParmVal( FindParm( probe_id, "Len", "Measure" ), 3.0 )

  Parameters:

    - [in] – geomid string Parent Geom ID

    - [in] – surfindx int Main surface index from the parent Geom

    - [in] – u double Surface u (0 - 1) coordinate

    - [in] – w double Surface w (0 - 1) coordinate

    - [in] – name string Probe name

  Return type:

    string

  Returns:

    string Probe ID

openvsp.vsp.AddRoutingPt(routing_id, geom_id, surf_index)

  Add a routing point to a RoutingGeom. The new point will be the last point in the route. The new point will be anchored to the specified geom and surface.

      pod1 = vsp.AddGeom('POD', '')

      pod2 = vsp.AddGeom('POD', '')
      ypod2 = vsp.GetParm(pod2, 'Y_Rel_Location', 'XForm')
      vsp.SetParmVal(ypod2, 2.0)

      routing_geom = vsp.AddGeom('ROUTING', '')

      rpt0 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u0 = vsp.GetParm( rpt0, 'U', 'RoutePt')
      vsp.SetParmVal(u0, 0.0)

      rpt1 = vsp.AddRoutingPt(routing_geom, pod2, 0)

      rpt2 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u2 = vsp.GetParm( rpt2, 'U', 'RoutePt')
      vsp.SetParmVal(u2, 1.0)

  See also: AddRoutingPt, DelRoutingPt, InsertRoutingPt :param [in]: routing_id string RoutingGeom Geom ID :param [in]: geom_id string Geom ID of geom to anchor new routing point to :param [in]: surf_index int Index of surf to anchor new routing point to :rtype: string :return: string ParmContainer ID for the newly added routing point

openvsp.vsp.AddRuler(startgeomid, startsurfindx, startu, startw, endgeomid, endsurfindx, endu, endw, name)

  Create a new Ruler and add it to the Measure Tool

      pid1 = AddGeom( "POD", "" )

      SetParmVal( pid1, "Y_Rel_Location", "XForm", 2.0 )

      pid2 = AddGeom( "POD", "" )

      SetParmVal( pid2, "Z_Rel_Location", "XForm", 4.0 )

      rid = AddRuler( pid1, 1, 0.2, 0.3, pid2, 0, 0.2, 0.3, "Ruler 1" )

      SetParmVal( FindParm( rid, "X_Offset", "Measure" ), 6.0 )

  Parameters:

    - [in] – startgeomid string Start parent Geom ID

    - [in] – startsurfindx int Main surface index from the staring parent Geom

    - [in] – startu double Surface u (0 - 1) start coordinate

    - [in] – startw double Surface w (0 - 1) start coordinate

    - [in] – endgeomid string End parent Geom ID

    - [in] – endsurfindx int Main surface index on the end parent Geom

    - [in] – endu double Surface u (0 - 1) end coordinate

    - [in] – endw double Surface w (0 - 1) end coordinate

    - [in] – name string Ruler name

  Return type:

    string

  Returns:

    string Ruler ID

openvsp.vsp.AddSelectedToCSGroup(selected, CSGroupIndex)

  Add each control surfaces in the array of control surface indexes to the control surface group at the specified index.

  Warning: The indexes in input “selected” must be matched with available control surfaces identified by GetAvailableCSNameVec. The “selected” input uses one- based indexing to associate available control surfaces.

      wid = AddGeom( "WING", "" ) # Add Wing

      aileron_id = AddSubSurf( wid, SS_CONTROL ) # Add Control Surface Sub-Surface

      group_index = CreateVSPAEROControlSurfaceGroup() # Empty control surface group

      cs_name_vec = GetAvailableCSNameVec( group_index )

      cs_ind_vec = [0] * len(cs_name_vec)

      for i in range(int( len(cs_name_vec) )):

          cs_ind_vec[i] = i + 1

      AddSelectedToCSGroup( cs_ind_vec, group_index ) # Add all available control surfaces to the group

  See also: GetAvailableCSNameVec :param [in]: selected vector <int> Array of control surface indexes to add to the group. Note, the integer values are one based. :param [in]: CSGroupIndex int Index of the control surface group

openvsp.vsp.AddSubSurf(geom_id, type, surfindex=0)

  Add a sub-surface to the specified Geom

      wid = AddGeom( "WING", "" )                             # Add Wing

      # Note: Parm Group for SubSurfaces in the form: "SS_" + type + "_" + count (initialized at 1)
      ss_line_id = AddSubSurf( wid, SS_LINE )                      # Add Sub Surface Line

      SetParmVal( wid, "Const_Line_Value", "SubSurface_1", 0.4 )     # Change Location

  See also: SUBSURF_TYPE :param [in]: geom_id string Geom ID :param [in]: type int Sub-surface type enum (i.e. SS_RECTANGLE) :param [in]: surfindex int Main surface index (default: 0) :rtype: string :return: string Sub-surface ID

openvsp.vsp.AddUserParm(type, name, group)

  Function to add a new user Parm of input type, name, and group

      length = AddUserParm( PARM_DOUBLE_TYPE, "Length", "Design" )

      SetParmValLimits( length, 10.0, 0.001, 1.0e12 )

      SetParmDescript( length, "Length user parameter" )

  See also: PARM_TYPE :param [in]: type int Parm type enum (i.e. PARM_DOUBLE_TYPE) :param [in]: name string Parm name :param [in]: group string Parm group :rtype: string :return: string Parm ID

openvsp.vsp.AddVarPresetGroup(group_name)

  Add a Variable Preset Group

      # Add Pod Geom
      pod1 = AddGeom( "POD", "" )

      gid = AddVarPresetGroup( "Tess" )

  Parameters:

    [in] – group_name string Name for Var Preset Group

  Return type:

    string

  Returns:

    string Var Preset Group ID

openvsp.vsp.AddVarPresetParm(group_id, parm_id)

  Add a Parm to the Variable Preset Group

      # Add Pod Geom
      pod1 = AddGeom( "POD", "" )

      gid = AddVarPresetGroup( "Tess" )

      sid = AddVarPresetSetting( gid, "Coarse" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )

      AddVarPresetParm( gid, p1 )

  Parameters:

    - [in] – group_id string Var Preset Group ID

    - [in] – parm_id string Parm ID

openvsp.vsp.AddVarPresetSetting(group_id, setting_name)

  Add a Setting to the Variable Preset Group

      # Add Pod Geom
      pod1 = AddGeom( "POD", "" )

      gid = AddVarPresetGroup( "Tess" )

      sid = AddVarPresetSetting( gid, "Coarse" )

  Parameters:

    - [in] – group_id string Var Preset Group ID

    - [in] – setting_name string Var Preset Setting Name

  Return type:

    string

  Returns:

    string Var Preset Setting ID

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

openvsp.vsp.ApplyModeSettings(mid)

  Apply Parm settings corresponding to a Mode.

      # Illustrating use of Modes requires substantial setup of the model including components, sets, and variable presets.
      #
      # Setup boiler plate.
      pod1 = AddGeom( "POD", "" )
      wing = AddGeom( "WING", pod1 )

      SetParmVal( wing, "Trans_Attach_Flag", "Attach", ATTACH_TRANS_LMN )
      SetParmVal( wing, "L_Attach_Location", "Attach", 0.35 )

      SetSetName( SET_FIRST_USER, "NonLifting" )
      SetSetName( SET_FIRST_USER + 1, "Lifting" )

      SetSetFlag( pod1, SET_FIRST_USER, True )
      SetSetFlag( wing, SET_FIRST_USER + 1, True )

      gid = AddVarPresetGroup( "Tess" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )
      AddVarPresetParm( gid, p1 )

      p2 = FindParm( pod1, "Tess_W", "Shape" )
      AddVarPresetParm( gid, p2 )

      sid = AddVarPresetSetting( gid, "Default" )
      SaveVarPresetParmVals( gid, sid )

      sid1 = AddVarPresetSetting( gid, "Coarse" )
      SetVarPresetParmVal( gid, sid1, p1, 3 )
      SetVarPresetParmVal( gid, sid1, p2, 5 )

      sid2 = AddVarPresetSetting( gid, "Fine" )
      SetVarPresetParmVal( gid, sid, p1, 35 )
      SetVarPresetParmVal( gid, sid, p2, 21 )

      gid2 = AddVarPresetGroup( "Design" )

      p3 = FindParm( pod1, "Length", "Design" )
      AddVarPresetParm( gid2, p3 )

      p4 = FindParm( pod1, "FineRatio", "Design" )
      AddVarPresetParm( gid2, p4 )

      sid3 = AddVarPresetSetting( gid2, "Normal" )
      SaveVarPresetParmVals( gid2, sid3 )

      sid4 = AddVarPresetSetting( gid2, "ShortFat" )
      SetVarPresetParmVal( gid2, sid4, p3, 3.0 )
      SetVarPresetParmVal( gid2, sid4, p4, 5.0 )

      sid5 = AddVarPresetSetting( gid2, "LongThin" )
      SetVarPresetParmVal( gid2, sid5, p3, 20.0 )
      SetVarPresetParmVal( gid2, sid5, p4, 35.0 )

      # End of setup boiler plate.

      mid1 = CreateAndAddMode( "FatWetAreas", SET_ALL, SET_NONE )
      ModeAddGroupSetting( mid1, gid, sid1 )
      ModeAddGroupSetting( mid1, gid2, sid4 )

      mid2 = CreateAndAddMode( "ThinAero", SET_FIRST_USER, SET_FIRST_USER + 1 )
      ModeAddGroupSetting( mid2, gid, sid2 )
      ModeAddGroupSetting( mid1, gid2, sid5 )

      ApplyModeSettings( mid2 )
      Update()

  Parameters:

    [in] – mid string Mode ID of mode to apply

openvsp.vsp.ApplyVarPresetSetting(group_id, setting_id)

  Apply Parm values for Var Preset Setting

      # Add Pod Geom
      pod1 = AddGeom( "POD", "" )

      gid = AddVarPresetGroup( "Tess" )

      sid = AddVarPresetSetting( gid, "Coarse" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )

      AddVarPresetParm( gid, p1 )

      ApplyVarPresetSetting( gid, sid )

      Update()

  Parameters:

    - [in] – group_id string Var Preset Group ID

    - [in] – setting_id string Var Preset Setting ID

openvsp.vsp.ApproximateAllPropellerPCurves(geom_id)

  Approximate all propeller blade curves with cubic Bezier curves.

      # Add Propeller
      prop = AddGeom( "PROP", "" )

      ApproximateAllPropellerPCurves( prop )

  Parameters:

    [in] – geom_id string Geom ID

openvsp.vsp.AutoGroupVSPAEROControlSurfaces()

  Creates the initial default grouping for the control surfaces. The initial grouping collects all surface copies of the sub-surface into a single group. For example if a wing is defined with an aileron and that wing is symmetrical about the xz plane there will be a surface copy of the master wing surface as well as a copy of the sub-surface. The two sub-surfaces may get deflected differently during analysis routines and can be identified uniquely by their full name.

      wid = AddGeom( "WING", "" )                             # Add Wing

      aileron_id = AddSubSurf( wid, SS_CONTROL )                      # Add Control Surface Sub-Surface

      #==== Add Vertical tail and set some parameters =====//
      vert_id = AddGeom( "WING" )

      SetGeomName( vert_id, "Vert" )

      SetParmValUpdate( vert_id, "TotalArea", "WingGeom", 10.0 )
      SetParmValUpdate( vert_id, "X_Rel_Location", "XForm", 8.5 )
      SetParmValUpdate( vert_id, "X_Rel_Rotation", "XForm", 90 )

      rudder_id = AddSubSurf( vert_id, SS_CONTROL )                      # Add Control Surface Sub-Surface

      AutoGroupVSPAEROControlSurfaces()

      Update()

      print( "COMPLETE\n" )
      control_group_settings_container_id = FindContainer( "VSPAEROSettings", 0 )   # auto grouping produces parm containers within VSPAEROSettings

      #==== Set Control Surface Group Deflection Angle ====//
      print( "\tSetting control surface group deflection angles..." )

      # subsurfaces get added to groups with "CSGQualities_[geom_name]_[control_surf_name]"
      # subsurfaces gain parm name is "Surf[surfndx]_Gain" starting from 0 to NumSymmetricCopies-1

      deflection_gain_id = FindParm( control_group_settings_container_id, "Surf_" + aileron_id + "_0_Gain", "ControlSurfaceGroup_0" )
      deflection_gain_id = FindParm( control_group_settings_container_id, "Surf_" + aileron_id + "_1_Gain", "ControlSurfaceGroup_0" )

      #  deflect aileron
      deflection_angle_id = FindParm( control_group_settings_container_id, "DeflectionAngle", "ControlSurfaceGroup_0" )

  See also: CreateVSPAEROControlSurfaceGroup

openvsp.vsp.AxisProjPnt01(geom_id, surf_indx, iaxis, pt)

  Project an input 3D coordinate point onto a surface along a specified axis. If the axis-aligned ray from the point intersects the surface multiple times, the nearest intersection is returned. If the axis-aligned ray from the point does not intersect the surface, the original point is returned and -1 is returned in the other output parameters.

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      surf_indx = 0

      u = 0.12345
      w = 0.67890

      surf_pt = CompPnt01( geom_id, surf_indx, u, w )
      pt = surf_pt

      pt.offset_y( -5.0 )

      idist, u_out, w_out = AxisProjPnt01( geom_id, surf_indx, Y_DIR, pt )

      print( f"iDist {idist} u_out {u_out} w_out {w_out}" )
      print( "3D Offset ", False)

  See also: AxisProjPnt01Guess, AxisProjPnt01I, AxisProjVecPnt01, AxisProjVecPnt01Guess :param [in]: geom_id string Parent Geom ID :param [in]: surf_indx int Main surface index from the parent Geom :param [in]: iaxis int Axis direction to project point along (X_DIR, Y_DIR, or Z_DIR) :param [in]: pt vec3d Input 3D coordinate point :param [out]: u_out double Output closest U (0 - 1) surface coordinate :param [out]: w_out double Output closest W (0 - 1) surface coordinate :rtype: float :return: double Axis aligned distance between the 3D point and the projected point on the surface

openvsp.vsp.AxisProjPnt01Guess(geom_id, surf_indx, iaxis, pt, u0, w0)

  Project an input 3D coordinate point onto a surface along a specified axis given an initial guess of surface parameter. If the axis-aligned ray from the point intersects the surface multiple times, the nearest intersection is returned. If the axis-aligned ray from the point does not intersect the surface, the original point is returned and -1 is returned in the other output parameters. The surface parameter guess should allow this call to be faster than calling AxisProjPnt01 without a guess.

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      surf_indx = 0

      u = 0.12345
      w = 0.67890

      surf_pt = CompPnt01( geom_id, surf_indx, u, w )
      pt = surf_pt

      pt.offset_y( -5.0 )

      # Construct initial guesses near actual parameters
      u0 = u + 0.01234
      w0 = w - 0.05678

      d, uout, wout = AxisProjPnt01Guess( geom_id, surf_indx, Y_DIR, pt, u0, w0 )

      print( f"Dist {d} u {uout} w {wout}" )

  See also: AxisProjPnt01, AxisProjPnt01I, AxisProjVecPnt01, AxisProjVecPnt01Guess :param [in]: geom_id string Parent Geom ID :param [in]: surf_indx int Main surface index from the parent Geom :param [in]: iaxis int Axis direction to project point along (X_DIR, Y_DIR, or Z_DIR) :param [in]: pt vec3d Input 3D coordinate point :param [in]: u0 double Input U (0 - 1) surface coordinate guess :param [in]: w0 double Input W (0 - 1) surface coordinate guess :param [out]: u_out double Output closest U (0 - 1) surface coordinate :param [out]: w_out double Output closest W (0 - 1) surface coordinate :rtype: float :return: double Distance between the 3D point and the closest point of the surface

openvsp.vsp.AxisProjPnt01I(geom_id, iaxis, pt)

  Project an input 3D coordinate point onto a Geom along a specified axis. The intersecting surface index is also returned. If the axis-aligned ray from the point intersects the Geom multiple times, the nearest intersection is returned. If the axis-aligned ray from the point does not intersect the Geom, the original point is returned and -1 is returned in the other output parameters.

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      surf_indx = 0

      u = 0.12345
      w = 0.67890

      surf_pt = CompPnt01( geom_id, surf_indx, u, w )
      pt = surf_pt

      pt.offset_y( -5.0 )

      idist, surf_indx_out, u_out, w_out = AxisProjPnt01I( geom_id, Y_DIR, pt )

      print( "iDist {idist} u_out {u_out} w_out {w_out} surf_index {surf_indx_out}" )
      print( "3D Offset ", False)

  See also: AxisProjPnt01, AxisProjPnt01Guess, AxisProjVecPnt01, AxisProjVecPnt01Guess :param [in]: geom_id string Parent Geom ID :param [in]: iaxis int Axis direction to project point along (X_DIR, Y_DIR, or Z_DIR) :param [in]: pt vec3d Input 3D coordinate point :param [out]: surf_indx_out int Output main surface index from the parent Geom :param [out]: u_out double Output closest U (0 - 1) surface coordinate :param [out]: w_out double Output closest W (0 - 1) surface coordinate :rtype: float :return: double Axis aligned distance between the 3D point and the projected point on the surface

openvsp.vsp.AxisProjVecPnt01(geom_id, surf_indx, iaxis, pts)

  Project an input array of 3D coordinate points onto a surface along a specified axis. If the axis-aligned ray from the point intersects the surface multiple times, the nearest intersection is returned. If the axis-aligned ray from the point does not intersect the surface, the original point is returned and -1 is returned in the other output parameters.

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )
      surf_indx = 0

      n = 5

      uvec = [0]*n
      wvec = [0]*n

      for i in range(n):

          uvec[i] = (i+1)*1.0/(n+1)

          wvec[i] = (n-i)*1.0/(n+1)

      ptvec = CompVecPnt01( geom_id, surf_indx, uvec, wvec )

      for i in range(n):

          ptvec[i].offset_y( -5.0 )

      uoutv, woutv, doutv = AxisProjVecPnt01( geom_id, surf_indx, Y_DIR, ptvec )

      # Some of these outputs are expected to be non-zero because the projected point is on the opposite side of
      # the pod from the originally computed point.  I.e. there were multiple solutions and the original point
      # is not the closest intersection point.  We could offset those points in the +Y direction instead of -Y.
      for i in range(n):

          print( i, False )
          print( "U delta ", False )
          print( uvec[i] - uoutv[i], False )
          print( "W delta ", False )
          print( wvec[i] - woutv[i] )

  See also: AxisProjPnt01, AxisProjPnt01Guess, AxisProjPnt01I, AxisProjVecPnt01Guess :param [in]: geom_id string Geom ID :param [in]: surf_indx int Main surface index from the Geom :param [in]: iaxis int Axis direction to project point along (X_DIR, Y_DIR, or Z_DIR) :param [in]: pts vector<vec3d> Input vector of 3D coordinate points :param [out]: u_out_vec vector<double> Output vector of the closest U (0 - 1) surface coordinate for each 3D input point :param [out]: w_out_vec vector<double> Output vector of the closest W (0 - 1) surface coordinate for each 3D input point :param [out]: d_out_vec vector<double> Output vector of axis distances for each 3D point and the projected point of the surface

openvsp.vsp.AxisProjVecPnt01Guess(geom_id, surf_indx, iaxis, pts, u0s, w0s)

  Project an input array of 3D coordinate points onto a surface along a specified axis given initial guess arrays of surface parameter. If the axis-aligned ray from the point intersects the surface multiple times, the nearest intersection is returned. If the axis-aligned ray from the point does not intersect the surface, the original point is returned and -1 is returned in the other output parameters. The surface parameter guess should allow this call to be faster than calling AxisProjVecPnt01 without a guess.

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )
      surf_indx = 0

      n = 5

      uvec = [0]*n
      wvec = [0]*n

      for i in range(n):

          uvec[i] = (i+1)*1.0/(n+1)

          wvec[i] = (n-i)*1.0/(n+1)

      ptvec = CompVecPnt01( geom_id, surf_indx, uvec, wvec )

      for i in range(n):

          ptvec[i].offset_y( -5.0 )

      u0v = [0]*n
      w0v = [0]*n

      for i in range(n):

          u0v[i] = uvec[i] + 0.01234
          w0v[i] = wvec[i] - 0.05678

      uoutv, woutv, doutv = AxisProjVecPnt01Guess( geom_id, surf_indx, Y_DIR, ptvec, u0v,  w0v )

      for i in range(n):

          print( i, False )
          print( "U delta ", False )
          print( uvec[i] - uoutv[i], False )
          print( "W delta ", False )
          print( wvec[i] - woutv[i] )

  See also: AxisProjPnt01, AxisProjPnt01Guess, AxisProjPnt01I, AxisProjVecPnt01 :param [in]: geom_id string Parent Geom ID :param [in]: surf_indx int Main surface index from the parent Geom :param [in]: iaxis int Axis direction to project point along (X_DIR, Y_DIR, or Z_DIR) :param [in]: pts vector<vec3d> Input vector of 3D coordinate points :param [in]: u0s vector<double> Input vector of U (0 - 1) surface coordinate guesses :param [in]: w0s vector<double> Input vector of W (0 - 1) surface coordinate guesses :param [out]: u_out_vec vector<double> Output vector of the closest U (0 - 1) surface coordinate for each 3D input point :param [out]: w_out_vec vector<double> Output vector of the closest W (0 - 1) surface coordinate for each 3D input point :param [out]: d_out_vec vector<double> Output vector of axis distances for each 3D point and the projected point of the surface

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.BOGIE_CENTER_DIST = 0

  Distance between centers

openvsp.vsp.BOGIE_CENTER_DIST_FRAC = 1

  Fractional distance between centers

openvsp.vsp.BOGIE_GAP = 2

  Gap

openvsp.vsp.BOGIE_GAP_FRAC = 3

  Fractional gap

openvsp.vsp.BOOL_DATA = 0

  Bool data type

openvsp.vsp.BOR_FLOWTHROUGH = 0

  Flowthrough mode (default)

openvsp.vsp.BOR_GEOM_SCREEN = 14

  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`

  Proxy of C++ std::vector< bool > class.

  append(BoolVector self, std: :vector< bool >::value_type x)
  assign(BoolVector self, std: :vector< bool >::size_type n, std: :vector< bool >::value_type x)
  back(BoolVector self) → std::vector< bool >::value_type
  begin(BoolVector self) → std::vector< bool >::iterator
  capacity(BoolVector self) → std::vector< bool >::size_type
  clear(BoolVector self)
  empty(BoolVector self) → bool
  end(BoolVector self) → std::vector< bool >::iterator
  erase(BoolVector self, std: :vector< bool >::iterator pos) → std::vector< bool >::iterator
  erase(BoolVector self, std: :vector< bool >::iterator first, std: :vector< bool >::iterator last) → std::vector< bool >::iterator
  front(BoolVector self) → std::vector< bool >::value_type
  get_allocator(BoolVector self) → std::vector< bool >::allocator_type
  insert(BoolVector self, std: :vector< bool >::iterator pos, std: :vector< bool >::value_type x) → std::vector< bool >::iterator
  insert(BoolVector self, std: :vector< bool >::iterator pos, std: :vector< bool >::size_type n, std: :vector< bool >::value_type x)
  iterator(BoolVector self) → SwigPyIterator
  pop(BoolVector self) → std::vector< bool >::value_type
  pop_back(BoolVector self)
  push_back(BoolVector self, std: :vector< bool >::value_type x)
  rbegin(BoolVector self) → std::vector< bool >::reverse_iterator
  rend(BoolVector self) → std::vector< bool >::reverse_iterator
  reserve(BoolVector self, std: :vector< bool >::size_type n)
  resize(BoolVector self, std: :vector< bool >::size_type new_size)
  resize(BoolVector self, std: :vector< bool >::size_type new_size, std: :vector< bool >::value_type x)
  size(BoolVector self) → std::vector< bool >::size_type
  swap(BoolVector self, BoolVector v)
  property thisown

    The membership flag

openvsp.vsp.BuildAdvLinkScript(index)

  Build (ready for execution and perform syntax check) an advanced link.

      pod = AddGeom( "POD", "" )
      length = FindParm( pod, "Length", "Design" )
      x_pos = GetParm( pod, "X_Rel_Location", "XForm" )

      AddAdvLink( "ExampleLink" )
      indx = GetLinkIndex( "ExampleLink" )
      AddAdvLinkInput( indx, length, "len" )
      AddAdvLinkOutput( indx, x_pos, "x" )

      SetAdvLinkCode( indx, "x = 10.0 - len;" )

      success = BuildAdvLinkScript( indx )

      if  success :
          print( "Advanced link build successful." )
      else:
          print( "Advanced link build not successful." )

  Parameters:

    [in] – index int Index for advanced link

  Return type:

    boolean

  Returns:

    bool Flag indicating whether advanced link build was successful

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.CCE_INTERFERENCE = 11

  Interference with composite clearance envelope

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_CW = 1

  Center and Width

openvsp.vsp.CHEVRON_W01_NUM_MODES = 2

  Number of chevron W parameter mode types.

openvsp.vsp.CHEVRON_W01_SE = 0

  Start and End

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.COBRA_GEOM_SCREEN = 20

  Cobra body geom screen

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.COMP_GEOM = 15

  Calculate wetted area and volume

openvsp.vsp.CONFORMAL_SCREEN = 12

  Conformal geom screen

openvsp.vsp.CONST_U = 0

  Constant U sub-surface

openvsp.vsp.CONST_W = 1

  Constant W sub-surface

openvsp.vsp.CP_PROP_DRIVER = 2

  Power coefficient driver

openvsp.vsp.CQ_PROP_DRIVER = 7

  Torque coefficient driver

openvsp.vsp.CT_PROP_DRIVER = 1

  Thrust coefficient driver

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 = 7

  Custom geom screen

openvsp.vsp.CalcAtmosphere(alt, delta_temp, atmos_type)

  Calculate the atmospheric properties determined by a specified model at input altitude and temperature deviation. This function may not be used for any manual atmospheric model types (i.e. ATMOS_TYPE_MANUAL_P_T). This function assumes freestream units are metric, temperature units are Kelvin, and pressure units are kPA.

      alt = 4000

      delta_temp = 0

      temp, pres, pres_ratio, rho_ratio = CalcAtmosphere( alt, delta_temp, ATMOS_TYPE_US_STANDARD_1976)

  See also: ATMOS_TYPE :param [in]: alt double Altitude :param [in]: delta_temp double Deviation in temperature from the value specified in the atmospheric model :param [in]: atmos_type int Atmospheric model enum (i.e. ATMOS_TYPE_HERRINGTON_1966) :param [out]: temp double output Temperature :param [out]: pres double output Pressure :param [out]: pres_ratio double Output pressure ratio :param [out]: rho_ratio double Output density ratio

openvsp.vsp.ChangeBORXSecShape(bor_id, type)

  Set the XSec type for a BOR component

      # Add Body of Recolution
      bor_id = AddGeom( "BODYOFREVOLUTION", "" )

      ChangeBORXSecShape( bor_id, XS_ROUNDED_RECTANGLE )

      if  GetBORXSecShape( bor_id ) != XS_ROUNDED_RECTANGLE : print( "ERROR: ChangeBORXSecShape" )

  See also: XSEC_CRV_TYPE :param [in]: bor_id string Body of revolution Geom ID :param [in]: type int XSec type enum (i.e. XS_ROUNDED_RECTANGLE)

openvsp.vsp.ChangeXSecShape(xsec_surf_id, xsec_index, type)

  Change the shape of a particular XSec, identified by an XSecSurf ID and XSec index

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      # Set XSec 1 & 2 to Edit Curve type
      ChangeXSecShape( xsec_surf, 1, XS_EDIT_CURVE )
      ChangeXSecShape( xsec_surf, 2, XS_EDIT_CURVE )

      xsec_2 = GetXSec( xsec_surf, 2 )

      if  GetXSecShape( xsec_2 ) != XS_EDIT_CURVE :
          print( "Error: ChangeXSecShape" )

  See also: XSEC_CRV_TYPE :param [in]: xsec_surf_id string XSecSurf ID :param [in]: xsec_index int Xsec index :param [in]: type int Xsec type enum (i.e. XS_ELLIPSE)

openvsp.vsp.CheckForVSPAERO(path)

  Check if all VSPAERO executables (Solver, Viewer, and Slicer) are in a given directory. Note that this function will return false if only one or two VSPAERO executables are found. An error message will indicate the executables that are missing. This may be acceptable, as only the Solver is needed in all cases. The Viewer and Slicer may not be needed.

      vspaero_path = "C:/Users/example_user/Documents/OpenVSP_3.4.5"

      if  CheckForVSPAERO( vspaero_path ) :
          SetVSPAEROPath( vspaero_path )

  See also: GetVSPExePath, GetVSPAEROPath, SetVSPAEROPath :param [in]: path string Absolute path to check for VSPAERO executables :rtype: boolean :return: bool Flag that indicates if all VSPAERO executables are found or not

openvsp.vsp.CheckForVSPHelp(path)

  Check if all OpenVSP help files are in a given directory.

      vsphelp_path = "C:/Users/example_user/Documents/OpenVSP_3.4.5/help"

      if  CheckForVSPHelp( vsphelp_path ) :
          SetVSPHelpPath( vsphelp_path )

  See also: GetVSPExePath, GetVSPAEROPath, SetVSPHelpPath :param [in]: path string Absolute path to check for VSPAERO executables :rtype: boolean :return: bool Flag that indicates if OpenVSP help files are found or not

openvsp.vsp.ClearVSPModel()

  Clear the current OpenVSP model

      fid = AddGeom( "FUSELAGE", "" )             # Add Fuselage

      #==== Reset Geometry ====//
      print( "--->Resetting VSP model to blank slate\n" )
      ClearVSPModel()

openvsp.vsp.CompCurvature01(geom_id, surf_indx, u, w)

  Determine the curvature of a specified surface at the input surface coordinate point

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      surf_indx = 0

      u = 0.25
      w = 0.75

      k1, k2, ka, kg = CompCurvature01( geom_id, surf_indx, u, w )

      print( f"Curvature : k1 {k1} k2 {k2} ka {ka} kg {kg}" )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – surf_indx int Main surface index from the parent Geom

    - [in] – u double U (0 - 1) surface coordinate

    - [in] – w double W (0 - 1) surface coordinate

    - [out] – k1_out double Output value of maximum principal curvature

    - [out] – k2_out double Output value of minimum principal curvature

    - [out] – ka_out double Output value of mean curvature

    - [out] – kg_out double Output value of Gaussian curvature

openvsp.vsp.CompNorm01(geom_id, surf_indx, u, w)

  Calculate the normal vector on the specified surface at input surface coordinate

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      surf_indx = 0

      u = 0.12345
      w = 0.67890

      norm = CompNorm01( geom_id, surf_indx, u, w )

      print( "Point: ( {norm.x()}, {norm.y()}, {norm.z()} )" )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – surf_indx int Main surface index from the parent Geom

    - [in] – u double U (0 - 1) surface coordinate

    - [in] – w double W (0 - 1) surface coordinate

  Return type:

    `vec3d`

  Returns:

    vec3d Normal vector

openvsp.vsp.CompPnt01(geom_id, surf_indx, u, w)

  Calculate the 3D coordinate equivalent for the input surface coordinate point

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      surf_indx = 0

      u = 0.12345
      w = 0.67890

      pnt = CompPnt01( geom_id, surf_indx, u, w )

      print( f"Point: ( {pnt.x()}, {pnt.y()}, {pnt.z()} )" )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – surf_indx int Main surface index from the parent Geom

    - [in] – u double U (0 - 1) surface coordinate

    - [in] – w double W (0 - 1) surface coordinate

  Return type:

    `vec3d`

  Returns:

    vec3d Normal vector3D coordinate point

openvsp.vsp.CompPntRST(geom_id, surf_indx, r, s, t)

  Calculate the (X, Y, Z) coordinate for the input volume (R, S, T) coordinate point

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      surf_indx = 0

      r = 0.12
      s = 0.68
      t = 0.56

      pnt = CompPntRST( geom_id, surf_indx, r, s, t )

      print( f"Point: ( {pnt.x()}, {pnt.y()}, {pnt.z()} )" )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – surf_indx int Main surface index from the parent Geom

    - [in] – r double R (0 - 1) volume coordinate

    - [in] – s double S (0 - 1) volume coordinate

    - [in] – t double T (0 - 1) volume coordinate

  Return type:

    `vec3d`

  Returns:

    vec3d coordinate point

openvsp.vsp.CompTanU01(geom_id, surf_indx, u, w)

  Calculate the vector tangent to the specified surface at input surface coordinate in the U direction

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      surf_indx = 0

      u = 0.12345
      w = 0.67890

      tanu = CompTanU01( geom_id, surf_indx, u, w )

      print( f"Point: ( {tanu.x()}, {tanu.y()}, {tanu.z()} )" )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – surf_indx int Main surface index from the parent Geom

    - [in] – u double U (0 - 1) surface coordinate

    - [in] – w double W (0 - 1) surface coordinate

  Return type:

    `vec3d`

  Returns:

    vec3d Tangent vector in U direction

openvsp.vsp.CompTanW01(geom_id, surf_indx, u, w)

  Calculate the vector tangent to the specified surface at input surface coordinate in the W direction

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      surf_indx = 0

      u = 0.12345
      w = 0.67890

      tanw = CompTanW01( geom_id, surf_indx, u, w )

      print( f"Point: ( {tanw.x()}, {tanw.y()}, {tanw.z()} )" )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – surf_indx int Main surface index from the parent Geom

    - [in] – u double U (0 - 1) surface coordinate

    - [in] – w double W (0 - 1) surface coordinate

  Return type:

    `vec3d`

  Returns:

    vec3d Tangent vector in W direction

openvsp.vsp.CompVecCurvature01(geom_id, surf_indx, us, ws)

  Determine the curvature of a specified surface at each surface coordinate point in the input arrays

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      n = 5

      uvec = [0]*n
      wvec = [0]*n

      for i in range(n):

          uvec[i] = (i+1)*1.0/(n+1)

          wvec[i] = (n-i)*1.0/(n+1)

      k1vec, k2vec, kavec, kgvec = CompVecCurvature01( geom_id, 0, uvec, wvec )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – surf_indx int Main surface index from the parent Geom

    - [in] – us vector<double> Input vector of U (0 - 1) surface coordinates

    - [in] – ws vector<double> Input vector of W (0 - 1) surface coordinates

    - [out] – k1_out_vec vector<double> Output vector of maximum principal curvatures

    - [out] – k2_out_vec vector<double> Output vector of minimum principal curvatures

    - [out] – ka_out_vec vector<double> Output vector of mean curvatures

    - [out] – kg_out_vec vector<double> Output vector of Gaussian curvatures

openvsp.vsp.CompVecDegenPnt01(geom_id, surf_indx, degen_type, u_in_vec, w_in_vec)

  Determine 3D coordinate for each degen surface coordinate point in the input arrays

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      n = 5

      uvec = [0]*n
      wvec = [0]*n

      for i in range(n):

          uvec[i] = (i+1)*1.0/(n+1)

          wvec[i] = (n-i)*1.0/(n+1)

      ptvec = CompVecDegenPnt01( geom_id, 0, 0, uvec, wvec )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – surf_indx int Main surface index from the parent Geom

    - [in] – degen_type int Type of degen surface (0-S, 1-V, 2-H, 3-C)

    - [in] – u_in_vec vector<double> Input vector of U (0 - 1) surface coordinates

    - [in] – w_in_vec vector<double> Input vector of W (0 - 1) surface coordinates

  Return type:

    std::vector< vec3d,std::allocator< vec3d > >

  Returns:

    vector<vec3d> Vector of 3D coordinate points

openvsp.vsp.CompVecNorm01(geom_id, surf_indx, us, ws)

  Determine the normal vector on a surface for each surface coordinate point in the input arrays

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      n = 5

      uvec = [0]*n
      wvec = [0]*n

      for i in range(n):

          uvec[i] = (i+1)*1.0/(n+1)

          wvec[i] = (n-i)*1.0/(n+1)

      normvec = CompVecNorm01( geom_id, 0, uvec, wvec )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – surf_indx int Main surface index from the parent Geom

    - [in] – us vector<double> Input vector of U (0 - 1) surface coordinates

    - [in] – ws vector<double> Input vector of W (0 - 1) surface coordinates

  Return type:

    std::vector< vec3d,std::allocator< vec3d > >

  Returns:

    vector<vec3d> Vector of 3D normal vectors

openvsp.vsp.CompVecPnt01(geom_id, surf_indx, u_in_vec, w_in_vec)

  Determine 3D coordinate for each surface coordinate point in the input arrays

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      n = 5

      uvec = [0]*n
      wvec = [0]*n

      for i in range(n):

          uvec[i] = (i+1)*1.0/(n+1)

          wvec[i] = (n-i)*1.0/(n+1)

      ptvec = CompVecPnt01( geom_id, 0, uvec, wvec )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – surf_indx int Main surface index from the parent Geom

    - [in] – u_in_vec vector<double> Input vector of U (0 - 1) surface coordinates

    - [in] – w_in_vec vector<double> Input vector of W (0 - 1) surface coordinates

  Return type:

    std::vector< vec3d,std::allocator< vec3d > >

  Returns:

    vector<vec3d> Vector of 3D coordinate points

openvsp.vsp.CompVecPntRST(geom_id, surf_indx, r_in_vec, s_in_vec, t_in_vec)

  Determine 3D coordinate for each volume coordinate point in the input arrays

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      n = 5

      rvec = [0]*n
      svec = [0]*n
      tvec = [0]*n

      for i in range(n):

          rvec[i] = (i+1)*1.0/(n+1)

          svec[i] = (n-i)*1.0/(n+1)

          tvec[i] = (i+1)*1.0/(n+1)

      ptvec = CompVecPntRST( geom_id, 0, rvec, svec, tvec )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – surf_indx int Main surface index from the parent Geom

    - [in] – r_in_vec vector<double> Input vector of R (0 - 1.0) volume coordinates

    - [in] – s_in_vec vector<double> Input vector of S (0 - 1.0) volume coordinates

    - [in] – t_in_vec vector<double> Input vector of T (0 - 1.0) volume coordinates

  Return type:

    std::vector< vec3d,std::allocator< vec3d > >

  Returns:

    vector<vec3d> Vector of 3D coordinate points

openvsp.vsp.ComputeBORXSecPnt(bor_id, fract)

  Compute 3D coordinate for a point on a BOR XSecCurve given the parameter value (U) along the curve

      #==== Add Geom ====//
      # Add Body of Recolution
      bor_id = AddGeom( "BODYOFREVOLUTION", "" )

      u_fract = 0.25

      pnt = ComputeBORXSecPnt( bor_id, u_fract )

  Parameters:

    - [in] – bor_id string Body of revolution Geom ID

    - [in] – fract double Curve parameter value (range: 0 - 1)

  Return type:

    `vec3d`

  Returns:

    vec3d Coordinate point on curve

openvsp.vsp.ComputeBORXSecTan(bor_id, fract)

  Compute the tangent vector of a point on a BOR XSecCurve given the parameter value (U) along the curve

      # Add Body of Recolution
      bor_id = AddGeom( "BODYOFREVOLUTION", "" )

      u_fract = 0.25

      tan = ComputeBORXSecTan( bor_id, u_fract )

  Parameters:

    - [in] – bor_id string Body of revolution Geom ID

    - [in] – fract double Curve parameter value (range: 0 - 1)

  Return type:

    `vec3d`

  Returns:

    vec3d Tangent vector on curve

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

  Create a CFD Mesh for the components in the set. This analysis cannot be run through the Analysis Manager.

       #==== CFDMesh Method Facet Export =====//
       SetComputationFileName( CFD_FACET_TYPE, "TestCFDMeshFacet_API.facet" )

      print( "\tComputing CFDMesh..." )

       ComputeCFDMesh( SET_ALL, SET_NONE, CFD_FACET_TYPE )

  See also: COMPUTATION_FILE_TYPE :param [in]: set int Set index (i.e. SET_ALL) :param [in]: degenset int DegenSet index (i.e. SET_NONE) :param [in]: file_export_types int CFD Mesh file type to export (supports XOR i.e CFD_SRF_TYPE & CFD_STL_TYPE)

openvsp.vsp.ComputeCompGeom(set, half_mesh, file_export_types)

  Mesh, intersect, and trim components in the set. Alternatively can be run through the Analysis Manager with ‘CompGeom’.

      #==== Add Pod Geom ====//
      pid = AddGeom( "POD", "" )

      #==== Run CompGeom And Get Results ====//
      mesh_id = ComputeCompGeom( SET_ALL, False, 0 )                      # Half Mesh false and no file export

      comp_res_id = FindLatestResultsID( "Comp_Geom" )                    # Find Results ID

      double_arr = GetDoubleResults( comp_res_id, "Wet_Area" )    # Extract Results

  See also: SetAnalysisInputDefaults, PrintAnalysisInputs, ExecAnalysis, COMPUTATION_FILE_TYPE :param [in]: set int Set index (i.e. SET_ALL) :param [in]: half_mesh bool Flag to ignore surfaces on the negative side of the XZ plane (e.g. symmetry) :param [in]: file_export_types int CompGeom file type to export (supports XOR i.e. COMP_GEOM_CSV_TYPE & COMP_GEOM_TXT_TYPE ) :rtype: string :return: string MeshGeom ID

openvsp.vsp.ComputeDegenGeom(set, file_export_types)

  Compute the degenerate geometry representation for the components in the set. Alternatively can be run through the Analysis Manager with ‘DegenGeom’ or ‘VSPAERODegenGeom’.

      #==== Set File Name ====//
      SetComputationFileName( DEGEN_GEOM_CSV_TYPE, "TestDegenScript.csv" )

      #==== Run Degen Geom ====//
      ComputeDegenGeom( SET_ALL, DEGEN_GEOM_CSV_TYPE )

  See also: SetAnalysisInputDefaults, PrintAnalysisInputs, ExecAnalysis, COMPUTATION_FILE_TYPE :param [in]: set int Set index (i.e. SET_ALL) :param [in]: file_export_types int DegenGeom file type to export (supports XOR i.e DEGEN_GEOM_M_TYPE & DEGEN_GEOM_CSV_TYPE)

openvsp.vsp.ComputeFeaMesh(*args)

  Overload 1:

  Compute an FEA Mesh for a Structure. Only a single output file can be generated with this function.

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      struct_id = GetFeaStructID( pod_id, struct_ind )

      #==== Generate FEA Mesh and Export ====//
      print( "--> Generating FeaMesh " )

      #==== Get Parent Geom ID and Index ====//
      parent_id = GetFeaStructParentGeomID( struct_id ) # same as pod_id

      ComputeFeaMesh( parent_id, struct_ind, FEA_CALCULIX_FILE_NAME )

  See also: SetFeaMeshFileName, FEA_EXPORT_TYPE :param [in]: geom_id string Parent Geom ID :param [in]: fea_struct_ind int FEA Structure index :param [in]: file_type int FEA output file type enum (i.e. FEA_EXPORT_TYPE)

  Overload 2:

  Compute an FEA Mesh for a Structure. Only a single output file can be generated with this function.

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      struct_id = GetFeaStructID( pod_id, struct_ind )

      #==== Generate FEA Mesh and Export ====//
      print( string( "--> Generating FeaMesh " ) )

      #==== Get Parent Geom ID and Index ====//
      parent_id = GetFeaStructParentGeomID( struct_id ) # same as pod_id

      Could also call ComputeFeaMesh ( struct_id, FEA_CALCULIX_FILE_NAME )

  See also: SetFeaMeshFileName, FEA_EXPORT_TYPE :param [in]: struct_id string FEA Structure index :param [in]: file_type int FEA output file type enum (i.e. FEA_EXPORT_TYPE)

openvsp.vsp.ComputeMassProps(set, num_slices, idir)

  Compute mass properties for the components in the set. Alternatively can be run through the Analysis Manager with ‘MassProp’.

      #==== Test Mass Props ====//
      pid = AddGeom( "POD", "" )

      mesh_id = ComputeMassProps( SET_ALL, 20, X_DIR )

      mass_res_id = FindLatestResultsID( "Mass_Properties" )

      double_arr = GetDoubleResults( mass_res_id, "Total_Mass" )

      if  len(double_arr) != 1 : print( "---> Error: API ComputeMassProps" )

  See also: SetAnalysisInputDefaults, PrintAnalysisInputs, ExecAnalysis :param [in]: set int Set index (i.e. SET_ALL) :param [in]: num_slices int Number of slices :param [in]: idir int Direction of slicing for integration :rtype: string :return: string MeshGeom ID

openvsp.vsp.ComputeMinClearanceDistance(*args)

  Compute the minimum clearance distance for the specified geometry

      fid = AddGeom( "FUSELAGE", "" )             # Add Fuselage

      pid = AddGeom( "POD", "" )                     # Add Pod

      x = GetParm( pid, "X_Rel_Location", "XForm" )

      SetParmVal( x, 3.0 )

      Update()

      min_dist = ComputeMinClearanceDistance( pid, SET_ALL )

  Parameters:

    - [in] – geom_id string Geom ID

    - [in] – set int Collision set enum (i.e. SET_ALL)

    - [in] – useMode bool Flag determine if mode is used instead of sets

    - [in] – modeID string ID of Mode to use

  Return type:

    float

  Returns:

    double Minimum clearance distance

openvsp.vsp.ComputePlaneSlice(set, num_slices, norm, auto_bnd, start_bnd=0, end_bnd=0, measureduct=False)

  Slice and mesh the components in the set. Alternatively can be run through the Analysis Manager with ‘PlanarSlice’.

      #==== Add Pod Geom ====//
      pid = AddGeom( "POD", "" )

      #==== Test Plane Slice ====//
      slice_mesh_id = ComputePlaneSlice( 0, 6, vec3d( 0.0, 0.0, 1.0 ), True )

      pslice_results = FindLatestResultsID( "Slice" )

      double_arr = GetDoubleResults( pslice_results, "Slice_Area" )

      if  len(double_arr) != 6 : print( "---> Error: API ComputePlaneSlice" )

  See also: SetAnalysisInputDefaults, PrintAnalysisInputs, ExecAnalysis :param [in]: set int Set index (i.e. SET_ALL) :param [in]: num_slices int Number of slices :param [in]: norm vec3d Normal axis for all slices :param [in]: auto_bnd bool Flag to automatically set the start and end bound locations :param [in]: start_bnd double Location of the first slice along the normal axis (default: 0.0) :param [in]: end_bnd double Location of the last slice along the normal axis (default: 0.0) :param [in]: measureduct bool Flag to measure negative area inside positive area (default: false) :rtype: string :return: string MeshGeom ID

openvsp.vsp.ComputeXSecPnt(xsec_id, fract)

  Compute 3D coordinate for a point on an XSec curve given the parameter value (U) along the curve

      #==== Add Geom ====//
      stack_id = AddGeom( "STACK" )

      #==== Get The XSec Surf ====//
      xsec_surf = GetXSecSurf( stack_id, 0 )

      xsec = GetXSec( xsec_surf, 2 )

      u_fract = 0.25

      pnt = ComputeXSecPnt(xsec, u_fract)

  Parameters:

    - [in] – xsec_id string XSec ID

    - [in] – fract double Curve parameter value (range: 0 - 1)

  Return type:

    `vec3d`

  Returns:

    vec3d 3D coordinate point

openvsp.vsp.ComputeXSecTan(xsec_id, fract)

  Compute the tangent vector of a point on an XSec curve given the parameter value (U) along the curve

      #==== Add Geom ====//
      stack_id = AddGeom( "STACK" )

      #==== Get The XSec Surf ====//
      xsec_surf = GetXSecSurf( stack_id, 0 )

      xsec = GetXSec( xsec_surf, 2 )

      u_fract = 0.25

      tan = ComputeXSecTan( xsec, u_fract )

  Parameters:

    - [in] – xsec_id string XSec ID

    - [in] – fract double Curve parameter value (range: 0 - 1)

  Return type:

    `vec3d`

  Returns:

    vec3d Tangent vector

openvsp.vsp.ConvertEtatoU(geom_id, eta)

  Convert eta wing coordinate to u coordinate.

      # Add Wing Geom
      geom_id = AddGeom( "WING", "" )

      surf_indx = 0

      eta= 0.25

      u = ConvertEtatoU( geom_id, eta )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – eta double Eta (0 - 1) wing spanwise coordinate

    - [out] – u_out double U (0 - 1) surface coordinate

openvsp.vsp.ConvertLMNtoRST(geom_id, surf_indx, l, m, n)

  Convert LMN volumetric coordinates to RST coordinates.

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      surf_indx = 0

      l = 0.12
      m = 0.34
      n = 0.56

      r_out, s_out, t_out = ConvertLMNtoRST( geom_id, surf_indx, l, m, n )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – surf_indx int Main surface index from the parent Geom

    - [in] – l double L (0 - 1) linear volume coordinate

    - [in] – m double M (0 - 1) linear volume coordinate

    - [in] – n double N (0 - 1) linear volume coordinate

    - [out] – r_out double R (0 - 1) volume coordinate

    - [out] – s_out double S (0 - 1) volume coordinate

    - [out] – t_out double T (0 - 1) volume coordinate

openvsp.vsp.ConvertLMNtoRSTVec(geom_id, surf_indx, l_vec, m_vec, n_vec)

  Convert vector of LMN volumetric coordinates to RST coordinates.

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      n = 5

      lvec = [0]*n
      mvec = [0]*n
      nvec = [0]*n

      for i in range(n):

          lvec[i] = (i+1)*1.0/(n+1)
          mvec[i] = (n-i)*1.0/(n+1)
          nvec[i] = (i+1)*1.0/(n+1)

      rvec, svec, tvec = ConvertLMNtoRSTVec( geom_id, 0, lvec, mvec, nvec )

  See also: ConvertRSTtoLMNVec, ConvertRSTtoLMN, ConvertLMNtoRST :param [in]: geom_id string Parent Geom ID :param [in]: surf_indx int Main surface index from the parent Geom :param [in]: l_vec vector<double> Input vector of L (0 - 1) linear volumetric coordinate :param [in]: m_vec vector<double> Input vector of M (0 - 1) linear volumetric coordinate :param [in]: n_vec vector<double> Input vector of N (0 - 1) linear volumetric coordinate :param [out]: r_out_vec vector<double> Output vector of R (0 - 1) volumetric coordinate :param [out]: s_out_vec vector<double> Output vector of S (0 - 1) volumetric coordinate :param [out]: t_out_vec vector<double> Output vector of T (0 - 1) volumetric coordinate

openvsp.vsp.ConvertLtoR(geom_id, surf_indx, l)

  Convert L volumetric coordinate to R coordinate.

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      surf_indx = 0

      l = 0.12

      r_out = ConvertLtoR( geom_id, surf_indx, l )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – surf_indx int Main surface index from the parent Geom

    - [in] – l double L (0 - 1) volume coordinate

    - [out] – r_out double R (0 - 1) linear volume coordinate

openvsp.vsp.ConvertRSTtoLMN(geom_id, surf_indx, r, s, t)

  Convert RST volumetric coordinates to LMN coordinates.

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      surf_indx = 0

      r = 0.12
      s = 0.68
      t = 0.56

      l_out, m_out, n_out = ConvertRSTtoLMN( geom_id, surf_indx, r, s, t )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – surf_indx int Main surface index from the parent Geom

    - [in] – r double R (0 - 1) volume coordinate

    - [in] – s double S (0 - 1) volume coordinate

    - [in] – t double T (0 - 1) volume coordinate

    - [out] – l_out double L (0 - 1) linear volume coordinate

    - [out] – m_out double M (0 - 1) linear volume coordinate

    - [out] – n_out double N (0 - 1) linear volume coordinate

openvsp.vsp.ConvertRSTtoLMNVec(geom_id, surf_indx, r_vec, s_vec, t_vec)

  Convert vector of RST volumetric coordinates to LMN coordinates.

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      n = 5

      rvec = [0]*n
      svec = [0]*n
      tvec = [0]*n

      for i in range(n):

          rvec[i] = (i+1)*1.0/(n+1)
          svec[i] = (n-i)*1.0/(n+1)
          tvec[i] = (i+1)*1.0/(n+1)

      lvec, mvec, nvec = ConvertRSTtoLMNVec( geom_id, 0, rvec, svec, tvec )

  See also: ConvertLMNtoRSTVec, ConvertRSTtoLMN, ConvertLMNtoRST :param [in]: geom_id string Parent Geom ID :param [in]: surf_indx int Main surface index from the parent Geom :param [in]: r_vec vector<double> Input vector of R (0 - 1) volumetric coordinate :param [in]: s_vec vector<double> Input vector of S (0 - 1) volumetric coordinate :param [in]: t_vec vector<double> Input vector of T (0 - 1) volumetric coordinate :param [out]: l_out_vec vector<double> Output vector of L (0 - 1) linear volumetric coordinate :param [out]: m_out_vec vector<double> Output vector of M (0 - 1) linear volumetric coordinate :param [out]: n_out_vec vector<double> Output vector of N (0 - 1) linear volumetric coordinate

openvsp.vsp.ConvertRtoL(geom_id, surf_indx, r)

  Convert R volumetric coordinate to L coordinate.

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      surf_indx = 0

      r = 0.12

      l_out = ConvertRtoL( geom_id, surf_indx, r )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – surf_indx int Main surface index from the parent Geom

    - [in] – r double R (0 - 1) volume coordinate

    - [out] – l_out double L (0 - 1) linear volume coordinate

openvsp.vsp.ConvertUtoEta(geom_id, u)

  Convert U coordinate to eta wing coordinate.

      # Add Wing Geom
      geom_id = AddGeom( "WING", "" )

      surf_indx = 0

      u = 0.25

      eta_out = ConvertUtoEta( geom_id, u )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – u double U (0 - 1) surface coordinate

    - [out] – eta_out double Eta (0 - 1) wing spanwise coordinate

openvsp.vsp.ConvertXSecToEdit(geom_id, indx=0)

  Convert any XSec type into an EditCurveXSec. This function will work for BOR Geoms, in which case the input XSec index is ignored.

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      ChangeXSecShape( xsec_surf, 1, XS_ROUNDED_RECTANGLE )

      # Convert Rounded Rectangle to Edit Curve type XSec
      ConvertXSecToEdit( sid, 1 )

      # Identify XSec 1
      xsec_1 = GetXSec( xsec_surf, 1 )

      # Get the control points for the default shape
      xsec1_pts = GetEditXSecCtrlVec( xsec_1, True ) # The returned control points will not be scaled by width and height

  Parameters:

    - [in] – geom_id string Geom ID

    - [in] – indx int XSec index

openvsp.vsp.CopyAttribute(attrID)

  Copy an attribute to the clipboard by attributeID

      ##==== Attribute: CopyAttribute  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      AttrName = 'Example_String_Attr'
      StringValue = 'Example_String_Attr_DataVal'
      AttrID = AddAttributeString( CollID, AttrName, StringValue )
      CopyError = CopyAttribute( AttrID )
      if not CopyError:
          print("Successfully copied Attribute")
      else:
          print("CopyAttribute Error!")

  Parameters:

    [in] – attrID string ID of attribute to be copied

openvsp.vsp.CopyGeomToClipboard(geom_id)

  Copy Geom from current location and store on clipboard

      #==== Add Pod Geometries ====//
      pid1 = AddGeom( "POD", "" )
      pid2 = AddGeom( "POD", "" )

      CopyGeomToClipboard( pid1 )

      PasteGeomClipboard( pid2 ) # Paste Pod 1 as child of Pod 2

      geom_ids = FindGeoms()

      if  len(geom_ids) != 3 : print( "---> Error: API Copy/Paste Geom  " )

  See also: PasteGeomClipboard :param [in]: geom_id string Geom ID

openvsp.vsp.CopyPasteSet(copyIndex, pasteIndex)

  Copies all the states of a geom set and pastes them into a specific set based on passed in indexs

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE", "" )

      #set fuseid's state for set 3 to true
      SetSetFlag( fuseid, 3, True )

      #Copy set 3 and Paste into set 4
      CopyPasteSet( 3, 4 )

      #get fuseid's state for set 4
      flag_value = GetSetFlag( fuseid, 4 )

      if  flag_value != True: print( "---> Error: API CopyPasteSet " )

  Parameters:

    - [in] – copyIndex int Copy Index

    - [in] – pasteIndex int Paste Index

openvsp.vsp.CopyXSec(geom_id, index)

  Copy a cross-section from the specified geometry and maintain it in memory

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Copy XSec To Clipboard
      CopyXSec( sid, 1 )

      # Paste To XSec 3
      PasteXSec( sid, 3 )

  See also: PasteXSec :param [in]: geom_id string Geom ID :param [in]: index int XSec index

openvsp.vsp.CreateAndAddBogie(gear_id)

  Create a new Bogie and add it to the end of the Bogie list of the specified GearGeom. A GearGeom’s landing gear is described by its list of Bogies. Each Bogie is a ParmContainer, so once you have the returned Bogie ID you can query and set its Parms with the normal Parm API functions.

      gear_id = AddGeom( "GEAR", "" )             # Add a landing gear Geom

      bogie_id = CreateAndAddBogie( gear_id )     # Create and add a Bogie

      # Bogies are ParmContainers -- work with their Parms once you have the ID.
      SetParmVal( bogie_id, "NumAcross", "Bogie", 2 )    # Two wheels across
      SetParmVal( bogie_id, "NumTandem", "Bogie", 2 )    # Two wheels in tandem

  See also: GetAllBogies, GetNumBogies, DelBogie, DelAllBogies :param [in]: gear_id string GearGeom Geom ID :rtype: string :return: string ParmContainer ID for the newly added Bogie

openvsp.vsp.CreateAndAddMode(name, normal_set, degen_set)

  Create a Mode – a combination of Sets and Variable Presets

      # Illustrating use of Modes requires substantial setup of the model including components, sets, and variable presets.
      #
      # Setup boiler plate.
      pod1 = AddGeom( "POD", "" )
      wing = AddGeom( "WING", pod1 )

      SetParmVal( wing, "Trans_Attach_Flag", "Attach", ATTACH_TRANS_LMN )
      SetParmVal( wing, "L_Attach_Location", "Attach", 0.35 )

      SetSetName( SET_FIRST_USER, "NonLifting" )
      SetSetName( SET_FIRST_USER + 1, "Lifting" )

      SetSetFlag( pod1, SET_FIRST_USER, True )
      SetSetFlag( wing, SET_FIRST_USER + 1, True )

      gid = AddVarPresetGroup( "Tess" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )
      AddVarPresetParm( gid, p1 )

      p2 = FindParm( pod1, "Tess_W", "Shape" )
      AddVarPresetParm( gid, p2 )

      sid = AddVarPresetSetting( gid, "Default" )
      SaveVarPresetParmVals( gid, sid )

      sid1 = AddVarPresetSetting( gid, "Coarse" )
      SetVarPresetParmVal( gid, sid1, p1, 3 )
      SetVarPresetParmVal( gid, sid1, p2, 5 )

      sid2 = AddVarPresetSetting( gid, "Fine" )
      SetVarPresetParmVal( gid, sid, p1, 35 )
      SetVarPresetParmVal( gid, sid, p2, 21 )

      gid2 = AddVarPresetGroup( "Design" )

      p3 = FindParm( pod1, "Length", "Design" )
      AddVarPresetParm( gid2, p3 )

      p4 = FindParm( pod1, "FineRatio", "Design" )
      AddVarPresetParm( gid2, p4 )

      sid3 = AddVarPresetSetting( gid2, "Normal" )
      SaveVarPresetParmVals( gid2, sid3 )

      sid4 = AddVarPresetSetting( gid2, "ShortFat" )
      SetVarPresetParmVal( gid2, sid4, p3, 3.0 )
      SetVarPresetParmVal( gid2, sid4, p4, 5.0 )

      sid5 = AddVarPresetSetting( gid2, "LongThin" )
      SetVarPresetParmVal( gid2, sid5, p3, 20.0 )
      SetVarPresetParmVal( gid2, sid5, p4, 35.0 )

      # End of setup boiler plate.

      mid1 = CreateAndAddMode( "FatWetAreas", SET_ALL, SET_NONE )
      ModeAddGroupSetting( mid1, gid, sid1 )
      ModeAddGroupSetting( mid1, gid2, sid4 )

      mid2 = CreateAndAddMode( "ThinAero", SET_FIRST_USER, SET_FIRST_USER + 1 )
      ModeAddGroupSetting( mid2, gid, sid2 )
      ModeAddGroupSetting( mid1, gid2, sid5 )

      ApplyModeSettings( mid2 )
      Update()

  Parameters:

    - [in] – name string Name for new Mode

    - [in] – normal_set int Normal set for Mode

    - [in] – degen_set int Degen set for Mode

  Return type:

    string

  Returns:

    string Mode ID for new Mode

openvsp.vsp.CreateGeomResults(geom_id, name)

  Create a new result for a Geom

      #==== Test Comp Geom ====//
      gid1 = AddGeom( "POD", "" )

      mesh_id = ComputeCompGeom( 0, False, 0 )

      #==== Test Comp Geom Mesh Results ====//
      mesh_geom_res_id = CreateGeomResults( mesh_id, "Comp_Mesh" )

      int_arr = GetIntResults( mesh_geom_res_id, "Num_Tris" )

      if  int_arr[0] < 4 : print( "---> Error: API CreateGeomResults" )

  Parameters:

    - [in] – geom_id string Geom ID

    - [in] – name string Result name

  Return type:

    string

  Returns:

    string Result ID

openvsp.vsp.CreateVSPAEROControlSurfaceGroup()

  Add a new VSPAERO control surface group using the default naming convention. The control surface group will not contain any control surfaces until they are added.

      wid = AddGeom( "WING", "" )                             # Add Wing

      aileron_id = AddSubSurf( wid, SS_CONTROL )                      # Add Control Surface Sub-Surface

      group_index = CreateVSPAEROControlSurfaceGroup() # Empty control surface group

      num_group = GetNumControlSurfaceGroups()

      if  num_group != 1 : print( "Error: CreateVSPAEROControlSurfaceGroup" )

  See also: AddSelectedToCSGroup :rtype: int :return: int Index of the new VSPAERO control surface group

openvsp.vsp.CutAttribute(attrID)

  Cut an attribute from its collection to the clipboard by attributeID

      ##==== Attribute: CopyAttribute  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      AttrName = 'Example_String_Attr'
      StringValue = 'Example_String_Attr_DataVal'
      AttrID = AddAttributeString( CollID, AttrName, StringValue )
      CutAttribute( AttrID )

      NewCollID = GetChildCollection( "_AttrWMGroup" )
      NewAttrIDs = PasteAttribute( NewCollID )

      MatchIDs = NewAttrIDs[0] == AttrID
      Attr_Cut_Check = AttrID not in FindAttributesInCollection( CollID )
      if MatchIDs and Attr_Cut_Check:
          print("Successfully cut Attribute")
      else:
          print("CutAttribute Error!")

  Parameters:

    [in] – attrID string ID of attribute to be copied

openvsp.vsp.CutGeomToClipboard(geom_id)

  Cut Geom from current location and store on clipboard

      #==== Add Pod Geometries ====//
      pid1 = AddGeom( "POD", "" )
      pid2 = AddGeom( "POD", "" )

      CutGeomToClipboard( pid1 )

      PasteGeomClipboard( pid2 ) # Paste Pod 1 as child of Pod 2

      geom_ids = FindGeoms()

      if  len(geom_ids) != 2 : print( "---> Error: API Cut/Paste Geom  " )

  See also: PasteGeomClipboard :param [in]: geom_id string Geom ID

openvsp.vsp.CutXSec(geom_id, index)

  Cut a cross-section from the specified geometry and maintain it in memory

      fid = AddGeom( "FUSELAGE", "" )             # Add Fuselage

      #==== Insert, Cut, Paste Example ====//
      InsertXSec( fid, 1, XS_ROUNDED_RECTANGLE )         # Insert A Cross-Section

      CopyXSec( fid, 2 )                                 # Copy Just Created XSec To Clipboard

      PasteXSec( fid, 1 )                                # Paste Clipboard

      CutXSec( fid, 2 )                                  # Cut Created XSec

  See also: PasteXSec :param [in]: geom_id string Geom ID :param [in]: index int XSec 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 = 2

  Double data type

openvsp.vsp.DOUBLE_MATRIX_DATA = 6

  Double matrix 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(index)

  Delete an advanced link specified by index

      pod = AddGeom( "POD", "" )
      length = FindParm( pod, "Length", "Design" )
      x_pos = GetParm( pod, "X_Rel_Location", "XForm" )

      AddAdvLink( "ExampleLink" )
      indx = GetLinkIndex( "ExampleLink" )
      AddAdvLinkInput( indx, length, "len" )
      AddAdvLinkOutput( indx, x_pos, "x" )

      SetAdvLinkCode( indx, "x = 10.0 - len;" )

      BuildAdvLinkScript( indx )

      DelAdvLink( indx )

      link_array = GetAdvLinkNames()

      # Should print nothing.
      for n in range(len(link_array) ):

          print( link_array[n] )

  Parameters:

    [in] – index int Index for advanced link

openvsp.vsp.DelAdvLinkInput(index, var_name)

  Delete an input variable from an advanced link

      pod = AddGeom( "POD", "" )
      length = FindParm( pod, "Length", "Design" )
      x_pos = GetParm( pod, "X_Rel_Location", "XForm" )
      y_pos = GetParm( pod, "Y_Rel_Location", "XForm" )

      AddAdvLink( "ExampleLink" )
      indx = GetLinkIndex( "ExampleLink" )
      AddAdvLinkInput( indx, length, "len" )
      AddAdvLinkOutput( indx, x_pos, "x" )
      AddAdvLinkInput( indx, y_pos, "y" )

      SetAdvLinkCode( indx, "x = 10.0 - len;" )

      BuildAdvLinkScript( indx )

      DelAdvLinkInput( indx, "y" )

      BuildAdvLinkScript( indx )

  Parameters:

    - [in] – index int Advanced link index

    - [in] – var_name string Name for advanced link input variable to delete

openvsp.vsp.DelAdvLinkOutput(index, var_name)

  Delete an output variable from an advanced link

      pod = AddGeom( "POD", "" )
      length = FindParm( pod, "Length", "Design" )
      x_pos = GetParm( pod, "X_Rel_Location", "XForm" )
      y_pos = GetParm( pod, "Y_Rel_Location", "XForm" )

      AddAdvLink( "ExampleLink" )
      indx = GetLinkIndex( "ExampleLink" )
      AddAdvLinkInput( indx, length, "len" )
      AddAdvLinkOutput( indx, x_pos, "x" )
      AddAdvLinkOutput( indx, y_pos, "y" )

      SetAdvLinkCode( indx, "x = 10.0 - len;" )

      BuildAdvLinkScript( indx )

      DelAdvLinkOutput( indx, "y" )

      BuildAdvLinkScript( indx )

  Parameters:

    - [in] – index int Advanced link index

    - [in] – var_name string Name for advanced link output variable to delete

openvsp.vsp.DelAllAdvLinks()

  Delete all advanced links

      pod = AddGeom( "POD", "" )
      length = FindParm( pod, "Length", "Design" )
      x_pos = GetParm( pod, "X_Rel_Location", "XForm" )

      AddAdvLink( "ExampleLink" )
      indx = GetLinkIndex( "ExampleLink" )
      AddAdvLinkInput( indx, length, "len" )
      AddAdvLinkOutput( indx, x_pos, "x" )

      SetAdvLinkCode( indx, "x = 10.0 - len;" )

      BuildAdvLinkScript( indx )

      DelAllAdvLinks()

      link_array = GetAdvLinkNames()

      # Should print nothing.
      for n in range( len(link_array) ):

          print( link_array[n] )

openvsp.vsp.DelAllBackground3Ds()

  Delete all Background3Ds in model

      # Add Background3D
      AddBackground3D()
      AddBackground3D()
      AddBackground3D()

      DelAllBackground3Ds()

      nbg = GetNumBackground3Ds()

      if nbg != 0 :
          print( "ERROR: DelAllBackground3Ds" )

openvsp.vsp.DelAllBogies(gear_id)

  Delete all Bogies from the specified GearGeom.

      gear_id = AddGeom( "GEAR", "" )

      CreateAndAddBogie( gear_id )
      CreateAndAddBogie( gear_id )

      DelAllBogies( gear_id )                            # GetNumBogies( gear_id ) == 0

  See also: CreateAndAddBogie, DelBogie :param [in]: gear_id string GearGeom Geom ID

openvsp.vsp.DelAllFeaPolySparPt(pspar_id)

  Delete all points from an FEA Poly Spar.

      wing_id = AddGeom( "WING" )

      struct_ind = AddFeaStruct( wing_id )

      pspar_id = AddFeaPart( wing_id, struct_ind, FEA_POLY_SPAR )

      AddFeaPolySparPt( pspar_id )
      AddFeaPolySparPt( pspar_id )

      DelAllFeaPolySparPt( pspar_id )

      if GetFeaPolySparNumPt( pspar_id ) != 0:
          print( "Error: DelAllFeaPolySparPt" )

  See also: DelFeaPolySparPt, AddFeaPolySparPt, GetFeaPolySparNumPt :param [in]: pspar_id string FEA Poly Spar part ID

openvsp.vsp.DelAllModes()

  Delete all modes from the model.

      # Illustrating use of Modes requires substantial setup of the model including components, sets, and variable presets.
      #
      # Setup boiler plate.
      pod1 = AddGeom( "POD", "" )
      wing = AddGeom( "WING", pod1 )

      SetParmVal( wing, "Trans_Attach_Flag", "Attach", ATTACH_TRANS_LMN )
      SetParmVal( wing, "L_Attach_Location", "Attach", 0.35 )

      SetSetName( SET_FIRST_USER, "NonLifting" )
      SetSetName( SET_FIRST_USER + 1, "Lifting" )

      SetSetFlag( pod1, SET_FIRST_USER, True )
      SetSetFlag( wing, SET_FIRST_USER + 1, True )

      gid = AddVarPresetGroup( "Tess" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )
      AddVarPresetParm( gid, p1 )

      p2 = FindParm( pod1, "Tess_W", "Shape" )
      AddVarPresetParm( gid, p2 )

      sid = AddVarPresetSetting( gid, "Default" )
      SaveVarPresetParmVals( gid, sid )

      sid1 = AddVarPresetSetting( gid, "Coarse" )
      SetVarPresetParmVal( gid, sid1, p1, 3 )
      SetVarPresetParmVal( gid, sid1, p2, 5 )

      sid2 = AddVarPresetSetting( gid, "Fine" )
      SetVarPresetParmVal( gid, sid, p1, 35 )
      SetVarPresetParmVal( gid, sid, p2, 21 )

      gid2 = AddVarPresetGroup( "Design" )

      p3 = FindParm( pod1, "Length", "Design" )
      AddVarPresetParm( gid2, p3 )

      p4 = FindParm( pod1, "FineRatio", "Design" )
      AddVarPresetParm( gid2, p4 )

      sid3 = AddVarPresetSetting( gid2, "Normal" )
      SaveVarPresetParmVals( gid2, sid3 )

      sid4 = AddVarPresetSetting( gid2, "ShortFat" )
      SetVarPresetParmVal( gid2, sid4, p3, 3.0 )
      SetVarPresetParmVal( gid2, sid4, p4, 5.0 )

      sid5 = AddVarPresetSetting( gid2, "LongThin" )
      SetVarPresetParmVal( gid2, sid5, p3, 20.0 )
      SetVarPresetParmVal( gid2, sid5, p4, 35.0 )

      # End of setup boiler plate.

      mid1 = CreateAndAddMode( "FatWetAreas", SET_ALL, SET_NONE )
      ModeAddGroupSetting( mid1, gid, sid1 )
      ModeAddGroupSetting( mid1, gid2, sid4 )

      mid2 = CreateAndAddMode( "ThinAero", SET_FIRST_USER, SET_FIRST_USER + 1 )
      ModeAddGroupSetting( mid2, gid, sid2 )
      ModeAddGroupSetting( mid1, gid2, sid5 )

      ApplyModeSettings( mid2 )
      Update()

      DelAllModes()

openvsp.vsp.DelAllRoutingPt(routing_id)

  Delete all routing points from a RoutingGeom.

      pod1 = vsp.AddGeom('POD', '')

      pod2 = vsp.AddGeom('POD', '')
      ypod2 = vsp.GetParm(pod2, 'Y_Rel_Location', 'XForm')
      vsp.SetParmVal(ypod2, 2.0)

      routing_geom = vsp.AddGeom('ROUTING', '')

      rpt0 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u0 = vsp.GetParm( rpt0, 'U', 'RoutePt')
      vsp.SetParmVal(u0, 0.0)

      rpt1 = vsp.AddRoutingPt(routing_geom, pod2, 0)

      rpt2 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u2 = vsp.GetParm( rpt2, 'U', 'RoutePt')
      vsp.SetParmVal(u2, 1.0)

      vsp.DelAllRoutingPt( routing_geom )

  See also: AddRoutingPt, DelRoutingPt :param [in]: routing_id string RoutingGeom Geom ID

openvsp.vsp.DelBackground3D(id)

  Delete specific Background3D frommodel

      # Add Background3D
      AddBackground3D()
      bg_id = AddBackground3D()
      AddBackground3D()

      nbg = GetNumBackground3Ds()

      DelBackground3D( bg_id )

      if GetNumBackground3Ds() != nbg -1 :
          print( "ERROR: DelBackground3D" )

  Parameters:

    [in] – id string Background3D ID to delete

openvsp.vsp.DelBogie(gear_id, bogie_id)

  Delete the specified Bogie from the specified GearGeom.

      gear_id = AddGeom( "GEAR", "" )

      bogie_id = CreateAndAddBogie( gear_id )

      DelBogie( gear_id, bogie_id )

  See also: CreateAndAddBogie, DelAllBogies :param [in]: gear_id string GearGeom Geom ID :param [in]: bogie_id string Bogie ParmContainer ID

openvsp.vsp.DelFeaBC(fea_struct_id, bc_id)

  Delete an FEA BC from a Structure

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      struct_id = GetFeaStructID( pod_id, struct_ind );

      #==== Add BC ====//
      bc_id = AddFeaBC( struct_id, FEA_BC_STRUCTURE )

      DelFeaBC( struct_id, bc_id )

  See also: FEA_BC_TYPE :param [in]: fea_struct_id string FEA Structure ID :param [in]: bc_id int FEA BC ID

openvsp.vsp.DelFeaPolySparPt(pspar_id, index)

  Delete the point at the given index from an FEA Poly Spar.

      wing_id = AddGeom( "WING" )

      struct_ind = AddFeaStruct( wing_id )

      pspar_id = AddFeaPart( wing_id, struct_ind, FEA_POLY_SPAR )

      AddFeaPolySparPt( pspar_id )
      AddFeaPolySparPt( pspar_id )

      # Delete the point at index 2 (leaving 3 points)
      DelFeaPolySparPt( pspar_id, 2 )

      if GetFeaPolySparNumPt( pspar_id ) != 3:
          print( "Error: DelFeaPolySparPt" )

  See also: DelAllFeaPolySparPt, AddFeaPolySparPt, GetFeaPolySparNumPt :param [in]: pspar_id string FEA Poly Spar part ID :param [in]: index int Index of the point to delete

openvsp.vsp.DelMode(mid)

  Delete a mode from the model.

      # Illustrating use of Modes requires substantial setup of the model including components, sets, and variable presets.
      #
      # Setup boiler plate.
      pod1 = AddGeom( "POD", "" )
      wing = AddGeom( "WING", pod1 )

      SetParmVal( wing, "Trans_Attach_Flag", "Attach", ATTACH_TRANS_LMN )
      SetParmVal( wing, "L_Attach_Location", "Attach", 0.35 )

      SetSetName( SET_FIRST_USER, "NonLifting" )
      SetSetName( SET_FIRST_USER + 1, "Lifting" )

      SetSetFlag( pod1, SET_FIRST_USER, True )
      SetSetFlag( wing, SET_FIRST_USER + 1, True )

      gid = AddVarPresetGroup( "Tess" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )
      AddVarPresetParm( gid, p1 )

      p2 = FindParm( pod1, "Tess_W", "Shape" )
      AddVarPresetParm( gid, p2 )

      sid = AddVarPresetSetting( gid, "Default" )
      SaveVarPresetParmVals( gid, sid )

      sid1 = AddVarPresetSetting( gid, "Coarse" )
      SetVarPresetParmVal( gid, sid1, p1, 3 )
      SetVarPresetParmVal( gid, sid1, p2, 5 )

      sid2 = AddVarPresetSetting( gid, "Fine" )
      SetVarPresetParmVal( gid, sid, p1, 35 )
      SetVarPresetParmVal( gid, sid, p2, 21 )

      gid2 = AddVarPresetGroup( "Design" )

      p3 = FindParm( pod1, "Length", "Design" )
      AddVarPresetParm( gid2, p3 )

      p4 = FindParm( pod1, "FineRatio", "Design" )
      AddVarPresetParm( gid2, p4 )

      sid3 = AddVarPresetSetting( gid2, "Normal" )
      SaveVarPresetParmVals( gid2, sid3 )

      sid4 = AddVarPresetSetting( gid2, "ShortFat" )
      SetVarPresetParmVal( gid2, sid4, p3, 3.0 )
      SetVarPresetParmVal( gid2, sid4, p4, 5.0 )

      sid5 = AddVarPresetSetting( gid2, "LongThin" )
      SetVarPresetParmVal( gid2, sid5, p3, 20.0 )
      SetVarPresetParmVal( gid2, sid5, p4, 35.0 )

      # End of setup boiler plate.

      mid1 = CreateAndAddMode( "FatWetAreas", SET_ALL, SET_NONE )
      ModeAddGroupSetting( mid1, gid, sid1 )
      ModeAddGroupSetting( mid1, gid2, sid4 )

      mid2 = CreateAndAddMode( "ThinAero", SET_FIRST_USER, SET_FIRST_USER + 1 )
      ModeAddGroupSetting( mid2, gid, sid2 )
      ModeAddGroupSetting( mid1, gid2, sid5 )

      ApplyModeSettings( mid2 )
      Update()

      DelMode( mid1 )

  Parameters:

    [in] – mid string Mode ID of mode to delete

openvsp.vsp.DelProbe(id)

  Delete a specific Probe from the Measure Tool

      pid1 = AddGeom( "POD", "" )

      SetParmVal( pid1, "Y_Rel_Location", "XForm", 2.0 )

      probe_id_1 = AddProbe( pid1, 0, 0.5, 0.8, "Probe 1" )
      probe_id_2 = AddProbe( pid1, 0, 0.2, 0.3, "Probe 2" )

      DelProbe( probe_id_1 )

      probe_array = GetAllProbes()

      if  len(probe_array) != 1 : print( "Error: DelProbe" )

  Parameters:

    [in] – id string Probe ID

openvsp.vsp.DelRoutingPt(routing_id, index)

  Delete a specified routing point from a RoutingGeom.

      pod1 = vsp.AddGeom('POD', '')

      pod2 = vsp.AddGeom('POD', '')
      ypod2 = vsp.GetParm(pod2, 'Y_Rel_Location', 'XForm')
      vsp.SetParmVal(ypod2, 2.0)

      routing_geom = vsp.AddGeom('ROUTING', '')

      rpt0 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u0 = vsp.GetParm( rpt0, 'U', 'RoutePt')
      vsp.SetParmVal(u0, 0.0)

      rpt1 = vsp.AddRoutingPt(routing_geom, pod2, 0)

      rpt2 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u2 = vsp.GetParm( rpt2, 'U', 'RoutePt')
      vsp.SetParmVal(u2, 1.0)

      vsp.DelRoutingPt( routing_geom, 1 )

  See also: AddRoutingPt, DelAllRoutingPt :param [in]: routing_id string RoutingGeom Geom ID :param [in]: index int Index of routing point to delete

openvsp.vsp.DelRuler(id)

  Delete a particular Ruler from the Measure Tool

      pid1 = AddGeom( "POD", "" )

      SetParmVal( pid1, "Y_Rel_Location", "XForm", 2.0 )

      pid2 = AddGeom( "POD", "" )

      SetParmVal( pid2, "Z_Rel_Location", "XForm", 4.0 )

      rid1 = AddRuler( pid1, 1, 0.2, 0.3, pid2, 0, 0.2, 0.3, "Ruler 1" )

      rid2 = AddRuler( pid1, 0, 0.4, 0.6, pid1, 1, 0.8, 0.9, "Ruler 2" )

      ruler_array = GetAllRulers()

      DelRuler( ruler_array[0] )

  Parameters:

    [in] – id string Ruler ID

openvsp.vsp.DeleteAllCFDSources()

  Delete all CFD Mesh sources for all Geoms

      #==== Add Pod Geom ====//
      pid = AddGeom( "POD", "" )

      AddCFDSource( POINT_SOURCE, pid, 0, 0.25, 2.0, 0.5, 0.5 )      # Add A Point Source

      DeleteAllCFDSources()

openvsp.vsp.DeleteAllDesignVars()

  Delete all design variables

openvsp.vsp.DeleteAllGeometryAnalyses()

  Delete all Geometry Analysis cases from the Geometry Analysis Manager.

      ##==== GeometryAnalysis: Delete all cases ====##
      ga_id_1 = AddGeometryAnalysis()
      ga_id_2 = AddGeometryAnalysis()
      DeleteAllGeometryAnalyses()
      ga_ids = GetAllGeometryAnalysesIDVec()
      print( "Number of Geometry Analyses after delete: ", len( ga_ids ) )

  See also: AddGeometryAnalysis, DeleteGeometryAnalysis, GetAllGeometryAnalysesIDVec

openvsp.vsp.DeleteAllProbes()

  Delete all Probes from the Measure Tool

      pid1 = AddGeom( "POD", "" )

      SetParmVal( pid1, "Y_Rel_Location", "XForm", 2.0 )

      probe_id_1 = AddProbe( pid1, 0, 0.5, 0.8, "Probe 1" )
      probe_id_2 = AddProbe( pid1, 0, 0.2, 0.3, "Probe 2" )

      DeleteAllProbes()

      probe_array = GetAllProbes()

      if  len(probe_array) != 0 : print( "Error: DeleteAllProbes" )

openvsp.vsp.DeleteAllResults()

  Delete all results

      #==== Test Comp Geom ====//
      gid1 = AddGeom( "POD", "" )

      mesh_id = ComputeCompGeom( 0, False, 0 )

      #==== Test Comp Geom Mesh Results ====//
      mesh_geom_res_id = CreateGeomResults( mesh_id, "Comp_Mesh" )

      DeleteAllResults()

      if ( GetNumResults( "Comp_Mesh" ) != 0 ): print( "---> Error: API DeleteAllResults" )

openvsp.vsp.DeleteAllRulers()

  Delete all Rulers from the Measure Tool

      pid1 = AddGeom( "POD", "" )

      SetParmVal( pid1, "Y_Rel_Location", "XForm", 2.0 )

      pid2 = AddGeom( "POD", "" )

      SetParmVal( pid2, "Z_Rel_Location", "XForm", 4.0 )

      rid1 = AddRuler( pid1, 1, 0.2, 0.3, pid2, 0, 0.2, 0.3, "Ruler 1" )

      rid2 = AddRuler( pid1, 0, 0.4, 0.6, pid1, 1, 0.8, 0.9, "Ruler 2" )

      DeleteAllRulers()

openvsp.vsp.DeleteAllUserParm()

  Get the user parm container ID

      DeleteAllUserParm()

openvsp.vsp.DeleteAttribute(attrID)

  Delete attribute by attribute ID

      ##==== Attribute: DeleteAttribute  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      InitVal = "This_Attribute_Will_Be_Deleted"
      AttrID = AddAttributeString( CollID, "TestStringAttr", InitVal )

      AttrIDs = FindAllAttributes()
      AttrAdded = AttrID in AttrIDs

      DeleteAttribute( AttrID )
      NewAttrIDs = FindAllAttributes()
      AttrDeleted = AttrID not in NewAttrIDs

      if AttrAdded and AttrDeleted:
          print( "Attribute successfully deleted" )
      else:
          print( "DeleteAttribute error!" )

  Parameters:

    [in] – attrID string of attribute ID

openvsp.vsp.DeleteExcrescence(index)

  Delete an Excresence from the Parasite Drag Tool

      AddExcrescence( "Miscellaneous", EXCRESCENCE_COUNT, 8.5 )

      AddExcrescence( "Cowl Boattail", EXCRESCENCE_CD, 0.0003 )

      AddExcrescence( "Percentage Example", EXCRESCENCE_PERCENT_GEOM, 5 )

      DeleteExcrescence( 2 ) # Last Index

  Parameters:

    [in] – index int Index of the Excressence to delete

openvsp.vsp.DeleteFeaPart(geom_id, fea_struct_ind, part_id)

  Delete an FEA Part from a Structure

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      #==== Add Bulkead ====//
      bulkhead_id = AddFeaPart( pod_id, struct_ind, FEA_SLICE )

      #==== Add Fixed Point ====//
      fixed_id = AddFeaPart( pod_id, struct_ind, FEA_FIX_POINT )

      #==== Delete Bulkead ====//
      DeleteFeaPart( pod_id, struct_ind, bulkhead_id )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – fea_struct_ind int FEA Structure index

    - [in] – part_id string FEA Part ID

openvsp.vsp.DeleteFeaStruct(geom_id, fea_struct_ind)

  Delete an FEA Structure and all FEA Parts and FEA SubSurfaces associated with it

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind_1 = AddFeaStruct( pod_id )

      struct_ind_2 = AddFeaStruct( pod_id )

      DeleteFeaStruct( pod_id, struct_ind_1 )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – fea_struct_ind int FEA Structure index

openvsp.vsp.DeleteFeaSubSurf(geom_id, fea_struct_ind, ss_id)

  Delete an FEA SubSurface from a Structure

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      #==== Add LineArray ====//
      line_array_id = AddFeaSubSurf( pod_id, struct_ind, SS_LINE_ARRAY )

      #==== Add Rectangle ====//
      rect_id = AddFeaSubSurf( pod_id, struct_ind, SS_RECTANGLE )

      #==== Delete LineArray ====//
      DeleteFeaSubSurf( pod_id, struct_ind, line_array_id )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – fea_struct_ind int FEA Structure index

    - [in] – ss_id string FEA SubSurface ID

openvsp.vsp.DeleteGeom(geom_id)

  Delete a particular Geom

      #==== Add Wing Geometry ====//
      wing_id = AddGeom( "WING" )

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      DeleteGeom( wing_id )

  Parameters:

    [in] – geom_id string Geom ID

openvsp.vsp.DeleteGeomVec(del_vec)

  Delete multiple Geoms

      #==== Add Pod Geometry ====//
      pid = AddGeom( "POD", "" )

      rid = ExecAnalysis( "CompGeom" )

      mesh_id_vec = GetStringResults( rid, "Mesh_GeomID" )

      DeleteGeomVec( mesh_id_vec )

  Parameters:

    [in] – del_vec vector<string> Vector of Geom IDs

openvsp.vsp.DeleteGeometryAnalysis(id)

  Delete a specific Geometry Analysis case from the Geometry Analysis Manager.

      ##==== GeometryAnalysis: Delete a specific case ====##
      ga_id = AddGeometryAnalysis()
      DeleteGeometryAnalysis( ga_id )

  See also: AddGeometryAnalysis, DeleteAllGeometryAnalyses, GetAllGeometryAnalysesIDVec :param [in]: id string ID of the Geometry Analysis case to delete

openvsp.vsp.DeleteResult(id)

  Delete a particular result

      #==== Test Comp Geom ====//
      gid1 = AddGeom( "POD", "" )

      mesh_id = ComputeCompGeom( 0, False, 0 )

      #==== Test Comp Geom Mesh Results ====//
      mesh_geom_res_id = CreateGeomResults( mesh_id, "Comp_Mesh" )

      DeleteResult( mesh_geom_res_id )

      if ( GetNumResults( "Comp_Mesh" ) != 0 ): print( "---> Error: API DeleteResult" )

  Parameters:

    [in] – id string Result ID

openvsp.vsp.DeleteSubSurf(*args)

  Overload 1:

  Delete the specified sub-surface

      wid = AddGeom( "WING", "" )                             # Add Wing

      ss_line_id = AddSubSurf( wid, SS_LINE )                      # Add Sub Surface Line
      ss_rec_id = AddSubSurf( wid, SS_RECTANGLE )                        # Add Sub Surface Rectangle

      print("Delete SS_Line\n")

      DeleteSubSurf( wid, ss_line_id )

      num_ss = GetNumSubSurf( wid )

      num_str = f"Number of SubSurfaces: {num_ss}\n"

      print( num_str )

  Parameters:

    - [in] – geom_id string Geom ID

    - [in] – sub_id string Sub-surface ID

  Overload 2:

  Delete the specified sub-surface

      wid = AddGeom( "WING", "" )                             # Add Wing

      ss_line_id = AddSubSurf( wid, SS_LINE )                      # Add Sub Surface Line
      ss_rec_id = AddSubSurf( wid, SS_RECTANGLE )                        # Add Sub Surface Rectangle

      print("Delete SS_Line\n")

      DeleteSubSurf( ss_line_id )

      num_ss = GetNumSubSurf( wid )

      num_str = f"Number of SubSurfaces: {num_ss}\n"

      print( num_str )

  Parameters:

    [in] – sub_id string Sub-surface ID

openvsp.vsp.DeleteUserParm(id)

  Get the user parm container ID

      n = GetNumPredefinedUserParms()
      id_arr = GetAllUserParms()

      if  len(id_arr) > n :
          DeleteUserParm( id_arr[n] )

openvsp.vsp.DeleteVarPresetGroup(group_id)

  Delete Variable Preset Group (and all contained settings)

      # Add Pod Geom
      pod1 = AddGeom( "POD", "" )

      gid = AddVarPresetGroup( "Tess" )

      sid = AddVarPresetSetting( gid, "Coarse" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )

      AddVarPresetParm( gid, p1 )

      DeleteVarPresetGroup( gid )

  Parameters:

    [in] – group_id string Var Preset Group ID

openvsp.vsp.DeleteVarPresetParm(group_id, parm_id)

  Delete Parm from Variable Preset Group

      # Add Pod Geom
      pod1 = AddGeom( "POD", "" )

      gid = AddVarPresetGroup( "Tess" )

      sid = AddVarPresetSetting( gid, "Coarse" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )

      AddVarPresetParm( gid, p1 )

      DeleteVarPresetParm( gid, p1 )

  Parameters:

    - [in] – group_id string Var Preset Group ID

    - [in] – parm_id string Var Parm ID

openvsp.vsp.DeleteVarPresetSetting(group_id, setting_id)

  Delete Variable Preset Setting

      # Add Pod Geom
      pod1 = AddGeom( "POD", "" )

      gid = AddVarPresetGroup( "Tess" )

      sid = AddVarPresetSetting( gid, "Coarse" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )

      AddVarPresetParm( gid, p1 )

      DeleteVarPresetSetting( gid, sid )

  Parameters:

    - [in] – group_id string Var Preset Group ID

    - [in] – setting_id string Var Preset Setting ID

openvsp.vsp.DemoteBORCSTLower(bor_id)

  Demote the CST for the lower airfoil surface of a BOR. The XSecCurve must be of type XS_CST_AIRFOIL See also: GetLowerCSTDegree :param [in]: bor_id string Body of revolution Geom ID

openvsp.vsp.DemoteBORCSTUpper(bor_id)

  Demote the CST for the upper airfoil surface of a BOR. The XSecCurve must be of type XS_CST_AIRFOIL See also: GetUpperCSTDegree :param [in]: bor_id string Body of revolution Geom ID

openvsp.vsp.DemoteCSTLower(xsec_id)

  Demote the CST for the lower airfoil surface. The XSec must be of type XS_CST_AIRFOIL See also: GetLowerCSTDegree :param [in]: xsec_id string XSec ID

openvsp.vsp.DemoteCSTUpper(xsec_id)

  Demote the CST for the upper airfoil surface. The XSec must be of type XS_CST_AIRFOIL See also: GetUpperCSTDegree :param [in]: xsec_id string XSec ID

openvsp.vsp.DisableStopGUIMenuItem()

  Disable Stop GUI Menu Item from the OpenVSP GUI.

  This reverses the operation of EnableStopGUIMenuItem.

      EnableStopGUIMenuItem()
      DisableStopGUIMenuItem()
      StartGUI()

  See also: EnableStopGUIMenuItem

class openvsp.vsp.DoubleVecVec(*args)

  Bases: `object`

  Proxy of C++ std::vector< std::vector< double > > class.

  append(DoubleVecVec self, DoubleVector x)
  assign(DoubleVecVec self, std: :vector< std::vector< double > >::size_type n, DoubleVector x)
  back(DoubleVecVec self) → DoubleVector
  begin(DoubleVecVec self) → std::vector< std::vector< double > >::iterator
  capacity(DoubleVecVec self) → std::vector< std::vector< double > >::size_type
  clear(DoubleVecVec self)
  empty(DoubleVecVec self) → bool
  end(DoubleVecVec self) → std::vector< std::vector< double > >::iterator
  erase(DoubleVecVec self, std: :vector< std::vector< double > >::iterator pos) → std::vector< std::vector< double > >::iterator
  erase(DoubleVecVec self, std: :vector< std::vector< double > >::iterator first, std: :vector< std::vector< double > >::iterator last) → std::vector< std::vector< double > >::iterator
  front(DoubleVecVec self) → DoubleVector
  get_allocator(DoubleVecVec self) → std::vector< std::vector< double > >::allocator_type
  insert(DoubleVecVec self, std: :vector< std::vector< double > >::iterator pos, DoubleVector x) → std::vector< std::vector< double > >::iterator
  insert(DoubleVecVec self, std: :vector< std::vector< double > >::iterator pos, std: :vector< std::vector< double > >::size_type n, DoubleVector x)
  iterator(DoubleVecVec self) → SwigPyIterator
  pop(DoubleVecVec self) → DoubleVector
  pop_back(DoubleVecVec self)
  push_back(DoubleVecVec self, DoubleVector x)
  rbegin(DoubleVecVec self) → std::vector< std::vector< double > >::reverse_iterator
  rend(DoubleVecVec self) → std::vector< std::vector< double > >::reverse_iterator
  reserve(DoubleVecVec self, std: :vector< std::vector< double > >::size_type n)
  resize(DoubleVecVec self, std: :vector< std::vector< double > >::size_type new_size)
  resize(DoubleVecVec self, std: :vector< std::vector< double > >::size_type new_size, DoubleVector x)
  size(DoubleVecVec self) → std::vector< std::vector< double > >::size_type
  swap(DoubleVecVec self, DoubleVecVec v)
  property thisown

    The membership flag

class openvsp.vsp.DoubleVector(*args)

  Bases: `object`

  Proxy of C++ std::vector< double > class.

  append(DoubleVector self, std: :vector< double >::value_type const & x)
  assign(DoubleVector self, std: :vector< double >::size_type n, std: :vector< double >::value_type const & x)
  back(DoubleVector self) → std::vector< double >::value_type const &
  begin(DoubleVector self) → std::vector< double >::iterator
  capacity(DoubleVector self) → std::vector< double >::size_type
  clear(DoubleVector self)
  empty(DoubleVector self) → bool
  end(DoubleVector self) → std::vector< double >::iterator
  erase(DoubleVector self, std: :vector< double >::iterator pos) → std::vector< double >::iterator
  erase(DoubleVector self, std: :vector< double >::iterator first, std: :vector< double >::iterator last) → std::vector< double >::iterator
  front(DoubleVector self) → std::vector< double >::value_type const &
  get_allocator(DoubleVector self) → std::vector< double >::allocator_type
  insert(DoubleVector self, std: :vector< double >::iterator pos, std: :vector< double >::value_type const & x) → std::vector< double >::iterator
  insert(DoubleVector self, std: :vector< double >::iterator pos, std: :vector< double >::size_type n, std: :vector< double >::value_type const & x)
  iterator(DoubleVector self) → SwigPyIterator
  pop(DoubleVector self) → std::vector< double >::value_type
  pop_back(DoubleVector self)
  push_back(DoubleVector self, std: :vector< double >::value_type const & x)
  rbegin(DoubleVector self) → std::vector< double >::reverse_iterator
  rend(DoubleVector self) → std::vector< double >::reverse_iterator
  reserve(DoubleVector self, std: :vector< double >::size_type n)
  resize(DoubleVector self, std: :vector< double >::size_type new_size)
  resize(DoubleVector self, std: :vector< double >::size_type new_size, std: :vector< double >::value_type const & x)
  size(DoubleVector self) → std::vector< double >::size_type
  swap(DoubleVector self, DoubleVector 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 = 13

  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 = 7

  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_FLOWTHROUGH_NEG_ONLY = 2

  Represent ONLY the integrated flowpath as flowthrough engine with negative flowpath.

openvsp.vsp.ENGINE_MODE_NUM_TYPES = 8

  Number of integrated flowpath representations.

openvsp.vsp.ENGINE_MODE_TO_FACE = 4

  Represent integrated flowpath to the face.

openvsp.vsp.ENGINE_MODE_TO_FACE_NEG = 5

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

openvsp.vsp.ENGINE_MODE_TO_FACE_NEG_ONLY = 6

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

openvsp.vsp.ENGINE_MODE_TO_LIP = 3

  Represent integrated flowpath to the lip.

openvsp.vsp.ETA_PROP_DRIVER = 4

  Prop efficiency driver

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.EXTENT_FORWARD_FINITE = 2

  Forward displacement.

openvsp.vsp.EXTENT_FORWARD_INF = 0

  Forward beyond extent of model.

openvsp.vsp.EXTENT_REVERSE_FINITE = 3

  Reverse displacement.

openvsp.vsp.EXTENT_REVERSE_INF = 1

  Reverse beyond extent of model.

openvsp.vsp.EXTENT_SLIDER_AFTER = 6

  Slider motion from current position to end.

openvsp.vsp.EXTENT_SLIDER_BEFORE = 5

  Slider motion from start to current position.

openvsp.vsp.EXTENT_SLIDER_FULL = 4

  Full range of slider motion.

openvsp.vsp.EXTERNAL_INTERFERENCE = 0

  Interference between mutually external bodies

openvsp.vsp.EXTERNAL_SELF_INTERFERENCE = 2

  Interference between multiple surfaces of one Geom / Set

openvsp.vsp.EditXSecConvertTo(xsec_id, newtype)

  Convert the EditCurveXSec curve type to the specified new type. Note, EditCurveXSec uses the same enumerations for PCurve to identify curve type, but APPROX_CEDIT is not supported at this time.

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      ChangeXSecShape( xsec_surf, 1, XS_EDIT_CURVE )

      # Identify XSec 1
      xsec_1 = GetXSec( xsec_surf, 1 )

      # Set XSec 1 to Linear
      EditXSecConvertTo( xsec_1, LINEAR )

  See also: PCURV_TYPE :param [in]: xsec_id string XSec ID :param [in]: newtype int New curve type enum (i.e. CEDIT)

openvsp.vsp.EditXSecDelPnt(xsec_id, indx)

  Delete an EditCurveXSec control point. Note, cubic Bezier intermediate control points (those not on the curve) cannot be deleted. The previous and next Bezier control point will be deleted along with the point on the curve. Regardless of curve type, the first and last points may not be deleted.

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      ChangeXSecShape( xsec_surf, 2, XS_EDIT_CURVE )

      # Identify XSec 2
      xsec_2 = GetXSec( xsec_surf, 2 )

      # Turn off R/L symmetry
      SetParmVal( GetXSecParm( xsec_2, "SymType"), SYM_NONE )

      old_pnts = GetEditXSecCtrlVec( xsec_2, True ) # The returned control points will not be scaled by width and height

      EditXSecDelPnt( xsec_2, 3 ) # Remove control point at bottom of circle

      new_pnts = GetEditXSecCtrlVec( xsec_2, True ) # The returned control points will not be scaled by width and height

      if  len(old_pnts) - len(new_pnts) != 3  :
          print( "Error: EditXSecDelPnt")

  Parameters:

    - [in] – xsec_id string XSec ID

    - [in] – indx int Control point index

openvsp.vsp.EditXSecInitShape(xsec_id)

  Initialize the EditCurveXSec to the current value of m_ShapeType (i.e. EDIT_XSEC_ELLIPSE)

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      ChangeXSecShape( xsec_surf, 2, XS_EDIT_CURVE )

      # Identify XSec 2
      xsec_2 = GetXSec( xsec_surf, 2 )

      # Set XSec 2 to linear
      EditXSecConvertTo( xsec_2, LINEAR )

      EditXSecInitShape( xsec_2 ) # Change back to default ellipse

  See also: INIT_EDIT_XSEC_TYPE :param [in]: xsec_id string XSec ID

openvsp.vsp.EditXSecSplit01(xsec_id, u)

  Split the EditCurveXSec at the specified U value

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      ChangeXSecShape( xsec_surf, 2, XS_EDIT_CURVE )

      # Identify XSec 2
      xsec_2 = GetXSec( xsec_surf, 2 )

      # Turn off R/L symmetry
      SetParmVal( GetXSecParm( xsec_2, "SymType"), SYM_NONE )

      old_pnts = GetEditXSecCtrlVec( xsec_2, True ) # The returned control points will not be scaled by width and height

      new_pnt_ind = EditXSecSplit01( xsec_2, 0.375 )

      new_pnts = GetEditXSecCtrlVec( xsec_2, True ) # The returned control points will not be scaled by width and height

      if  len(new_pnts) - len(old_pnts) != 3  :
          print( "Error: EditXSecSplit01")

  Parameters:

    - [in] – xsec_id string XSec ID

    - [in] – u double U value to split the curve at (0 - 1)

  Return type:

    int

  Returns:

    int Index of the point added from the split

openvsp.vsp.EnableStopGUIMenuItem()

  Enable Stop GUI Menu Item from the OpenVSP GUI.

  Typically used for the blocking-mode OpenVSP GUI from the API.

  This will add a “Stop GUI” option to the file pulldown menu and will also cause the exit button on the window frame to have the same effect. When selected, these options will stop the OpenVSP GUI event loop, returning control to the API program. OpenVSP will not terminate, the model will remain in memory and will be responsive to subsequent API calls.

      EnableStopGUIMenuItem()
      StartGUI()

  See also: DisableStopGUIMenuItem

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

    Check if there was an error on the last call to the API

        #==== Force API to silence error messages ====##
        SilenceErrors()

        #==== Bogus Call To Create API Error ====##
        print( "---> Test Error Handling" )

        SetParmVal( "BogusParmID", 23.0 )

        if not GetErrorLastCallFlag():
            print( "---> Error: API GetErrorLastCallFlag" )

        #==== Tell API to print error messages ====##
        PrintOnErrors()

    Return type:

      boolean

    Returns:

      False if no error, true otherwise

  GetLastError()

    Return the most recent error from the stack (does NOT pop error off the stack)

        #==== Force API to silence error messages ====##
        SilenceErrors()

        print( "Creating an API error" )
        SetParmVal( "ABCDEFG", "Test_Name", "Test_Group", 123.4 )

        #==== Check For API Errors ====##
        err = GetLastError()

        print( err.GetErrorString() )

        #==== Tell API to print error messages ====##
        PrintOnErrors()

    See also: SilenceErrors, PrintOnErrors; :rtype: `ErrorObj` :return: Error object

  GetNumTotalErrors()

    Count the total number of errors on the stack

        #==== Force API to silence error messages ====##
        SilenceErrors()

        print( "Creating an API error" )
        SetParmVal( "ABCDEFG", "Test_Name", "Test_Group", 123.4 )

        #==== Check For API Errors ====##
        while GetNumTotalErrors() > 0:
            err = PopLastError()
            print( err.GetErrorString() )

        #==== Tell API to print error messages ====##
        PrintOnErrors()

    Return type:

      int

    Returns:

      Number of errors

  MessageCallback(ErrorMgrSingleton self, MessageBase const * _from, MessageData const & data)
  NoError(ErrorMgrSingleton self)
  PopErrorAndPrint(ErrorMgrSingleton self, FILE * stream) → bool
  PopLastError()

    Pop (remove) and return the most recent error from the stack. Note, errors are printed on occurrence by default.

        #==== Force API to silence error messages ====##
        SilenceErrors()

        print( "Creating an API error" )
        SetParmVal( "ABCDEFG", "Test_Name", "Test_Group", 123.4 )

        #==== Check For API Errors ====##
        while GetNumTotalErrors() > 0:
            err = PopLastError()
            print( err.GetErrorString() )

        #==== Tell API to print error messages ====##
        PrintOnErrors()

    Return type:

      `ErrorObj`

    Returns:

      Error object

  PrintOnErrors()

    Cause errors to be printed to stdout as they occur.

        #==== Force API to silence error messages ====##
        SilenceErrors()

        print( "Creating an API error" )
        SetParmVal( "ABCDEFG", "Test_Name", "Test_Group", 123.4 )

        #==== Tell API to print error messages ====##
        PrintOnErrors()

    See also: SilenceErrors

  SilenceErrors()

    Prevent errors from printing to stdout as they occur.

        #==== Force API to silence error messages ====##
        SilenceErrors()

        print( "Creating an API error" )
        SetParmVal( "ABCDEFG", "Test_Name", "Test_Group", 123.4 )

        #==== Tell API to print error messages ====##
        PrintOnErrors()

    See also: PrintOnErrors

  static getInstance() → ErrorMgrSingleton
  property thisown

    The membership flag

class openvsp.vsp.ErrorObj(*args)

  Bases: `object`

  ErrorObj is defined by an error code enum and associated error string.

  GetErrorCode()

    Get the ERROR_CODE enum of the last raised error

        err = PopLastError()

        if err.GetErrorCode() != vsp.VSP_CANT_FIND_PARM:
            print( "---> Error: API PopLast" )

    See also: ERROR_CODE :rtype: int :return: ERROR_CODE error code enum

  GetErrorString()

    Get the error string of the last raised error

        #==== Check For API Errors ====##
        while GetNumTotalErrors() > 0:
            err = PopLastError()
            print( err.GetErrorString() )

    Return type:

      string

    Returns:

      Error 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(analysis)

  Execute an analysis through the Analysis Manager

      analysis_name = "VSPAEROComputeGeometry"

      res_id = ExecAnalysis( analysis_name )

  Parameters:

    [in] – analysis string Analysis name

  Return type:

    string

  Returns:

    string Result ID

openvsp.vsp.ExportFile(*args)

  Export a file from OpenVSP. Many formats are available, such as STL, IGES, and SVG. If a mesh is generated for a particular export, the ID of the MeshGeom will be returned. If no mesh is generated an empty string will be returned.

      wid = AddGeom( "WING" )             # Add Wing

      ExportFile( "Airfoil_Metadata.csv", SET_ALL, EXPORT_SELIG_AIRFOIL )

      mesh_id = ExportFile( "Example_Mesh.msh", SET_ALL, EXPORT_GMSH )
      DeleteGeom( mesh_id ) # Delete the mesh generated by the GMSH export

  See also: EXPORT_TYPE :param [in]: file_name string Export file name :param [in]: thick_set int Set index to export (i.e. SET_ALL) :param [in]: file_type int File type enum (i.e. EXPORT_IGES) :param [in]: subsFlag int Flag to tag subsurfaces if MeshGeom is created :param [in]: thin_set int Set index to export as degenerate geometry (i.e. SET_NONE) :param [in]: useMode bool Flag determine if mode is used instead of sets :param [in]: modeID string ID of Mode to use :rtype: string :return: string Mesh Geom ID if the export generates a mesh

openvsp.vsp.FAN_FRAGMENT = 3

  Fan blade fragment

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 = 10

  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_POLY_SPAR = 9

  Poly Spar FEA Part 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.FLAP_NONE = 0

  No flap

openvsp.vsp.FLAP_NUM_TYPES = 2

  Number of flap types

openvsp.vsp.FLAP_PLAIN = 1

  Plain flap

openvsp.vsp.FLAT_END_CAP = 1

  Flat end cap

openvsp.vsp.FUSELAGE_GEOM_SCREEN = 1

  Fuselage geom screen

openvsp.vsp.FindActuatorDisk(disk_index)

  Get the ID of a VSPAERO actuator disk at the specified index. An empty string is returned if the index is out of range.

      # Add a propeller
      prop_id = AddGeom( "PROP", "" )
      SetParmVal( prop_id, "PropMode", "Design", PROP_DISK )
      SetParmVal( prop_id, "Diameter", "Design", 6.0 )

      Update()

      # Setup the actuator disk VSPAERO parms
      disk_id = FindActuatorDisk( 0 )

      SetParmVal( FindParm( disk_id, "RotorRPM", "Rotor" ), 1234.0 )
      SetParmVal( FindParm( disk_id, "RotorCT", "Rotor" ), 0.35 )
      SetParmVal( FindParm( disk_id, "RotorCP", "Rotor" ), 0.55 )
      SetParmVal( FindParm( disk_id, "RotorHubDiameter", "Rotor" ), 1.0 )

  See also: PROP_MODE :param [in]: disk_index int Actuator disk index for the current VSPAERO set :rtype: string :return: string Actuator disk ID

openvsp.vsp.FindAllAttributes()

  Returns a vector of string IDs for all Attributes in the vehicle

      ##==== Attributes: FindAllAttributes ====##
      AttrIDs = FindAllAttributes()
      for AttrID in AttrIDs:
          print( AttrID )

  Return type:

    vector< string >

  Returns:

    vector <string> Vector of All Attribute IDs

openvsp.vsp.FindAttributeByName(search_str, index)

  Searches all attributes that contain the search string, case insensitive, and returns the user-specified index

      ##==== Attributes: FindAttributeByName ====##
      AttrID = FindAttributeByName( "Watermark", 0 )
      print( AttrID )

  Return type:

    string

  Returns:

    string Returns a StringID of the attribute indexed/searched by user, if found

  Parameters:

    - [in] – search_str string for filtering attributes in model

    - [in] – index int for indexing which of the vector of found attributes to select

openvsp.vsp.FindAttributeInCollection(obj_id, search_str, index)

  Searches all attributes in an OpenVSP object or AttributeCollection that contain the search string, case insensitive, and returns the user-specified index. Works either with the ID of an object that contains an attributeCollection or just the ID of an attributeCollection.

      ##==== Attributes: FindAttributeInCollection ====##
      VehID = GetVehicleID()
      AttrID = FindAttributeInCollection( VehID, 'Watermark', 0 )
      print( AttrID )

  Return type:

    string

  Returns:

    string Returns a StringID of the attribute indexed/searched by user, if found

  Parameters:

    - [in] – obj_id string id of object to search within for attributes

    - [in] – search_str string for filtering attributes in object

    - [in] – index int for indexing which of the vector of found attributes to select

openvsp.vsp.FindAttributeNamesInCollection(collID)

  Return a list of all attribute Names within an attribute collection

      ##==== Attributes: FindAttributeNamesInCollection ====##
      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      AttrNames = FindAttributeNamesInCollection( CollID )
      for AttrName in AttrNames:
          print( AttrName )

  Return type:

    vector< string >

  Returns:

    vector<string> Array of result names

  Parameters:

    [in] – collID string ID of an attribute collection

openvsp.vsp.FindAttributedObjects()

  Get array of IDs of all OpenVSP entities that have populated attributeCollections Includes attributeGroups

      ##==== Attributes: FindAttributedObjects ====##
      AttachIDs = FindAttributedObjects()
      for AttachID in AttachIDs:
          print( AttachID )

  Return type:

    vector< string >

  Returns:

    vector<string> Array of IDs of entities in OpenVSP that contain populated attribute collections

openvsp.vsp.FindAttributesByName(search_str)

  Returns all attributes that contain the string search_str within their name, case insensitive

      ##==== Attributes: FindAttributesByName ====##
      AttrIDs = FindAttributesByName( "Watermark" )
      for AttrID in AttrIDs:
          print( AttrID )

  Return type:

    vector< string >

  Returns:

    vector <string> Vector of string IDs of matching Attributes

  Parameters:

    [in] – search_str string for filtering attributes in model

openvsp.vsp.FindAttributesInCollection(collID)

  Get all attribute IDs within a single AttributeCollection, referenced by collID

      ##==== Attributes: FindAttributesInCollection ====##
      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      AttrIDs = FindAttributesInCollection( CollID )
      for AttrID in AttrIDs:
          print( AttrID )

  Return type:

    vector< string >

  Returns:

    vector<string> Vector of attribute IDs in an attribute collection.

  Parameters:

    [in] – collID string ID of an attribute collection

openvsp.vsp.FindContainer(name, index)

  Get the ID of a Parm Container with specified name at input index

      #===== Get Vehicle Parm Container ID ====//
      veh_id = FindContainer( "Vehicle", 0 )

  See also: FindContainersWithName :param [in]: name string Parm Container name :param [in]: index int Parm Container index :rtype: string :return: string Parm Container ID

openvsp.vsp.FindContainerGroupNames(parm_container_id)

  Get an array of Parm group names included in the specified Container

      user_ctr = FindContainer( "UserParms", 0 )

      grp_arr = FindContainerGroupNames( user_ctr )

      print( "---> UserParms Container Group IDs: " )
      for i in range(int( len(grp_arr) )):

          message = "\t" + grp_arr[i] + "\n"

          print( message )

  Parameters:

    [in] – parm_container_id string Parm Container ID

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Array of Parm group names

openvsp.vsp.FindContainerParmIDs(parm_container_id)

  Get an array of Parm IDs included in the specified Container

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      #==== Get Structure Name and Parm Container ID ====//
      parm_container_name = GetFeaStructName( pod_id, struct_ind )

      parm_container_id = FindContainer( parm_container_name, struct_ind )

      #==== Get and List All Parms in the Container ====//
      parm_ids = FindContainerParmIDs( parm_container_id )

      for i in range(len(parm_ids)):

          name_id = GetParmName( parm_ids[i] ) + ": " + parm_ids[i] + "\n"

          print( name_id )

  Parameters:

    [in] – parm_container_id string Parm Container ID

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Array of Parm IDs

openvsp.vsp.FindContainers()

  Get an array of all Parm Container IDs

      ctr_arr = FindContainers()

      print( "---> API Parm Container IDs: " )

      for i in range(int( len(ctr_arr) )):

          message = "\t" + ctr_arr[i] + "\n"

          print( message )

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Array of Parm Container IDs

openvsp.vsp.FindContainersWithName(name)

  Get an array of Parm Container IDs for Containers with the specified name

      ctr_arr = FindContainersWithName( "UserParms" )

      if  len(ctr_arr) > 0 : print( ( "UserParms Parm Container ID: " + ctr_arr[0] ) )

  Parameters:

    [in] – name string Parm Container name

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Array of Parm Container IDs

openvsp.vsp.FindGeom(name, index)

  Find and return the Geom ID with the specified name at given index. Equivalent to FindGeomsWithName( name )[index].

      #==== Add Pod Geometry ====//
      pid = AddGeom( "POD", "" )

      SetGeomName( pid, "ExamplePodName" )

      geom_id = FindGeom( "ExamplePodName", 0 )

      geom_ids = FindGeomsWithName( "ExamplePodName" )

      if  geom_ids[0] != geom_id :
          print( "---> Error: API FindGeom & FindGeomsWithName" )

  See also: FindGeomsWithName :param [in]: name string Geom name :param [in]: index :rtype: string :return: string Geom ID with name at specified index

openvsp.vsp.FindGeoms()

  Find and return all Geom IDs in the model

      #==== Add Pod Geometries ====//
      pod1 = AddGeom( "POD", "" )
      pod2 = AddGeom( "POD", "" )

      #==== There Should Be Two Geoms =====//
      geom_ids = FindGeoms()

      if  len(geom_ids) != 2 : print( "---> Error: API FindGeoms " )

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Array of all Geom IDs

openvsp.vsp.FindGeomsWithName(name)

  Find and return all Geom IDs with the specified name

      #==== Add Pod Geometry ====//
      pid = AddGeom( "POD", "" )

      SetGeomName( pid, "ExamplePodName" )

      geom_ids = FindGeomsWithName( "ExamplePodName" )

      if  len(geom_ids) != 1 :
          print( "---> Error: API FindGeomsWithName " )

  See also: FindGeom :param [in]: name string Geom name :rtype: std::vector< std::string,std::allocator< std::string > > :return: vector<string> Array of Geom IDs

openvsp.vsp.FindLatestResultsID(name)

  Find the latest results ID for particular result name

      #==== Write Some Fake Test Results =====//
      WriteTestResults()

      results_array = GetAllResultsNames()

      for i in range(int( len(results_array) )):

          resid = FindLatestResultsID( results_array[i] )
          PrintResults( resid )

  Parameters:

    [in] – name string Result name

  Return type:

    string

  Returns:

    string Result ID

openvsp.vsp.FindParm(parm_container_id, parm_name, group_name)

  Find a Parm ID given the Parm Container ID, Parm name, and Parm group

      #==== Add Wing Geometry ====//
      wing_id = AddGeom( "WING" )

      #==== Turn Symmetry OFF ====//
      sym_id = FindParm( wing_id, "Sym_Planar_Flag", "Sym")

      SetParmVal( sym_id, 0.0 ) # Note: bool input not supported in SetParmVal

  Parameters:

    - [in] – parm_container_id string Parm Container ID

    - [in] – parm_name string Parm name

    - [in] – group_name string Parm group name

  Return type:

    string

  Returns:

    string Parm ID

openvsp.vsp.FindRST(geom_id, surf_indx, pt)

  Determine the nearest (R, S, T) volume coordinate for an input (X, Y, Z) 3D coordinate point and calculate the distance between the 3D point and the found volume point.

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      surf_indx = 0

      r = 0.12
      s = 0.68
      t = 0.56

      pnt = CompPntRST( geom_id, surf_indx, r, s, t )

      d, rout, sout, tout = FindRST( geom_id, surf_indx, pnt )

      print( f"Dist {d} r {rout} s {sout} t {tout}" )

  See also: FindRSTGuess :param [in]: geom_id string Parent Geom ID :param [in]: surf_indx int Main surface index from the parent Geom :param [in]: pt vec3d Input 3D coordinate point :param [out]: r_out double Output closest R (0 - 1.0) volume coordinate :param [out]: s_out double Output closest S (0 - 1.0) volume coordinate :param [out]: t_out double Output closest T (0 - 1.0) volume coordinate :rtype: float :return: double Distance between the 3D point and the closest point of the volume

openvsp.vsp.FindRSTGuess(geom_id, surf_indx, pt, r0, s0, t0)

  Determine the nearest (R, S, T) volume coordinate for an input (X, Y, Z) 3D coordinate point given an initial guess of volume coordinates. Also calculate the distance between the 3D point and the found volume point.

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      surf_indx = 0

      r = 0.12
      s = 0.68
      t = 0.56

      pnt = CompPntRST( geom_id, surf_indx, r, s, t )

      r0 = 0.1
      s0 = 0.6
      t0 = 0.5

      d, rout, sout, tout = FindRSTGuess( geom_id, surf_indx, pnt, r0, s0, t0 )

      print( f"Dist {d} r {rout} s {sout} t {tout}" )

  See also: FindRST :param [in]: geom_id string Parent Geom ID :param [in]: surf_indx int Main surface index from the parent Geom :param [in]: pt vec3d Input 3D coordinate point :param [in]: r0 double Input R (0 - 1.0) volume coordinate guess :param [in]: s0 double Input S (0 - 1.0) volume coordinate guess :param [in]: t0 double Input T (0 - 1.0) volume coordinate guess :param [out]: r_out double Output closest R (0 - 1.0) volume coordinate :param [out]: s_out double Output closest S (0 - 1.0) volume coordinate :param [out]: t_out double Output closest T (0 - 1.0) volume coordinate :rtype: float :return: double Distance between the 3D point and the closest point of the volume

openvsp.vsp.FindRSTVec(geom_id, surf_indx, pts)

  Determine the nearest volume coordinates for an input array of 3D coordinate points and calculate the distance between each 3D point and the found point in the volume.

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      n = 5

      rvec = [0]*n
      svec = [0]*n
      tvec = [0]*n

      for i in range(n):

          rvec[i] = (i+1)*1.0/(n+1)

          svec[i] = (n-i)*1.0/(n+1)

          tvec[i] = (i+1)*1.0/(n+1)

      ptvec = CompVecPntRST( geom_id, 0, rvec, svec, tvec )

      routv, soutv, toutv, doutv = FindRSTVec( geom_id, 0, ptvec )

  See also: FindRSTVecGuess :param [in]: geom_id string Parent Geom ID :param [in]: surf_indx int Main surface index from the parent Geom :param [in]: pts vector<vec3d> Input vector of 3D coordinate points :param [out]: r_out_vec vector<double> Output vector of the closest R (0 - 1.0) volume coordinate for each 3D input point :param [out]: s_out_vec vector<double> Output vector of the closest S (0 - 1.0) volume coordinate for each 3D input point :param [out]: t_out_vec vector<double> Output vector of the closest T (0 - 1.0) volume coordinate for each 3D input point :param [out]: d_out_vec vector<double> Output vector of distances for each 3D point and the closest point of the volume

openvsp.vsp.FindRSTVecGuess(geom_id, surf_indx, pts, r0s, s0s, t0s)

  Determine the nearest volume coordinates for an input array of 3D coordinate points and calculate the distance between each 3D point and the closest point of the volume. This function takes an input array of volume coordinate guesses for each 3D coordinate, offering a potential decrease in computation time compared to FindRSTVec.

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      n = 5

      rvec = [0]*n
      svec = [0]*n
      tvec = [0]*n

      for i in range(n):

          rvec[i] = (i+1)*1.0/(n+1)

          svec[i] = (n-i)*1.0/(n+1)

          tvec[i] = (i+1)*1.0/(n+1)

      ptvec = CompVecPntRST( geom_id, 0, rvec, svec, tvec )

      for i in range(n):

          ptvec[i].set_xyz(ptvec[i].x() * 0.9, ptvec[i].y() * 0.9, ptvec[i].z() * 0.9)

       routv, soutv, toutv, doutv = FindRSTVecGuess( geom_id, 0, ptvec, rvec, svec, tvec )

  See also: FindRSTVec, :param [in]: geom_id string Parent Geom ID :param [in]: surf_indx int Main surface index from the parent Geom :param [in]: pts vector<vec3d> Input vector of 3D coordinate points :param [in]: r0s vector<double> Input vector of U (0 - 1.0) volume coordinate guesses :param [in]: s0s vector<double> Input vector of S (0 - 1.0) volume coordinate guesses :param [in]: t0s vector<double> Input vector of T (0 - 1.0) volume coordinate guesses :param [out]: r_out_vec vector<double> Output vector of the closest R (0 - 1.0) volume coordinate for each 3D input point :param [out]: s_out_vec vector<double> Output vector of the closest S (0 - 1.0) volume coordinate for each 3D input point :param [out]: t_out_vec vector<double> Output vector of the closest T (0 - 1.0) volume coordinate for each 3D input point :param [out]: d_out_vec vector<double> Output vector of distances for each 3D point and the closest point of the volume

openvsp.vsp.FindResultsID(name, index=0)

  Find a results ID given its name and index

      #==== Write Some Fake Test Results =====//
      WriteTestResults()

      res_id = FindResultsID( "Test_Results" )

      if  len(res_id) == 0 : print( "---> Error: API FindResultsID" )

  Parameters:

    - [in] – name string Result name

    - [in] – index int Result index

  Return type:

    string

  Returns:

    string Result ID

openvsp.vsp.FindUnsteadyGroup(group_index)

  Get the ID of the VSPAERO unsteady group at the specified index. An empty string is returned if the index is out of range.

      wing_id = AddGeom( "WING" )
      pod_id = AddGeom( "POD" )

      # Create an actuator disk
      prop_id = AddGeom( "PROP", "" )
      SetParmVal( prop_id, "PropMode", "Design", PROP_BLADES )

      Update()

      # Setup the unsteady group VSPAERO parms
      disk_id = FindUnsteadyGroup( 1 ) # fixed components are in group 0 (wing & pod)

      SetParmVal( FindParm( disk_id, "RPM", "UnsteadyGroup" ), 1234.0 )

  See also: PROP_MODE :param [in]: group_index int Unsteady group index for the current VSPAERO set :rtype: string :return: string Unsteady group ID

openvsp.vsp.FitAfCST(xsec_surf_id, xsec_index, deg)

  Fit a CST airfoil for an existing airfoil of type XS_FOUR_SERIES, XS_SIX_SERIES, XS_FOUR_DIGIT_MOD, XS_FIVE_DIGIT, XS_FIVE_DIGIT_MOD, XS_ONE_SIX_SERIES, or XS_FILE_AIRFOIL. :param [in]: xsec_surf_id string XsecSurf ID :param [in]: xsec_index int XSec index :param [in]: deg int CST degree

openvsp.vsp.FitAllViews()

  Fit contents to all viewports

      FitAllViews()

openvsp.vsp.FitBORAfCST(bor_id, deg)

  Fit a CST airfoil for an existing airfoil of a BOR of type XS_FOUR_SERIES, XS_SIX_SERIES, XS_FOUR_DIGIT_MOD, XS_FIVE_DIGIT, XS_FIVE_DIGIT_MOD, XS_ONE_SIX_SERIES, or XS_FILE_AIRFOIL. :param [in]: bor_id string Body of revolution Geom ID :param [in]: deg int CST degree

openvsp.vsp.FitPlane(Vec3dVec pts, vec3d cen, vec3d norm)

openvsp.vsp.GDEV_ADD_CHOICE_ITEM = 17

  Add item to custom GUI Choice

openvsp.vsp.GDEV_BEGIN_SAME_LINE = 27

  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 = 16

  Custom GUI Choice

openvsp.vsp.GDEV_COLOR_PICKER = 24

  Custom GUI ColorPicker

openvsp.vsp.GDEV_COUNTER = 15

  Custom GUI Counter

openvsp.vsp.GDEV_DIVIDER_BOX = 26

  Custom GUI divider box

openvsp.vsp.GDEV_END_SAME_LINE = 28

  Set end same line flag for custom GUI

openvsp.vsp.GDEV_FORCE_WIDTH = 29

  Set forced width for custom GUI

openvsp.vsp.GDEV_FRACT_PARM_SLIDER = 21

  Custom GUI FractParmSlider

openvsp.vsp.GDEV_GROUP = 2

  Custom GUI Group

openvsp.vsp.GDEV_INDEX_SELECTOR = 23

  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 = 30

  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 = 19

  Custom GUI SliderAdjRangeInput

openvsp.vsp.GDEV_SLIDER_ADJ_RANGE_TWO_INPUT = 20

  Custom GUI SliderAdjRangeInput with two inputs (NOT IMPLEMENTED)

openvsp.vsp.GDEV_SLIDER_INPUT = 18

  Custom GUI SliderInput

openvsp.vsp.GDEV_STRING_INPUT = 22

  Custom GUI StringInput

openvsp.vsp.GDEV_TAB = 0

  Custom GUI Tab

openvsp.vsp.GDEV_TOGGLE_BUTTON = 11

  Custom GUI ToggleButton

openvsp.vsp.GDEV_TOGGLE_BUTTON_FREE = 12

  Custom GUI ToggleButton without Parm

openvsp.vsp.GDEV_TOGGLE_RADIO_GROUP = 13

  Custom GUI ToggleRadioGroup (NOT IMPLEMENTED)

openvsp.vsp.GDEV_TRIGGER_BUTTON = 14

  Custom GUI TriggerButton

openvsp.vsp.GDEV_YGAP = 25

  Custom GUI Y gap

openvsp.vsp.GEAR_CG_TIPBACK_ANALYSIS = 5

  Calculate tipback angle

openvsp.vsp.GEAR_CONFIGURATION_ALL = 4

  Gear drawn in all configurations

openvsp.vsp.GEAR_CONFIGURATION_DOWN = 0

  Gear drawn down

openvsp.vsp.GEAR_CONFIGURATION_INTERMEDIATE = 3

  Gear drawn somewhere beteween down and up

openvsp.vsp.GEAR_CONFIGURATION_UP = 1

  Gear drawn up

openvsp.vsp.GEAR_CONFIGURATION_UP_AND_DOWN = 2

  Gear drawn both up and down

openvsp.vsp.GEAR_GEOM_SCREEN = 19

  Gear geom screen

openvsp.vsp.GEAR_MECHANISM = 1

  Specified by mechanism

openvsp.vsp.GEAR_STOWED_POSITION = 0

  Specified by stowed position

openvsp.vsp.GEAR_SUSPENSION_COMPRESSED = 1

  Gear suspension is compressed

openvsp.vsp.GEAR_SUSPENSION_EXTENDED = 2

  Gear suspension is extended

openvsp.vsp.GEAR_SUSPENSION_NOMINAL = 0

  Gear suspension at nominal extension

openvsp.vsp.GEAR_TIPOVER_ANALYSIS = 8

  Calculate tipover angle

openvsp.vsp.GEAR_TURN_ANALYSIS = 9

  Calculate ground manueveribility

openvsp.vsp.GEAR_WEIGHT_DISTRIBUTION_ANALYSIS = 7

  Calculate distribution of weight across landing gear

openvsp.vsp.GENERIC_FRAGMENT = 5

  Generic fragment

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(CSGroupIndex)

  Get the names of each active (used) control surface in the control surface group at the specified index

      wid = AddGeom( "WING", "" )                             # Add Wing

      aileron_id = AddSubSurf( wid, SS_CONTROL )                      # Add Control Surface Sub-Surface

      group_index = CreateVSPAEROControlSurfaceGroup() # Empty control surface group

      AddAllToVSPAEROControlSurfaceGroup( group_index )

      cs_name_vec = GetActiveCSNameVec( group_index )

      print( "Active CS in Group Index #", False )
      print( group_index )

      for i in range(int( len(cs_name_vec) )):

          print( cs_name_vec[i] )

  Parameters:

    [in] – CSGroupIndex int Index of the control surface group

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector <string> Array of active control surface names

openvsp.vsp.GetActiveGeometryAnalysis()

  Get the ID of the active Geometry Analysis case.

      ga_id = AddGeometryAnalysis()
      SetActiveGeometryAnalysis( ga_id )
      active = GetActiveGeometryAnalysis()

  See also: SetActiveGeometryAnalysis :rtype: string :return: string Active Geometry Analysis case ID (empty string if none)

openvsp.vsp.GetAdvLinkCode(index)

  Get the code from an advanced link

      pod = AddGeom( "POD", "" )
      length = FindParm( pod, "Length", "Design" )
      x_pos = GetParm( pod, "X_Rel_Location", "XForm" )

      AddAdvLink( "ExampleLink" )
      indx = GetLinkIndex( "ExampleLink" )
      AddAdvLinkInput( indx, length, "len" )
      AddAdvLinkOutput( indx, x_pos, "x" )

      SetAdvLinkCode( indx, "x = 10.0 - len;" )

      BuildAdvLinkScript( indx )

      code = GetAdvLinkCode( indx )

      print( code )

  Parameters:

    [in] – index int Index for advanced link

  Return type:

    string

  Returns:

    string String containing advanced link code

openvsp.vsp.GetAdvLinkInputNames(index)

  Get the name of all the inputs to a specified advanced link index

      pod = AddGeom( "POD", "" )
      length = FindParm( pod, "Length", "Design" )
      x_pos = GetParm( pod, "X_Rel_Location", "XForm" )

      AddAdvLink( "ExampleLink" )
      indx = GetLinkIndex( "ExampleLink" )
      AddAdvLinkInput( indx, length, "len" )
      AddAdvLinkOutput( indx, x_pos, "x" )

      SetAdvLinkCode( indx, "x = 10.0 - len;" )

      BuildAdvLinkScript( indx )

      name_array = GetAdvLinkInputNames( indx )

      for n in range(len(name_array) ):

          print( name_array[n] )

  Parameters:

    [in] – index int Advanced link index

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Array of advanced link input names

openvsp.vsp.GetAdvLinkInputParms(index)

  Get the Parm IDs of all the inputs to a specified advanced link index

      pod = AddGeom( "POD", "" )
      length = FindParm( pod, "Length", "Design" )
      x_pos = GetParm( pod, "X_Rel_Location", "XForm" )

      AddAdvLink( "ExampleLink" )
      indx = GetLinkIndex( "ExampleLink" )
      AddAdvLinkInput( indx, length, "len" )
      AddAdvLinkOutput( indx, x_pos, "x" )

      SetAdvLinkCode( indx, "x = 10.0 - len;" )

      BuildAdvLinkScript( indx )

      parm_array = GetAdvLinkInputParms( indx )

      for n in range( len(parm_array) ):

          print( parm_array[n] )

  Parameters:

    [in] – index int Advanced link index

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Array of advanced link input Parm IDs

openvsp.vsp.GetAdvLinkNames()

  Get an array of all advanced link names

      link_array = GetAdvLinkNames()

      for n in range(len(link_array) ):

          print( link_array[n] )

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Array of advanced link names

openvsp.vsp.GetAdvLinkOutputNames(index)

  Get the Parm IDs of all the outputs to a specified advanced link index

      pod = AddGeom( "POD", "" )
      length = FindParm( pod, "Length", "Design" )
      x_pos = GetParm( pod, "X_Rel_Location", "XForm" )

      AddAdvLink( "ExampleLink" )
      indx = GetLinkIndex( "ExampleLink" )
      AddAdvLinkInput( indx, length, "len" )
      AddAdvLinkOutput( indx, x_pos, "x" )

      SetAdvLinkCode( indx, "x = 10.0 - len;" )

      BuildAdvLinkScript( indx )

      name_array = GetAdvLinkOutputNames( indx )

      for n in range( len(name_array) ):

          print( name_array[n] )

  Parameters:

    [in] – index int Advanced link index

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Array of advanced link output names

openvsp.vsp.GetAdvLinkOutputParms(index)

  Get the Parm IDs of all the outputs to a specified advanced link index

      pod = AddGeom( "POD", "" )
      length = FindParm( pod, "Length", "Design" )
      x_pos = GetParm( pod, "X_Rel_Location", "XForm" )

      AddAdvLink( "ExampleLink" )
      indx = GetLinkIndex( "ExampleLink" )
      AddAdvLinkInput( indx, length, "len" )
      AddAdvLinkOutput( indx, x_pos, "x" )

      SetAdvLinkCode( indx, "x = 10.0 - len;" )

      BuildAdvLinkScript( indx )

      parm_array = GetAdvLinkOutputParms( indx )

      for n in range( len(parm_array) ):

          print( parm_array[n] )

  Parameters:

    [in] – index int Advanced link index

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Array of advanced link output Parm IDs

openvsp.vsp.GetAirfoilCoordinates(geom_id, foilsurf_u)

  Get the untwisted unit-length 2D coordinate points for the specified airfoil See also: WriteSeligAirfoil :param [in]: geom_id string Geom ID :param [in]: foilsurf_u double U location (range: 0 - 1) along the surface. The foil surface does not include root and tip caps (i.e. 2 section wing -> XSec0 @ u=0, XSec1 @ u=0.5, XSec2 @ u=1.0)

openvsp.vsp.GetAirfoilLowerPnts(xsec_id)

  Get the coordinate points for the lower surface of an airfoil. The XSec must be of type XS_FILE_AIRFOIL

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE", "" )

      xsec_surf = GetXSecSurf( fuseid, 0 )

      ChangeXSecShape( xsec_surf, 1, XS_FILE_AIRFOIL )

      xsec = GetXSec( xsec_surf, 1 )

      ReadFileAirfoil( xsec, "airfoil/N0012_VSP.af" )

      low_array = GetAirfoilLowerPnts( xsec )

  See also: SetAirfoilPnts :param [in]: xsec_id string XSec ID :rtype: std::vector< vec3d,std::allocator< vec3d > > :return: vector<vec3d> Vector of coordinate points for the lower airfoil surface

openvsp.vsp.GetAirfoilUpperPnts(xsec_id)

  Get the coordinate points for the upper surface of an airfoil. The XSec must be of type XS_FILE_AIRFOIL

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE", "" )

      xsec_surf = GetXSecSurf( fuseid, 0 )

      ChangeXSecShape( xsec_surf, 1, XS_FILE_AIRFOIL )

      xsec = GetXSec( xsec_surf, 1 )

      ReadFileAirfoil( xsec, "airfoil/N0012_VSP.af" )

      up_array = GetAirfoilUpperPnts( xsec )

  See also: SetAirfoilPnts :param [in]: xsec_id string XSec ID :rtype: std::vector< vec3d,std::allocator< vec3d > > :return: vector<vec3d> VectorArray of coordinate points for the upper airfoil surface

openvsp.vsp.GetAllBackground3DAbsolutePaths()

  Get absolute paths to all Background3D images in model.

      # Add Background3D
      AddBackground3D()
      AddBackground3D()
      AddBackground3D()

      bg_file_array = GetAllBackground3DAbsolutePaths()

      for n in range( len( bg_file_array ) ):
          print( bg_file_array[n] )

      DelAllBackground3Ds()

  Return type:

    vector< string >

  Returns:

    vector<string> Vector of absolute paths to Background3D image files

openvsp.vsp.GetAllBackground3DRelativePaths()

  Get relative paths to all Background3D images in model. Note that path is relative to the model’s *.vsp3 file. Consequently, if a file has not yet been saved or assigned a file name, the relative path is meaningless.

      # Add Background3D
      AddBackground3D()
      AddBackground3D()
      AddBackground3D()

      bg_file_array = GetAllBackground3DRelativePaths()

      for n in range( len( bg_file_array ) ):
          print( bg_file_array[n] )

      DelAllBackground3Ds()

  Return type:

    vector< string >

  Returns:

    vector<string> Vector of relative paths to Background3D image files

openvsp.vsp.GetAllBackground3Ds()

  Get id’s of all Background3Ds in model

      nbg = GetNumBackground3Ds()

      # Add Background3D
      AddBackground3D()
      AddBackground3D()
      AddBackground3D()

      if GetNumBackground3Ds() != nbg + 3 :
          print( "ERROR: AddBackground3D" )

      bg_array = GetAllBackground3Ds()

      for n in range( len( bg_array ) ):
          print( bg_array[n] )

      DelAllBackground3Ds()

  Return type:

    vector< string >

  Returns:

    vector<string> Vector of Background3D IDs

openvsp.vsp.GetAllBogies(gear_id)

  Get the ParmContainer IDs of all the Bogies in the specified GearGeom, in list order.

      gear_id = AddGeom( "GEAR", "" )

      CreateAndAddBogie( gear_id )
      CreateAndAddBogie( gear_id )

      bogie_ids = GetAllBogies( gear_id )

  See also: CreateAndAddBogie, GetNumBogies, DelBogie :param [in]: gear_id string GearGeom Geom ID :rtype: vector< string > :return: vector<string> Vector of Bogie ParmContainer IDs

openvsp.vsp.GetAllDataNames(results_id)

  Get all data names for a particular result

      #==== Write Some Fake Test Results =====//
      WriteTestResults()

      res_id = FindResultsID( "Test_Results" )

      data_names = GetAllDataNames( res_id )

      if  len(data_names) != 5 : print( "---> Error: API GetAllDataNames" )

  Parameters:

    [in] – results_id string Result ID

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Array of result names

openvsp.vsp.GetAllFeaPolySparPtIDVec(pspar_id)

  Get a vector of IDs for all points in an FEA Poly Spar. Each ID is a ParmContainer ID that can be used with FindParm to access the point’s parameters such as Eta, U01, U0N, and XoC.

      wing_id = AddGeom( "WING" )

      struct_ind = AddFeaStruct( wing_id )

      pspar_id = AddFeaPart( wing_id, struct_ind, FEA_POLY_SPAR )

      AddFeaPolySparPt( pspar_id )

      pt_ids = GetAllFeaPolySparPtIDVec( pspar_id )

      if len( pt_ids ) != 3:
          print( "Error: GetAllFeaPolySparPtIDVec" )

      # Set each point's spanwise eta location
      SetParmVal( FindParm( pt_ids[0], "Eta", "FeaPolySparPoint" ), 0.1 )
      SetParmVal( FindParm( pt_ids[1], "Eta", "FeaPolySparPoint" ), 0.5 )
      SetParmVal( FindParm( pt_ids[2], "Eta", "FeaPolySparPoint" ), 0.9 )

  See also: GetFeaPolySparPtID, FindParm, SetParmVal :param [in]: pspar_id string FEA Poly Spar part ID :rtype: vector< string > :return: vector <string> Vector of Poly Spar point ParmContainer IDs

openvsp.vsp.GetAllGeometryAnalysesIDVec()

  Get a vector of all Geometry Analysis case IDs in the Geometry Analysis Manager.

      ##==== GeometryAnalysis: List all cases ====##
      ga_id_1 = AddGeometryAnalysis()
      ga_id_2 = AddGeometryAnalysis()
      ga_ids = GetAllGeometryAnalysesIDVec()
      for ga_id in ga_ids:
          print( "Geometry Analysis ID: ", ga_id )

  See also: AddGeometryAnalysis, DeleteGeometryAnalysis, DeleteAllGeometryAnalyses :rtype: vector< string > :return: vector<string> Array of all Geometry Analysis case IDs

openvsp.vsp.GetAllModes()

  Get all ModeID’s in model.

      # Illustrating use of Modes requires substantial setup of the model including components, sets, and variable presets.
      #
      # Setup boiler plate.
      pod1 = AddGeom( "POD", "" )
      wing = AddGeom( "WING", pod1 )

      SetParmVal( wing, "Trans_Attach_Flag", "Attach", ATTACH_TRANS_LMN )
      SetParmVal( wing, "L_Attach_Location", "Attach", 0.35 )

      SetSetName( SET_FIRST_USER, "NonLifting" )
      SetSetName( SET_FIRST_USER + 1, "Lifting" )

      SetSetFlag( pod1, SET_FIRST_USER, True )
      SetSetFlag( wing, SET_FIRST_USER + 1, True )

      gid = AddVarPresetGroup( "Tess" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )
      AddVarPresetParm( gid, p1 )

      p2 = FindParm( pod1, "Tess_W", "Shape" )
      AddVarPresetParm( gid, p2 )

      sid = AddVarPresetSetting( gid, "Default" )
      SaveVarPresetParmVals( gid, sid )

      sid1 = AddVarPresetSetting( gid, "Coarse" )
      SetVarPresetParmVal( gid, sid1, p1, 3 )
      SetVarPresetParmVal( gid, sid1, p2, 5 )

      sid2 = AddVarPresetSetting( gid, "Fine" )
      SetVarPresetParmVal( gid, sid, p1, 35 )
      SetVarPresetParmVal( gid, sid, p2, 21 )

      gid2 = AddVarPresetGroup( "Design" )

      p3 = FindParm( pod1, "Length", "Design" )
      AddVarPresetParm( gid2, p3 )

      p4 = FindParm( pod1, "FineRatio", "Design" )
      AddVarPresetParm( gid2, p4 )

      sid3 = AddVarPresetSetting( gid2, "Normal" )
      SaveVarPresetParmVals( gid2, sid3 )

      sid4 = AddVarPresetSetting( gid2, "ShortFat" )
      SetVarPresetParmVal( gid2, sid4, p3, 3.0 )
      SetVarPresetParmVal( gid2, sid4, p4, 5.0 )

      sid5 = AddVarPresetSetting( gid2, "LongThin" )
      SetVarPresetParmVal( gid2, sid5, p3, 20.0 )
      SetVarPresetParmVal( gid2, sid5, p4, 35.0 )

      # End of setup boiler plate.

      mid1 = CreateAndAddMode( "FatWetAreas", SET_ALL, SET_NONE )
      ModeAddGroupSetting( mid1, gid, sid1 )
      ModeAddGroupSetting( mid1, gid2, sid4 )

      mid2 = CreateAndAddMode( "ThinAero", SET_FIRST_USER, SET_FIRST_USER + 1 )
      ModeAddGroupSetting( mid2, gid, sid2 )
      ModeAddGroupSetting( mid1, gid2, sid5 )

      ApplyModeSettings( mid2 )
      Update()

      modids = GetAllModes();

  Return type:

    vector< string >

  Returns:

    array<string> array of Mode IDs

openvsp.vsp.GetAllProbes()

  Get an array of all Probe IDs from the Measure Tool

      pid1 = AddGeom( "POD", "" )

      SetParmVal( pid1, "Y_Rel_Location", "XForm", 2.0 )

      probe_id = AddProbe( pid1, 0, 0.5, 0.8, "Probe 1" )

      probe_array = GetAllProbes()

      print( "One Probe: ", False )

      print( probe_array[0] )

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Array of Probe IDs

openvsp.vsp.GetAllResultsNames()

  Get the name of all results in the Results Manager

      #==== Write Some Fake Test Results =====//
      WriteTestResults()

      results_array = GetAllResultsNames()

      for i in range(int( len(results_array) )):

          resid = FindLatestResultsID( results_array[i] )
          PrintResults( resid )

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Array of result names

openvsp.vsp.GetAllRoutingPtCoords(routing_id, symm_index)

  Get the coordinate locations along a RoutingGeom. The main copy is symm_index = 0.

      pod1 = vsp.AddGeom('POD', '')

      pod2 = vsp.AddGeom('POD', '')
      ypod2 = vsp.GetParm(pod2, 'Y_Rel_Location', 'XForm')
      vsp.SetParmVal(ypod2, 2.0)

      routing_geom = vsp.AddGeom('ROUTING', '')

      rpt0 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u0 = vsp.GetParm( rpt0, 'U', 'RoutePt')
      vsp.SetParmVal(u0, 0.0)

      rpt1 = vsp.AddRoutingPt(routing_geom, pod2, 0)

      rpt2 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u2 = vsp.GetParm( rpt2, 'U', 'RoutePt')
      vsp.SetParmVal(u2, 1.0)

      vsp.Update()
      pvec = vsp.GetAllRoutingPtCoords(rpt1, 0)

  See also: AddRoutingPt, DelRoutingPt, GetMainRoutingPtCoord, GetRoutingPtCoord, GetRoutingCurve :param [in]: routing_id string RoutingGeom Geom ID :param [in]: symm_index int Symmetry index to get coordinate of :rtype: vector< vec3d > :return: vector < vec3d > coordinate of routing points along RoutingGeom

openvsp.vsp.GetAllRoutingPtIds(routing_id)

  Get the ParmContainer IDs of all the routing points within a RoutingGeom. The vector will contain the IDs in order.

      pod1 = vsp.AddGeom('POD', '')

      pod2 = vsp.AddGeom('POD', '')
      ypod2 = vsp.GetParm(pod2, 'Y_Rel_Location', 'XForm')
      vsp.SetParmVal(ypod2, 2.0)

      routing_geom = vsp.AddGeom('ROUTING', '')

      rpt0 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u0 = vsp.GetParm( rpt0, 'U', 'RoutePt')
      vsp.SetParmVal(u0, 0.0)

      rpt1 = vsp.AddRoutingPt(routing_geom, pod2, 0)

      rpt2 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u2 = vsp.GetParm( rpt2, 'U', 'RoutePt')
      vsp.SetParmVal(u2, 1.0)

      rpts = vsp.GetAllRoutingPtIds(routing_geom)

  See also: AddRoutingPt, DelAllRoutingPt, GetRoutingPtId :param [in]: routing_id string RoutingGeom Geom ID :rtype: vector< string > :return: vector<string> Vector of routing point ParmConatiner IDs

openvsp.vsp.GetAllRulers()

  Get an array of all Ruler IDs from the Measure Tool

      pid1 = AddGeom( "POD", "" )

      SetParmVal( pid1, "Y_Rel_Location", "XForm", 2.0 )

      pid2 = AddGeom( "POD", "" )

      SetParmVal( pid2, "Z_Rel_Location", "XForm", 4.0 )

      rid1 = AddRuler( pid1, 1, 0.2, 0.3, pid2, 0, 0.2, 0.3, "Ruler 1" )

      rid2 = AddRuler( pid1, 0, 0.4, 0.6, pid1, 1, 0.8, 0.9, "Ruler 2" )

      ruler_array = GetAllRulers()

      print("Two Rulers")

      for n in range(len(ruler_array)):

          print( ruler_array[n] )

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Vector of Ruler IDs

openvsp.vsp.GetAllSubSurfIDs()

  Get a vector of all sub-surface IDs for the entire model :rtype: std::vector< std::string,std::allocator< std::string > > :return: vector<string> Array of sub-surface IDs

openvsp.vsp.GetAllUserParms()

  Get the vector of id’s for all user parameters

      id_arr = GetAllUserParms()

      print( "---> User Parm IDs: " )

      for i in range(int( len(id_arr) )):

          message = "\t" + id_arr[i] + "\n"

          print( message )

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector <string> Array of user parameter ids

openvsp.vsp.GetAnalysisDoc(analysis)

  Get the analysis documentation string

      analysis_name = "VSPAEROComputeGeometry"

      doc = GetAnalysisDoc( analysis_name )

  Parameters:

    [in] – analysis string Analysis name

  Return type:

    string

  Returns:

    string Documentation string

openvsp.vsp.GetAnalysisInputDoc(analysis, name)

  Get the documentation string for the particular analysis and input

  Parameters:

    - [in] – analysis string Analysis name

    - [in] – name string Input name

  Return type:

    string

  Returns:

    string Documentation string

openvsp.vsp.GetAnalysisInputNames(analysis)

  Get the name of every available input for a particular analysis

      analysis_name = "VSPAEROComputeGeometry"

      in_names =  GetAnalysisInputNames( analysis_name )

      print("Analysis Inputs: ")

      for i in range(int( len(in_names) )):

          print( ( "\t" + in_names[i] + "\n" ) )

  Parameters:

    [in] – analysis string Analysis name

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Array of input names

openvsp.vsp.GetAnalysisInputType(analysis, name)

  Get the data type for a particulat analysis type and input

      analysis = "VSPAEROComputeGeometry"

      inp_array = GetAnalysisInputNames( analysis )

      for j in range(int( len(inp_array) )):

          typ = GetAnalysisInputType( analysis, inp_array[j] )

  See also: RES_DATA_TYPE :param [in]: analysis string Analysis name :param [in]: name string Input name :rtype: int :return: int Data type enum (i.e. DOUBLE_DATA)

openvsp.vsp.GetAndResetUpdateCount()

  Return the OpenVSP update count and also reset it to zero.

  The OpenVSP update count tracks how many times the GUI has been told to update screens (set to dirty). It provides a simple means of testing whether the OpenVSP state has possibly changed (non-zero returned).

  Return type:

    int

  Returns:

    int OpenVSP update count

openvsp.vsp.GetAttributeBoolVal(attrID)

  Get the boolean value of a bool-type attribute

      ##==== Attribute: GetAttributeBoolVal  =====##
      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      InitVal = True
      AttrID = AddAttributeBool( CollID, "TestBoolAttr", InitVal )

      GetVal = GetAttributeBoolVal( AttrID )
      if GetVal[0] == InitVal:
          print( "Got matching Bool Value from Attribute" )
      else:
          print( "GetAttributeBoolVal error!" )

  Return type:

    vector< int >

  Returns:

    vector<int> Bool value of attribute

  Parameters:

    [in] – attrID string ID of attribute

openvsp.vsp.GetAttributeDoc(attrID)

  Return string doc of attribute by its ID

      ##==== Attributes: GetAttributeDoc =====##
      AttrID = FindAllAttributes()[0]
      AttrDoc = GetAttributeDoc(AttrID)
      print( AttrDoc )

  Return type:

    string

  Returns:

    string Return string doc of attribute by its ID

  Parameters:

    [in] – attrID string ID of attribute

openvsp.vsp.GetAttributeDoubleMatrixVal(attrID)

  Get the Double Matrix of an Double-matrix-type attribute

      ##==== Attribute: GetAttributeDoubleMatrixVal  =====##
      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      InitVal = [[0., 1.,],[-4., -1000.]]
      AttrID = AddAttributeDoubleMatrix( CollID, "TestDoubleMatrixAttr", InitVal )

      DblMatrixVal = GetAttributeDoubleMatrixVal( AttrID )
      DblMatrixVal = [list(row) for row in DblMatrixVal]

      if DblMatrixVal == InitVal:
          print( "Got matching Double Matrix Value from Attribute" )
      else:
          print( "GetAttributeDoubleMatrixVal error!" )

  Return type:

    vector< vector< double > >

  Returns:

    vector<vector <double>> Double Matrix value of attribute as vector < vector < Double > >

  Parameters:

    [in] – attrID string ID of attribute

openvsp.vsp.GetAttributeDoubleVal(attrID)

  Get the double value of a double-type attribute

      ##==== Attribute: GetAttributeDoubleVal  =====##
      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      InitVal = 3.14159
      AttrID = AddAttributeDouble( CollID, "TestDoubleAttr", InitVal )

      GetVal = GetAttributeDoubleVal( AttrID )
      if GetVal[0] == InitVal:
          print( "Got matching Double Value from Attribute" )
      else:
          print( "GetAttributeDoubleVal error!" )

  Return type:

    vector< double >

  Returns:

    vector<double> Double value of attribute

  Parameters:

    [in] – attrID string ID of attribute

openvsp.vsp.GetAttributeID(collID, attributeName, index)

  Return the ID of an attribute by its name and collection ID

      ##==== Attributes: GetAttributeID =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      AttrNames = FindAttributeNamesInCollection( CollID )
      for AttrName in AttrNames:
          AttrID = GetAttributeID( CollID, AttrName, 0 )
          print( AttrID )

  Return type:

    string

  Returns:

    string String ID of attribute based on collectionID and name

  Parameters:

    - [in] – collID string ID of an attribute collection

    - [in] – attributeName string name of an attribute in that collection

    - [in] – index int index of attribute in collection

openvsp.vsp.GetAttributeIntMatrixVal(attrID)

  Get the Int Matrix of an Int-matrix-type attribute

      ##==== Attribute: GetAttributeIntMatrixVal  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      InitVal = [[0, 1,],[-4, -1000]]
      AttrID = AddAttributeIntMatrix( CollID, "TestIntMatrixAttr", InitVal )

      IntMatrixVal = GetAttributeIntMatrixVal( AttrID )
      IntMatrixVal = [list(row) for row in IntMatrixVal]

      if IntMatrixVal == InitVal:
          print( "Got matching IntMatrix Value from Attribute" )
      else:
          print( "GetAttributeIntMatrixVal error!" )

  Return type:

    vector< vector< int > >

  Returns:

    vector<vector <int>> Int Matrix value of attribute as vector < vector < int > >

  Parameters:

    [in] – attrID string ID of attribute

openvsp.vsp.GetAttributeIntVal(attrID)

  Get the integer value of an int-type attribute

      ##==== Attribute: GetAttributeIntVal  =====//
      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      InitVal = 55
      AttrID = AddAttributeInt( CollID, "TestIntAttr", InitVal )

      GetVal = GetAttributeIntVal( AttrID )
      if GetVal[0] == InitVal:
          print( "Got matching Int Value from Attribute" )
      else:
          print( "GetAttributeIntVal error!" )

  Return type:

    vector< int >

  Returns:

    vector<int> Int value of attribute

  Parameters:

    [in] – attrID string ID of attribute

openvsp.vsp.GetAttributeName(attrID)

  Return the name of an attribute by its ID

      ##==== Attributes: GetAttributeName =====##

      AttrIDs = FindAllAttributes()

      for AttrID in AttrIDs:
          AttrName = GetAttributeName( AttrID )
          print( AttrName )

  Parameters:

    [in] – attrID string ID of an attribute

  Return type:

    string

  Returns:

    string name of attribute

openvsp.vsp.GetAttributeParmID(attrID)

  Get the parm value of a parm-type attribute

      ##==== Attribute: GetAttributeParmID  =====##
      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )

      PodID = AddGeom( "POD", "" )
      print( "---> Test Get Parm Val" )
      ParmArray = GetGeomParmIDs( PodID )

      ParmID = ParmArray[0]
      AttrID = AddAttributeParm( CollID, "TestParmAttr", ParmID )

      GetID = GetAttributeParmID( AttrID )

      if GetID[0] == ParmID:
          print( "Got matching Parm ID from Attribute" )
      else:
          print( "GetAttributeParmID error!" )

  Return type:

    vector< string >

  Returns:

    vector<string> Parm value of attribute

  Parameters:

    [in] – attrID string ID of attribute

openvsp.vsp.GetAttributeParmName(attrID)

  Get the name of the referenced parm of a parm-type attribute

      ##==== Attribute: GetAttributeParmName  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      PodID = AddGeom( "POD", "" )
      print( "---> Test Get Parm Val" )
      ParmArray = GetGeomParmIDs( PodID )
      AttrName = 'Example_Parm_Attr'
      ParmID = ParmArray[0]
      AddAttributeParm( CollID, AttrName, ParmID )
      AttrID = GetAttributeID( CollID, AttrName, 0 )
      ParmName = GetAttributeParmName( AttrID )[0]
      if ParmName == GetParmName( ParmID ):
          print( "Got matching Parm Name from Attribute" )
      else:
          print( "GetAttributeParmName error!" )

  Return type:

    vector< string >

  Returns:

    vector <string> Parm name of attribute

  Parameters:

    [in] – attrID string ID of attribute

openvsp.vsp.GetAttributeParmVal(attrID)

  Get the parm value of a parm-type attribute

      ##==== Attribute: GetAttributeParmVal  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )

      PodID = AddGeom( "POD", "" )
      print( "---> Test Get Parm Val" )
      ParmArray = GetGeomParmIDs( PodID )

      ParmID = ParmArray[0]
      AttrID = AddAttributeParm( CollID, "TestParmAttr", ParmID )

      InitVal = GetParmVal( ParmID )
      GetVal = GetAttributeParmVal( AttrID )

      if GetVal[0] == InitVal:
          print( "Got matching Parm Value from Attribute" )
      else:
          print( "GetAttributeParmVal error!" )

  Return type:

    vector< double >

  Returns:

    vector <double> Parm value of attribute

  Parameters:

    [in] – attrID string ID of attribute

openvsp.vsp.GetAttributeStringVal(attrID)

  Get the string value of a string-type attribute

      ##==== Attribute: GetAttributeStringVal  =====##
      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      InitVal = "Hello_World_of_Attributes"
      AttrID = AddAttributeString( CollID, "TestStringAttr", InitVal )

      GetVal = GetAttributeStringVal( AttrID )
      if GetVal[0] == InitVal:
          print( "Got matching String Value from Attribute" )
      else:
          print( "GetAttributeStringVal error!" )

  Return type:

    vector< string >

  Returns:

    vector<string> String value of attribute

  Parameters:

    [in] – attrID string ID of attribute

openvsp.vsp.GetAttributeType(attrID)

  Get int enum type of attribute by ID Use in conjunction with GetAttributeTypeName for getting strings or with the following enums

  > BOOL_DATA INT_DATA DOUBLE_DATA STRING_DATA VEC3D_DATA INT_MATRIX_DATA DOUBLE_MATRIX_DATA NAMEVAL_COLLECTION_DATA ATTR_COLLECTION_DATA

      ##==== Attributes: GetAttributeType =====##
      AttrID = FindAllAttributes()[0]
      AttrType = GetAttributeType( AttrID )
      print( AttrType )

  Return type:

    int

  Returns:

    int Int type of attribute

  Parameters:

    [in] – attrID string ID of attribute

openvsp.vsp.GetAttributeTypeName(attrID)

  Get the attribute’s type as a string

      ##==== Attributes: GetAttributeTypeName =====##
      AttrID = FindAllAttributes()[0]
      AttributeTypeName = GetAttributeTypeName( AttrID )
      print( AttributeTypeName )

  Return type:

    string

  Returns:

    string Type of attribute as string

  Parameters:

    [in] – attrID string ID of attribute

openvsp.vsp.GetAttributeVec3dVal(attrID)

  Get the vec3d value of a string-type attribute

      ##==== Attribute: GetAttributeVec3dVal  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      InitVal = vec3d([1., 0.5, -4.])
      AttrID = AddAttributeVec3d( CollID, "TestVec3dAttr", [InitVal] )

      Vec3dVal = GetAttributeVec3dVal( AttrID )
      if ( Vec3dVal[0].x() == InitVal.x() ) and ( Vec3dVal[0].y() == InitVal.y() ) and ( Vec3dVal[0].z() == InitVal.z() ):
          print( "Got matching Vec3d Value from Attribute" )
      else:
          print( "GetAttributeVec3dVal error!" )

  Return type:

    vector< vec3d >

  Returns:

    vector<vec3d> Vec3d value of attribute

  Parameters:

    [in] – attrID string ID of attribute

openvsp.vsp.GetAvailableCSNameVec(CSGroupIndex)

  Get the names of each available (not used) control surface in the control surface group at the specified index

      wid = AddGeom( "WING", "" ) # Add Wing

      aileron_id = AddSubSurf( wid, SS_CONTROL ) # Add Control Surface Sub-Surface

      group_index = CreateVSPAEROControlSurfaceGroup() # Empty control surface group

      cs_name_vec = GetAvailableCSNameVec( group_index )

      cs_ind_vec = [1]

      AddSelectedToCSGroup( cs_ind_vec, group_index ) # Add the first available control surface to the group

  Parameters:

    [in] – CSGroupIndex int Index of the control surface group

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector <string> Array of active control surface names

openvsp.vsp.GetBBoxSet(set)

  Get the corners of the bounding box of the specified Set.

      #==== Add Pod Geometry ====//
      pid = AddGeom( "POD" )

      Update()

      sethasmembers, xmin, ymin, zmin, xlen, ylen, zlen = GetBBoxSet( SET_ALL )

  Parameters:

    - [in] – set int Desired Set

    - [out] – xmin_out double Minimum bounding box X coordinate

    - [out] – ymin_out double Minimum bounding box Y coordinate

    - [out] – zmin_out double Minimum bounding box Z coordinate

    - [out] – xlen_out double Maximum bounding box X length

    - [out] – ylen_out double Maximum bounding box Y length

    - [out] – zlen_out double Maximum bounding box Z length

  Return type:

    boolean

  Returns:

    bool Flag indicating whether the set has members (is non-empty)

openvsp.vsp.GetBORAirfoilLowerPnts(bor_id)

  Get the coordinate points for the lower surface of an airfoil of a BOR. The XSecCurve must be of type XS_FILE_AIRFOIL

      # Add Body of Recolution
      bor_id = AddGeom( "BODYOFREVOLUTION", "" )

      ChangeBORXSecShape( bor_id, XS_FILE_AIRFOIL )

      ReadBORFileAirfoil( bor_id, "airfoil/N0012_VSP.af" )

      low_array = GetBORAirfoilLowerPnts( bor_id )

  See also: SetAirfoilPnts :param [in]: bor_id string Body of revolution Geom ID :rtype: std::vector< vec3d,std::allocator< vec3d > > :return: vector<vec3d> Vector of coordinate points for the lower airfoil surface

openvsp.vsp.GetBORAirfoilUpperPnts(bor_id)

  Get the coordinate points for the upper surface of an airfoil on a BOR. The BOR XSecCurve must be of type XS_FILE_AIRFOIL

      # Add Body of Recolution
      bor_id = AddGeom( "BODYOFREVOLUTION", "" )

      ChangeBORXSecShape( bor_id, XS_FILE_AIRFOIL )

      ReadBORFileAirfoil( bor_id, "airfoil/N0012_VSP.af" )

      up_array = GetBORAirfoilUpperPnts( bor_id )

  See also: SetAirfoilPnts :param [in]: bor_id string Body of revolution Geom ID :rtype: std::vector< vec3d,std::allocator< vec3d > > :return: vector<vec3d> Vector of coordinate points for the upper airfoil surface

openvsp.vsp.GetBORLowerCSTCoefs(bor_id)

  Get the CST coefficients for the lower surface of an airfoil of a BOR. The XSecCurve must be of type XS_CST_AIRFOIL See also: SetLowerCST :param [in]: bor_id string Body of revolution Geom ID :rtype: std::vector< double,std::allocator< double > > :return: vector<double> Vector of CST coefficients for the lower airfoil surface

openvsp.vsp.GetBORLowerCSTDegree(bor_id)

  Get the CST degree for the lower surface of an airfoil of a BOR. The XSecCurve must be of type XS_CST_AIRFOIL See also: SetLowerCST :param [in]: bor_id string Body of revolution Geom ID :rtype: int :return: int CST Degree for lower airfoil surface

openvsp.vsp.GetBORUpperCSTCoefs(bor_id)

  Get the CST coefficients for the upper surface of an airfoil of a BOR. The XSecCurve must be of type XS_CST_AIRFOIL See also: SetUpperCST :param [in]: bor_id string Body of revolution Geom ID :rtype: std::vector< double,std::allocator< double > > :return: vector<double> Vector of CST coefficients for the upper airfoil surface

openvsp.vsp.GetBORUpperCSTDegree(bor_id)

  Get the CST degree for the upper surface of an airfoil of a BOR. The XSecCurve must be of type XS_CST_AIRFOIL See also: SetUpperCST :param [in]: bor_id string Body of revolution Geom ID :rtype: int :return: int CST Degree for upper airfoil surface

openvsp.vsp.GetBORXSecShape(bor_id)

  Get the XSec type for a BOR component

      # Add Body of Recolution
      bor_id = AddGeom( "BODYOFREVOLUTION", "" )

      ChangeBORXSecShape( bor_id, XS_ROUNDED_RECTANGLE )

      if  GetBORXSecShape( bor_id ) != XS_ROUNDED_RECTANGLE : print( "ERROR: GetBORXSecShape" )

  Parameters:

    [in] – bor_id string Body of revolution Geom ID

  Return type:

    int

  Returns:

    int XSec type enum (i.e. XS_ROUNDED_RECTANGLE)

openvsp.vsp.GetBackground3DAbsolutePath(id)

  Get absolute path to specified Background3D’s image.

      # Add Background3D
      bg_id = AddBackground3D()

      SetBackground3DAbsolutePath( bg_id, "/user/me/vsp_work/front.png" )
      bg_file = GetBackground3DAbsolutePath( bg_id )

      print( bg_file )

      DelAllBackground3Ds()

  Parameters:

    [in] – id string Background3D ID

  Return type:

    string

  Returns:

    string Absolute path to Background3D image file

openvsp.vsp.GetBackground3DRelativePath(id)

  Get relative path to specified Background3D’s image. Note that path is relative to the model’s *.vsp3 file. Consequently, if a file has not yet been saved or assigned a file name, the relative path is meaningless.

      # Add Background3D
      bg_id = AddBackground3D()

      SetBackground3DRelativePath( bg_id, "front.png" )
      bg_file = GetBackground3DRelativePath( bg_id )

      print( bg_file )

      DelAllBackground3Ds()

  Parameters:

    [in] – id string Background3D ID

  Return type:

    string

  Returns:

    string Relative path to Background3D image file

openvsp.vsp.GetBoolParmVal(parm_id)

  Get the value of the specified bool type Parm

      #==== Add Prop Geometry ====//
      prop_id = AddGeom( "PROP" )

      rev_flag_id = GetParm( prop_id, "ReverseFlag", "Design" )

      reverse_flag = GetBoolParmVal( rev_flag_id )

  Parameters:

    [in] – parm_id string Parm ID

  Return type:

    boolean

  Returns:

    bool Parm value

openvsp.vsp.GetChildCollection(attachID)

  Get collection ID from any OpenVSP object If ID is an attribute collection, return the same ID back If ID is an attribute group, return its nested collection

      ##==== Attributes: GetChildCollection =====##
      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      print( CollID )

  Return type:

    string

  Returns:

    string String ID of attribute collection associated with the attachID

  Parameters:

    [in] – attachID string ID of an OpenVSP object

openvsp.vsp.GetCompleteCSNameVec()

  Get the names of all control surfaces. Some may be active (used) while others may be available.

      wid = AddGeom( "WING", "" )                             # Add Wing

      aileron_id = AddSubSurf( wid, SS_CONTROL )                      # Add Control Surface Sub-Surface

      group_index = CreateVSPAEROControlSurfaceGroup() # Empty control surface group

      cs_name_vec = GetCompleteCSNameVec()

      print( "All Control Surfaces: ", False )

      for i in range(int( len(cs_name_vec) )):

          print( cs_name_vec[i] )

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector <string> Array of all control surface names

openvsp.vsp.GetContainerName(parm_container_id)

  Get the name of the specified Parm Container

      veh_id = FindContainer( "Vehicle", 0 )

      if  GetContainerName( veh_id) != "Vehicle":       print( "---> Error: API GetContainerName" )

  Parameters:

    [in] – parm_container_id string Parm Container ID

  Return type:

    string

  Returns:

    string Parm Container name

openvsp.vsp.GetDesignVar(index)

  Get the Parm ID of the specified design variable :param [in]: index int Index of design variable :rtype: string :return: string Parm ID

openvsp.vsp.GetDesignVarType(index)

  Get the XDDM type of the specified design variable See also: XDDM_QUANTITY_TYPE :param [in]: index int Index of design variable :rtype: int :return: int XDDM type enum (XDDM_VAR or XDDM_CONST)

openvsp.vsp.GetDoubleAnalysisInput(analysis, name, index=0)

  Get the current double values for the particular analysis, input, and data index

      vinfFCinput = list( GetDoubleAnalysisInput( "ParasiteDrag", "Vinf" ) )

      vinfFCinput[0] = 629

      SetDoubleAnalysisInput( "ParasiteDrag", "Vinf", vinfFCinput )

  See also: RES_DATA_TYPE, SetDoubleAnalysisInput :param [in]: analysis string Analysis name :param [in]: name string Input name :param [in]: index int Data index :rtype: std::vector< double,std::allocator< double > > :return: vector<double> Array of analysis input values

openvsp.vsp.GetDoubleMatResults(id, name, index=0)

  Get all matrix (vector<vector<double>>) values for a particular result, name, and index :param [in]: id string Result ID :param [in]: name string Data name :param [in]: index int Data index :rtype: std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > :return: vector<vector<double>> 2D array of data values

openvsp.vsp.GetDoubleResults(id, name, index=0)

  Get all double values for a particular result, name, and index

      #==== Add Pod Geom ====//
      pid = AddGeom( "POD", "" )

      #==== Run CompGeom And View Results ====//
      mesh_id = ComputeCompGeom( SET_ALL, False, 0 )                      # Half Mesh false and no file export

      comp_res_id = FindLatestResultsID( "Comp_Geom" )                    # Find Results ID

      double_arr = GetDoubleResults( comp_res_id, "Wet_Area" )    # Extract Results

  Parameters:

    - [in] – id string Result ID

    - [in] – name string Data name

    - [in] – index int Data index

  Return type:

    std::vector< double,std::allocator< double > >

  Returns:

    vector<double> Array of data values

openvsp.vsp.GetEditXSecCtrlVec(xsec_id, non_dimensional=True)

  Get the control point vector for an EditCurveXSec. Note, the returned array of vec3d values will be represented in 2D with Z set to 0.

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      ChangeXSecShape( xsec_surf, 1, XS_EDIT_CURVE )

      # Identify XSec 1
      xsec_1 = GetXSec( xsec_surf, 1 )

      # Get the control points for the default shape
      xsec1_pts = GetEditXSecCtrlVec( xsec_1, True ) # The returned control points will not be scaled by width and height

      print( f"Normalized Bottom Point of XSecCurve: {xsec1_pts[3].x()}, {xsec1_pts[3].y()}, {xsec1_pts[3].z()}" )

  Parameters:

    - [in] – xsec_id string XSec ID

    - [in] – non_dimensional bool True to get the points non-dimensionalized, False to get them scaled by m_Width and m_Height

  Return type:

    std::vector< vec3d,std::allocator< vec3d > >

  Returns:

    vector <vec3d> Array of control points

openvsp.vsp.GetEditXSecFixedUVec(xsec_id)

  Get the vector of fixed U flags for each control point in an EditCurveXSec. The fixed U flag is used to hold the U parameter of the control point constant when performing an equal arc length reparameterization of the curve.

      # Add Wing
      wid = AddGeom( "WING" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( wid, 0 )

      ChangeXSecShape( xsec_surf, 1, XS_EDIT_CURVE )

      # Identify XSec 1
      xsec_1 = GetXSec( xsec_surf, 1 )

      fixed_u_vec = list(GetEditXSecFixedUVec( xsec_1 ))

      fixed_u_vec[3] = True # change a flag

      SetEditXSecFixedUVec( xsec_1, fixed_u_vec )

      ReparameterizeEditXSec( xsec_1 )

  See also: SetEditXSecFixedUVec, ReparameterizeEditXSec :param [in]: xsec_id string XSec ID :rtype: std::vector< bool,std::allocator< bool > > :return: vector <bool> Array of bool values for each control point

openvsp.vsp.GetEditXSecUVec(xsec_id)

  Get the U parameter vector for an EditCurveXSec. The vector will be in increasing order with a range of 0 - 1.

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      ChangeXSecShape( xsec_surf, 2, XS_EDIT_CURVE )

      # Identify XSec 2
      xsec_2 = GetXSec( xsec_surf, 2 )

      # Set XSec 2 to linear
      EditXSecConvertTo( xsec_2, LINEAR )

      u_vec = GetEditXSecUVec( xsec_2 )

      if  u_vec[1] - 0.25 > 1e-6 :
          print( "Error: GetEditXSecUVec" )

  Parameters:

    [in] – xsec_id string XSec ID

  Return type:

    std::vector< double,std::allocator< double > >

  Returns:

    vector <double> Array of U parameter values

openvsp.vsp.GetEllipsoidCpDist(surf_pnt_vec, abc_rad, V_inf)

  Generate Analytical Solution for Potential Flow for specified ellipsoid shape at input surface points for input velocity vector. Based on Munk, M. M., ‘Remarks on the Pressure Distribution over the Surface of an Ellipsoid, Moving Translationally Through a Perfect Fluid,’ NACA TN-196, June 1924. Function initially created to compare VSPAERO results to theory.

      import math
      pi = 3.14159265358979323846

      npts = 101

      abc_rad = vec3d(1.0, 2.0, 3.0)

      alpha = 5 # deg

      beta = 5 # deg

      V_inf = 100.0

      x_slice_pnt_vec = [None]*npts
      theta_vec = [None]*npts

      theta_vec[0] = 0

      for i in range(1, npts):
          theta_vec[i] = theta_vec[i-1] + (2 * pi / (npts - 1))

      for i in range(npts):

          x_slice_pnt_vec[i] = vec3d( 0, abc_rad.y() * math.cos( theta_vec[i] ), abc_rad.z() * math.sin( theta_vec[i] ) )

      V_vec = vec3d( ( V_inf * math.cos( alpha*pi/180 ) * math.cos( beta*pi/180 ) ), ( V_inf * math.sin( beta*pi/180 ) ), ( V_inf * math.sin( alpha*pi/180 ) * math.cos( beta*pi/180 ) ) )

      cp_dist = GetEllipsoidCpDist( x_slice_pnt_vec, abc_rad, V_vec )

  See also: GetEllipsoidSurfPnts :param [in]: surf_pnt_vec vector<vec3d> Vector of points on the ellipsoid surface to assess :param [in]: abc_rad vec3d Radius along the A (X), B (Y), and C (Z) axes :param [in]: V_inf vec3d 3D components of freestream velocity :rtype: std::vector< double,std::allocator< double > > :return: vector<double> Vector of Cp results corresponding to each point in surf_pnt_arr

openvsp.vsp.GetEllipsoidSurfPnts(center, abc_rad, u_npts=20, w_npts=20)

  Generate the surface coordinate points for a ellipsoid at specified center of input radius along each axis. Based on the MATLAB function ellipsoid (https://in.mathworks.com/help/matlab/ref/ellipsoid.html). See also: GetVKTAirfoilPnts :param [in]: center vec3d 3D location of the ellipsoid center :param [in]: abc_rad vec3d Radius along the A (X), B (Y), and C (Z) axes :param [in]: u_npts int Number of points in the U direction :param [in]: w_npts int Number of points in the W direction :rtype: std::vector< vec3d,std::allocator< vec3d > > :return: vector<vec3d> Array of coordinates describing the ellipsoid surface

openvsp.vsp.GetFeaBCIDVec(fea_struct_id)

  Return a vector of FEA BC ID’s for a structure

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      struct_id = GetFeaStructID( pod_id, struct_ind );

      #==== Add BC ====//
      bc_id = AddFeaBC( struct_id, FEA_BC_STRUCTURE )

      bc_id_vec = GetFeaBCIDVec( struct_id )

  Parameters:

    [in] – fea_struct_id string FEA Structure ID

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Array of FEA BC IDs

openvsp.vsp.GetFeaPartID(fea_struct_id, fea_part_index)

  Get the Parm ID of an FEA Part, identified from a FEA Structure Parm ID and FEA Part index.

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      struct_id = GetFeaStructID( pod_id, struct_ind )

      #==== Add Bulkead ====//
      bulkhead_id = AddFeaPart( pod_id, struct_ind, FEA_SLICE )

      Update()

      if  bulkhead_id != GetFeaPartID( struct_id, 1 ) : # These should be equivalent (index 0 is skin)

          print( "Error: GetFeaPartID" )

  Parameters:

    - [in] – fea_struct_id string FEA Structure ID

    - [in] – fea_part_index int FEA Part index

  Return type:

    string

  Returns:

    string FEA Part ID

openvsp.vsp.GetFeaPartIDVec(fea_struct_id)

  Get the IDs of all FEA Parts in the given FEA Structure

      #==== Add Geometries ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      struct_id = GetFeaStructID( pod_id, struct_ind )

      #==== Add FEA Parts ====//
      slice_id = AddFeaPart( pod_id, struct_ind, FEA_SLICE )
      dome_id = AddFeaPart( pod_id, struct_ind, FEA_DOME )

      part_id_vec = GetFeaPartIDVec( struct_id ) # Should include slice_id & dome_id

  See also: NumFeaParts :param [in]: fea_struct_id string FEA Structure ID :rtype: std::vector< std::string,std::allocator< std::string > > :return: vector<string> Array of FEA Part IDs

openvsp.vsp.GetFeaPartName(part_id)

  Get the name of an FEA Part

      #==== Add Fuselage Geometry ====//
      fuse_id = AddGeom( "FUSELAGE" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( fuse_id )

      #==== Add Bulkead ====//
      bulkhead_id = AddFeaPart( fuse_id, struct_ind, FEA_SLICE )

      name = "example_name"
      SetFeaPartName( bulkhead_id, name )

      if  name != GetFeaPartName( bulkhead_id ) : # These should be equivalent

          print( "Error: GetFeaPartName" )

  See also: SetFeaPartName :param [in]: part_id string FEA Part ID :rtype: string :return: string FEA Part name

openvsp.vsp.GetFeaPartPerpendicularSparID(part_id)

  Get the ID of the perpendicular spar for an FEA Rib or Rib Array. Note, the FEA Rib or Rib Array doesn’t have to have “SPAR_NORMAL” set for the “PerpendicularEdgeType” Parm for this function to still return a value.

      #==== Add Wing Geometry ====//
      wing_id = AddGeom( "WING" )

      #==== Add FeaStructure to Wing ====//
      struct_ind = AddFeaStruct( wing_id )

      #==== Add Rib ====//
      rib_id = AddFeaPart( wing_id, struct_ind, FEA_RIB )

      #==== Add Spars ====//
      spar_id_1 = AddFeaPart( wing_id, struct_ind, FEA_SPAR )
      spar_id_2 = AddFeaPart( wing_id, struct_ind, FEA_SPAR )

      SetParmVal( FindParm( spar_id_1, "RelCenterLocation", "FeaPart" ), 0.25 )
      SetParmVal( FindParm( spar_id_2, "RelCenterLocation", "FeaPart" ), 0.75 )

      #==== Set Perpendicular Edge type to SPAR ====//
      SetParmVal( FindParm( rib_id, "PerpendicularEdgeType", "FeaRib" ), SPAR_NORMAL )

      SetFeaPartPerpendicularSparID( rib_id, spar_id_2 )

      if  spar_id_2 != GetFeaPartPerpendicularSparID( rib_id ) :
          print( "Error: GetFeaPartPerpendicularSparID" )

  See also: FEA_RIB_NORMAL, SetFeaPartPerpendicularSparID :param [in]: part_id string FEA Part ID (Rib or Rib Array Type) :rtype: string :return: string Perpendicular FEA Spar ID

openvsp.vsp.GetFeaPartType(part_id)

  Get the type of an FEA Part

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      #==== Add Slice ====//
      slice_id = AddFeaPart( pod_id, struct_ind, FEA_SLICE )

      if  FEA_SLICE != GetFeaPartType( slice_id ) : # These should be equivalent

          print( "Error: GetFeaPartType" )

  See also: FEA_PART_TYPE :param [in]: part_id string FEA Part ID :rtype: int :return: int FEA Part type enum

openvsp.vsp.GetFeaPolySparNumPt(pspar_id)

  Get the number of points in an FEA Poly Spar. A newly created Poly Spar contains two points (the inboard and outboard endpoints).

      wing_id = AddGeom( "WING" )

      struct_ind = AddFeaStruct( wing_id )

      pspar_id = AddFeaPart( wing_id, struct_ind, FEA_POLY_SPAR )

      # A new Poly Spar starts with 2 points
      if GetFeaPolySparNumPt( pspar_id ) != 2:
          print( "Error: GetFeaPolySparNumPt" )

  See also: AddFeaPolySparPt, InsertFeaPolySparPt, DelFeaPolySparPt, DelAllFeaPolySparPt :param [in]: pspar_id string FEA Poly Spar part ID :rtype: int :return: int Number of points in the Poly Spar

openvsp.vsp.GetFeaPolySparPtID(pspar_id, index)

  Get the ID of a point in an FEA Poly Spar. The returned ID is a ParmContainer ID that can be used with FindParm to access the point’s parameters such as Eta, U01, U0N, and XoC.

      wing_id = AddGeom( "WING" )

      struct_ind = AddFeaStruct( wing_id )

      pspar_id = AddFeaPart( wing_id, struct_ind, FEA_POLY_SPAR )

      pt_id = GetFeaPolySparPtID( pspar_id, 0 )

      # Set the spanwise location of the inboard point to eta = 0.1
      SetParmVal( FindParm( pt_id, "Eta", "FeaPolySparPoint" ), 0.1 )

      pt_id_1 = GetFeaPolySparPtID( pspar_id, 1 )

      # Set the spanwise location of the outboard point to eta = 0.9
      SetParmVal( FindParm( pt_id_1, "Eta", "FeaPolySparPoint" ), 0.9 )

  See also: GetAllFeaPolySparPtIDVec, FindParm, SetParmVal :param [in]: pspar_id string FEA Poly Spar part ID :param [in]: index int Index of the point :rtype: string :return: string ID of the Poly Spar point ParmContainer

openvsp.vsp.GetFeaPolySparPtName(pspar_id, index)

  Get the name of a point in an FEA Poly Spar.

      wing_id = AddGeom( "WING" )

      struct_ind = AddFeaStruct( wing_id )

      pspar_id = AddFeaPart( wing_id, struct_ind, FEA_POLY_SPAR )

      SetFeaPolySparPtName( pspar_id, 0, "InboardPt" )

      name = GetFeaPolySparPtName( pspar_id, 0 )

      print( "Point 0 name: " + name )

  See also: SetFeaPolySparPtName :param [in]: pspar_id string FEA Poly Spar part ID :param [in]: index int Index of the point :rtype: string :return: string Name of the point

openvsp.vsp.GetFeaStructID(geom_id, fea_struct_ind)

  Get the ID of an FEA Structure

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      struct_id = GetFeaStructID( pod_id, struct_ind )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – fea_struct_ind int FEA Structure index

  Return type:

    string

  Returns:

    string FEA Structure ID

openvsp.vsp.GetFeaStructIDVec()

  Get the IDs of all FEA Structures in the vehicle

      #==== Add Geometries ====//
      pod_id = AddGeom( "POD" )
      wing_id = AddGeom( "WING" )

      #==== Add FeaStructures ====//
      pod_struct_ind = AddFeaStruct( pod_id )
      wing_struct_ind = AddFeaStruct( wing_id )

      struct_id_vec = GetFeaStructIDVec()

  See also: NumFeaStructures :rtype: std::vector< std::string,std::allocator< std::string > > :return: vector<string> Array of FEA Structure IDs

openvsp.vsp.GetFeaStructIndex(struct_id)

  Get the index of an FEA Structure in its Parent Geom’s vector of Structures

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind_1 = AddFeaStruct( pod_id )

      struct_ind_2 = AddFeaStruct( pod_id )

      struct_id_2 = GetFeaStructID( pod_id, struct_ind_2 )

      DeleteFeaStruct( pod_id, struct_ind_1 )

      struct_ind_2_new = GetFeaStructIndex( struct_id_2 )

  Parameters:

    [in] – struct_id string FEA Structure ID

  Return type:

    int

  Returns:

    int FEA Structure index

openvsp.vsp.GetFeaStructName(geom_id, fea_struct_ind)

  Get the name of an FEA Structure. The FEA Structure name functions as the the Parm Container name

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      #==== Get Structure Name ====//
      parm_container_name = GetFeaStructName( pod_id, struct_ind )

      display_name = "Current Structure Parm Container Name: " + parm_container_name + "\n"

      print( display_name )

  See also: FindContainer, SetFeaStructName :param [in]: geom_id string Parent Geom ID :param [in]: fea_struct_ind int FEA Structure index :rtype: string :return: string Name for the FEA Structure

openvsp.vsp.GetFeaStructParentGeomID(struct_id)

  Get the Parent Geom ID for an FEA Structure

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      struct_id = GetFeaStructID( pod_id, struct_ind )

      #==== Get Parent Geom ID and Index ====//
      parent_id = GetFeaStructParentGeomID( struct_id )

  Parameters:

    [in] – struct_id string FEA Structure ID

  Return type:

    string

  Returns:

    string Parent Geom ID

openvsp.vsp.GetFeaSubSurfIDVec(fea_struct_id)

  Get the IDs of all FEA SubSurfaces in the given FEA Structure

      #==== Add Geometries ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      struct_id = GetFeaStructID( pod_id, struct_ind )

      #==== Add SubSurfaces ====//
      line_array_id = AddFeaSubSurf( pod_id, struct_ind, SS_LINE_ARRAY )
      rectangle_id = AddFeaSubSurf( pod_id, struct_ind, SS_RECTANGLE )

      part_id_vec = GetFeaSubSurfIDVec( struct_id ) # Should include line_array_id & rectangle_id

  See also: NumFeaSubSurfs :param [in]: fea_struct_id string FEA Structure ID :rtype: std::vector< std::string,std::allocator< std::string > > :return: vector<string> Array of FEA Part IDs

openvsp.vsp.GetFeaSubSurfIndex(ss_id)

  Get the index of an FEA SubSurface give the SubSurface ID

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      #==== Add Slice ====//
      slice_id = AddFeaPart( pod_id, struct_ind, FEA_SLICE )

      #==== Add LineArray ====//
      line_array_id = AddFeaSubSurf( pod_id, struct_ind, SS_LINE_ARRAY )

      #==== Add Rectangle ====//
      rect_id = AddFeaSubSurf( pod_id, struct_ind, SS_RECTANGLE )

      if  1 != GetFeaSubSurfIndex( rect_id ) : # These should be equivalent

          print( "Error: GetFeaSubSurfIndex" )

  Parameters:

    [in] – ss_id string FEA SubSurface ID

  Return type:

    int

  Returns:

    int FEA SubSurface Index

openvsp.vsp.GetFeaSubSurfName(subsurf_id)

  Set the name of an FEA SubSurface

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      #==== Add LineArray ====//
      line_array_id = AddFeaSubSurf( pod_id, struct_ind, SS_LINE_ARRAY )

      name = "example_name"
      SetFeaSubSurfName( line_array_id, name )

      if  name != GetFeaSubSurfName( line_array_id ) : # These should be equivalent
          print( "Error: GetFeaSubSurfName" )

  Parameters:

    [in] – subsurf_id string FEA SubSurface ID

  Return type:

    string

  Returns:

    string FEA SubSurf name

openvsp.vsp.GetFeatureLinePnts(geom_id)

  Get the points along the feature lines of a particular Geom :param [in]: geom_id string Geom ID :rtype: std::vector< vec3d,std::allocator< vec3d > > :return: vector<vec3d> Array of points along the Geom’s feature lines

openvsp.vsp.GetGeomBBoxMax(geom_id, main_surf_ind=0, ref_frame_is_absolute=True)

  Get the the maximum coordinate of the bounding box of a Geom with given main surface index. The Geom bounding box may be specified in absolute or body reference frame.

      #==== Add Pod Geometry ====//
      pid = AddGeom( "POD" )

      SetParmVal( FindParm( pid, "Y_Rotation", "XForm" ), 45 )
      SetParmVal( FindParm( pid, "Z_Rotation", "XForm" ), 25 )

      Update()

      max_pnt = GetGeomBBoxMax( pid, 0, False )

  See also: GetGeomBBoxMin :param [in]: geom_id string Geom ID :param [in]: main_surf_ind int Main surface index :param [in]: ref_frame_is_absolute bool Flag to specify absolute or body reference frame :rtype: `vec3d` :return: vec3d Maximum coordinate of the bounding box

openvsp.vsp.GetGeomBBoxMin(geom_id, main_surf_ind=0, ref_frame_is_absolute=True)

  Get the the minimum coordinate of the bounding box of a Geom with given main surface index. The Geom bounding box may be specified in absolute or body reference frame.

      #==== Add Pod Geometry ====//
      pid = AddGeom( "POD" )

      SetParmVal( FindParm( pid, "Y_Rotation", "XForm" ), 45 )
      SetParmVal( FindParm( pid, "Z_Rotation", "XForm" ), 25 )

      Update()

      min_pnt = GetGeomBBoxMin( pid, 0, False )

  See also: GetGeomBBoxMax :param [in]: geom_id string Geom ID :param [in]: main_surf_ind int Main surface index :param [in]: ref_frame_is_absolute bool Flag to specify absolute or body reference frame :rtype: `vec3d` :return: vec3d Minimum coordinate of the bounding box

openvsp.vsp.GetGeomChildren(geom_id)

  Get the IDs for each child of the input parent Geom.

      #==== Add Parent and Child Geometry ====//
      pod1 = AddGeom( "POD" )

      pod2 = AddGeom( "POD", pod1 )

      pod3 = AddGeom( "POD", pod2 )

      print( "Children of Pod #1: " )

      children = GetGeomChildren( pod1 )

      for i in range(int( len(children) )):

          print( "\t", False )
          print( children[i] )

  Parameters:

    [in] – geom_id string Geom ID

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Vector of child Geom IDs

openvsp.vsp.GetGeomName(geom_id)

  Get the name of a specific Geom

      #==== Add Pod Geometry ====//
      pid = AddGeom( "POD", "" )

      SetGeomName( pid, "ExamplePodName" )

      name_str = "Geom Name: " + GetGeomName( pid )

      print( name_str )

  Parameters:

    [in] – geom_id string Geom ID

  Return type:

    string

  Returns:

    string Geom name

openvsp.vsp.GetGeomParent(geom_id)

  Get the parent Geom ID for the input child Geom. “NONE” is returned if the Geom has no parent.

      #==== Add Parent and Child Geometry ====//
      pod1 = AddGeom( "POD" )

      pod2 = AddGeom( "POD", pod1 )

      print( "Parent ID of Pod #2: ", False )

      print( GetGeomParent( pod2 ) )

  Parameters:

    [in] – geom_id string Geom ID

  Return type:

    string

  Returns:

    string Parent Geom ID

openvsp.vsp.GetGeomParmIDs(geom_id)

  Get all Parm IDs associated with this Geom Parm container

      #==== Add Pod Geometry ====//
      pid = AddGeom( "POD", "" )

      print( "---> Test Get Parm Arrays" )

      parm_array = GetGeomParmIDs( pid )

      if  len(parm_array) < 1 : print( "---> Error: API GetGeomParmIDs " )

  Parameters:

    [in] – geom_id string Geom ID

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Array of Parm IDs

openvsp.vsp.GetGeomSet(name)

  Get an array of Geom IDs for the specified set name

      SetSetName( 3, "SetFromScript" )

      geom_arr1 = GetGeomSetAtIndex( 3 )

      geom_arr2 = GetGeomSet( "SetFromScript" )

      if  len(geom_arr1) != len(geom_arr2) : print( "---> Error: API GetGeomSet " )

  Parameters:

    [in] – name string const string set name

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    array<string> array of Geom IDs

openvsp.vsp.GetGeomSetAtIndex(index)

  Get an array of Geom IDs for the specified set index

      SetSetName( 3, "SetFromScript" )

      geom_arr1 = GetGeomSetAtIndex( 3 )

      geom_arr2 = GetGeomSet( "SetFromScript" )

      if  len(geom_arr1) != len(geom_arr2) : print( "---> Error: API GetGeomSet " )

  See also: SET_TYPE :param [in]: index int Set index :rtype: std::vector< std::string,std::allocator< std::string > > :return: vector<string> Array of Geom IDs

openvsp.vsp.GetGeomSetCollection(index)

  Get collection ID from a vehicle’s GeomSet

      ##==== Attributes: GetGeomSetCollection =====##
      CollID = GetGeomSetCollection( 0 )
      print( CollID )

  Return type:

    string

  Returns:

    string String ID of attribute collection associated with the geom set

  Parameters:

    [in] – index int Geom set

openvsp.vsp.GetGeomTypeName(geom_id)

  Get the type name of specified Geom (i.e. FUSELAGE)

      #==== Add Wing Geometry ====//
      wing_id = AddGeom( "WING" )

      print( "Geom Type Name: ", False )

      print( GetGeomTypeName( wing_id ) )

  Parameters:

    [in] – geom_id string Geom ID

  Return type:

    string

  Returns:

    string Geom type name

openvsp.vsp.GetGeomTypes()

  Get an array of all Geom types (i.e FUSELAGE, POD, etc.)

      #==== Add Pod Geometries ====//
      pod1 = AddGeom( "POD", "" )
      pod2 = AddGeom( "POD", "" )

      type_array = GetGeomTypes()

      if ( type_array[0] != "POD" ): print( "---> Error: API GetGeomTypes  " )

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Array of Geom type names

openvsp.vsp.GetGeomVSPSurfCfdType(geom_id, main_surf_ind=0)

  Get the VSP surface CFD type of the specified Geom

      #==== Add Wing Geometry ====//
      wing_id = AddGeom( "WING" )

      if  GetGeomVSPSurfCfdType( wing_id ) != CFD_NORMAL :
          print( "---> Error: API GetGeomVSPSurfCfdType " )

  See also: VSP_SURF_CFD_TYPE :param [in]: geom_id string Geom ID :param [in]: main_surf_ind int Main surface index :rtype: int :return: int VSP surface CFD type enum (i.e. CFD_TRANSPARENT)

openvsp.vsp.GetGeomVSPSurfType(geom_id, main_surf_ind=0)

  Get the VSP surface type of the specified Geom

      #==== Add Wing Geometry ====//
      wing_id = AddGeom( "WING" )

      if  GetGeomVSPSurfType( wing_id ) != WING_SURF :
          print( "---> Error: API GetGeomVSPSurfType " )

  See also: VSP_SURF_TYPE :param [in]: geom_id string Geom ID :param [in]: main_surf_ind int Main surface index :rtype: int :return: int VSP surface type enum (i.e. DISK_SURF)

openvsp.vsp.GetGroupName(group_id)

  Get Variable Preset group name

      # Add Pod Geom
      pod1 = AddGeom( "POD", "" )

      gid = AddVarPresetGroup( "Tess" )

      name = GetGroupName( gid )

  Parameters:

    [in] – group_id string Var Preset Group ID

  Return type:

    string

  Returns:

    string Var Preset Group name

openvsp.vsp.GetHersheyBarDragDist(npts, alpha, Vinf, span, full_span_flag=False)

  Get the theoretical drag (Cd) distribution for a Hershey Bar wing with unit chord length using Glauert’s Method. This function was initially created to compare VSPAERO results to Lifting Line Theory. If full_span_flag is set to true symmetry is applied to the results.

      pi = 3.14159265358979323846
      # Compute theoretical lift and drag distributions using 100 points
      Vinf = 100

      halfAR = 20

      alpha_deg = 10

      n_pts = 100

      cl_dist_theo = GetHersheyBarLiftDist( int( n_pts ), alpha_deg*pi/180, Vinf, ( 2 * halfAR ), False )

      cd_dist_theo = GetHersheyBarDragDist( int( n_pts ), alpha_deg*pi/180, Vinf, ( 2 * halfAR ), False )

  Parameters:

    - [in] – npts int Number of points along the span to assess

    - [in] – alpha double Wing angle of attack (Radians)

    - [in] – Vinf double Freestream velocity

    - [in] – span double Hershey Bar full-span. Note, only half is used in the calculation

    - [in] – full_span_flag bool Flag to apply symmetry to results (default: false)

  Return type:

    std::vector< vec3d,std::allocator< vec3d > >

  Returns:

    vector<vec3d> Theoretical coefficient of drag distribution array (size = 2*npts if full_span_flag = true)

openvsp.vsp.GetHersheyBarLiftDist(npts, alpha, Vinf, span, full_span_flag=False)

  Get the theoretical lift (Cl) distribution for a Hershey Bar wing with unit chord length using Glauert’s Method. This function was initially created to compare VSPAERO results to Lifting Line Theory. If full_span_flag is set to true symmetry is applied to the results.

      pi = 3.14159265358979323846
      # Compute theoretical lift and drag distributions using 100 points
      Vinf = 100

      halfAR = 20

      alpha_deg = 10

      n_pts = 100

      cl_dist_theo = GetHersheyBarLiftDist( int( n_pts ), alpha_deg*pi/180, Vinf, ( 2 * halfAR ), False )

      cd_dist_theo = GetHersheyBarDragDist( int( n_pts ), alpha_deg*pi/180, Vinf, ( 2 * halfAR ), False )

  Parameters:

    - [in] – npts int Number of points along the span to assess

    - [in] – alpha double Wing angle of attack (Radians)

    - [in] – Vinf double Freestream velocity

    - [in] – span double Hershey Bar full-span. Note, only half is used in the calculation

    - [in] – full_span_flag bool Flag to apply symmetry to results

  Return type:

    std::vector< vec3d,std::allocator< vec3d > >

  Returns:

    vector<vec3d> Theoretical coefficient of lift distribution array (size = 2*npts if full_span_flag = true)

openvsp.vsp.GetIntAnalysisInput(analysis, name, index=0)

  Get the current integer values for the particular analysis, input, and data index

      #==== Analysis: VSPAero Compute Geometry ====//
      analysis_name = "VSPAEROComputeGeometry"

      # Set to panel method
      thick_set = GetIntAnalysisInput( analysis_name, "GeomSet" )
      thin_set = GetIntAnalysisInput( analysis_name, "ThinGeomSet" )

      thick_set = [vsp.SET_NONE]
      thin_set = [vsp.SET_ALL]

      SetIntAnalysisInput( analysis_name, "GeomSet", thick_set )
      SetIntAnalysisInput( analysis_name, "ThinGeomSet", thin_set )

  See also: RES_DATA_TYPE, SetIntAnalysisInput :param [in]: analysis string Analysis name :param [in]: name string Input name :param [in]: index int Data index :rtype: std::vector< int,std::allocator< int > > :return: vector<int> Array of analysis input values

openvsp.vsp.GetIntParmVal(parm_id)

  Get the value of the specified int type Parm

      #==== Add Prop Geometry ====//
      prop_id = AddGeom( "PROP" )

      num_blade_id = GetParm( prop_id, "NumBlade", "Design" )

      num_blade = GetIntParmVal( num_blade_id )

  Parameters:

    [in] – parm_id string Parm ID

  Return type:

    int

  Returns:

    double Parm value

openvsp.vsp.GetIntResults(id, name, index=0)

  Get all integer values for a particular result, name, and index

      #==== Write Some Fake Test Results =====//
      WriteTestResults()

      res_id = FindResultsID( "Test_Results" )

      if ( GetNumData( res_id, "Test_Int" ) != 2 ): print( "---> Error: API GetNumData " )

      int_arr = GetIntResults( res_id, "Test_Int", 0 )

      if  int_arr[0] != 1 : print( "---> Error: API GetIntResults" )

      int_arr = GetIntResults( res_id, "Test_Int", 1 )

      if  int_arr[0] != 2 : print( "---> Error: API GetIntResults" )

  Parameters:

    - [in] – id string Result ID

    - [in] – name string Data name

    - [in] – index int Data index

  Return type:

    std::vector< int,std::allocator< int > >

  Returns:

    vector<int> Array of data values

openvsp.vsp.GetLinkIndex(name)

  Find the index of a specific advanced link.

      pod = AddGeom( "POD", "" )
      length = FindParm( pod, "Length", "Design" )
      x_pos = GetParm( pod, "X_Rel_Location", "XForm" )

      AddAdvLink( "ExampleLink" )
      indx = GetLinkIndex( "ExampleLink" )
      AddAdvLinkInput( indx, length, "len" )
      AddAdvLinkOutput( indx, x_pos, "x" )

      SetAdvLinkCode( indx, "x = 10.0 - len;" )

      BuildAdvLinkScript( indx )

  Parameters:

    [in] – name string Name for advanced link

  Return type:

    int

  Returns:

    int index for advanced link

openvsp.vsp.GetLowerCSTCoefs(xsec_id)

  Get the CST coefficients for the lower surface of an airfoil. The XSec must be of type XS_CST_AIRFOIL See also: SetLowerCST :param [in]: xsec_id string XSec ID :rtype: std::vector< double,std::allocator< double > > :return: vector<double> Vector of CST coefficients for the lower airfoil surface

openvsp.vsp.GetLowerCSTDegree(xsec_id)

  Get the CST degree for the lower surface of an airfoil. The XSec must be of type XS_CST_AIRFOIL See also: SetLowerCST :param [in]: xsec_id string XSec ID :rtype: int :return: int CST Degree for lower airfoil surface

openvsp.vsp.GetMainRoutingPtCoord(pt_id)

  Get the main coordinate location a routing point. The main location is the location of the base copy before symmetry has been applied.

      pod1 = vsp.AddGeom('POD', '')

      pod2 = vsp.AddGeom('POD', '')
      ypod2 = vsp.GetParm(pod2, 'Y_Rel_Location', 'XForm')
      vsp.SetParmVal(ypod2, 2.0)

      routing_geom = vsp.AddGeom('ROUTING', '')

      rpt0 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u0 = vsp.GetParm( rpt0, 'U', 'RoutePt')
      vsp.SetParmVal(u0, 0.0)

      rpt1 = vsp.AddRoutingPt(routing_geom, pod2, 0)

      rpt2 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u2 = vsp.GetParm( rpt2, 'U', 'RoutePt')
      vsp.SetParmVal(u2, 1.0)

      vsp.Update()
      p1 = vsp.GetMainRoutingPtCoord(rpt1)

  See also: AddRoutingPt, DelRoutingPt, GetRoutingPtCoord, GetAllRoutingPtCoords, GetRoutingCurve :param [in]: pt_id string ParmContainer ID of desired routing point :rtype: `vec3d` :return: vec3d coordinate of main routing point

openvsp.vsp.GetMaterialNames()

  Get the names of all visualization materials

      mat_array = GetMaterialNames()

      for i in range(int( len(mat_array) )):
          print( mat_array[i] )

  Return type:

    vector< string >

  Returns:

    vector<string> Array of material names

openvsp.vsp.GetNumActuatorDisks()

  Get the number of actuator disks in the current VSPAERO set. This is equivalent to the number of disk surfaces in the VSPAERO set.

      # Set VSPAERO set index to SET_ALL
      SetParmVal( FindParm( FindContainer( "VSPAEROSettings", 0 ), "GeomSet", "VSPAERO" ), SET_ALL )

      # Add a propeller
      prop_id = AddGeom( "PROP", "" )
      SetParmValUpdate( prop_id, "PropMode", "Design", PROP_BLADES )

      num_disk = GetNumActuatorDisks() # Should be 0

      SetParmValUpdate( prop_id, "PropMode", "Design", PROP_DISK )

      num_disk = GetNumActuatorDisks() # Should be 1

  See also: PROP_MODE :rtype: int :return: int Number of actuator disks in the current VSPAERO set

openvsp.vsp.GetNumAnalysis()

  Get the number of analysis types available in the Analysis Manager

      nanalysis = GetNumAnalysis()

      print( f"Number of registered analyses: {nanalysis}" )

  Return type:

    int

  Returns:

    int Number of analyses

openvsp.vsp.GetNumAnalysisInputData(analysis, name)

  Get the documentation string for the particular analysis and input :param [in]: analysis string Analysis name :param [in]: name string Input name :rtype: int :return: int Documentation string

openvsp.vsp.GetNumBackground3Ds()

  Get Number of Background3D’s in a model

      nbg = GetNumBackground3Ds()

      # Add Background3D
      bg_id = AddBackground3D()

      if GetNumBackground3Ds() != nbg + 1 :
          print( "ERROR: AddBackground3D" )

      DelBackground3D( bg_id )

  Return type:

    int

  Returns:

    int Number of Background3D’s in model

openvsp.vsp.GetNumBogies(gear_id)

  Get the number of Bogies in the specified GearGeom.

      gear_id = AddGeom( "GEAR", "" )

      CreateAndAddBogie( gear_id )
      CreateAndAddBogie( gear_id )

      num_bogie = GetNumBogies( gear_id )            # num_bogie == 2

  See also: CreateAndAddBogie, GetAllBogies :param [in]: gear_id string GearGeom Geom ID :rtype: int :return: int Number of Bogies in the specified GearGeom

openvsp.vsp.GetNumControlSurfaceGroups()

  Get the total number of control surface groups

      wid = AddGeom( "WING", "" )                             # Add Wing

      aileron_id = AddSubSurf( wid, SS_CONTROL )                      # Add Control Surface Sub-Surface

      #==== Add Horizontal tail and set some parameters =====//
      horiz_id = AddGeom( "WING", "" )

      SetGeomName( horiz_id, "Vert" )

      SetParmValUpdate( horiz_id, "TotalArea", "WingGeom", 10.0 )
      SetParmValUpdate( horiz_id, "X_Rel_Location", "XForm", 8.5 )

      elevator_id = AddSubSurf( horiz_id, SS_CONTROL )                      # Add Control Surface Sub-Surface

      AutoGroupVSPAEROControlSurfaces()

      num_group = GetNumControlSurfaceGroups()

      if  num_group != 2 : print( "Error: GetNumControlSurfaceGroups" )

  Return type:

    int

  Returns:

    int Number of control surface groups

openvsp.vsp.GetNumData(results_id, data_name)

  Get the number of data values for a given result ID and data name

      #==== Write Some Fake Test Results =====//
      WriteTestResults()

      res_id = FindResultsID( "Test_Results" )

      if ( GetNumData( res_id, "Test_Int" ) != 2 ): print( "---> Error: API GetNumData " )

      int_arr = GetIntResults( res_id, "Test_Int", 0 )

      if  int_arr[0] != 1 : print( "---> Error: API GetIntResults" )

      int_arr = GetIntResults( res_id, "Test_Int", 1 )

      if  int_arr[0] != 2 : print( "---> Error: API GetIntResults" )

  Parameters:

    - [in] – results_id string Result ID

    - [in] – data_name string Data name

  Return type:

    int

  Returns:

    int Number of data values

openvsp.vsp.GetNumDesignVars()

  Get the number of design variables :rtype: int :return: int Number of design variables

openvsp.vsp.GetNumMainSurfs(geom_id)

  Get the number of main surfaces for the specified Geom. Multiple main surfaces may exist for CustoGeoms, propellors, etc., but does not include surfaces created due to symmetry.

      #==== Add Prop Geometry ====//
      prop_id = AddGeom( "PROP" )

      num_surf = 0

      num_surf = GetNumMainSurfs( prop_id ) # Should be the same as the number of blades

      print( "Number of Propeller Surfaces: ", False )

      print( num_surf )

  Parameters:

    [in] – geom_id string Geom ID

  Return type:

    int

  Returns:

    int Number of main surfaces

openvsp.vsp.GetNumModes()

  Get number of Modes in model.

      # Illustrating use of Modes requires substantial setup of the model including components, sets, and variable presets.
      #
      # Setup boiler plate.
      pod1 = AddGeom( "POD", "" )
      wing = AddGeom( "WING", pod1 )

      SetParmVal( wing, "Trans_Attach_Flag", "Attach", ATTACH_TRANS_LMN )
      SetParmVal( wing, "L_Attach_Location", "Attach", 0.35 )

      SetSetName( SET_FIRST_USER, "NonLifting" )
      SetSetName( SET_FIRST_USER + 1, "Lifting" )

      SetSetFlag( pod1, SET_FIRST_USER, True )
      SetSetFlag( wing, SET_FIRST_USER + 1, True )

      gid = AddVarPresetGroup( "Tess" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )
      AddVarPresetParm( gid, p1 )

      p2 = FindParm( pod1, "Tess_W", "Shape" )
      AddVarPresetParm( gid, p2 )

      sid = AddVarPresetSetting( gid, "Default" )
      SaveVarPresetParmVals( gid, sid )

      sid1 = AddVarPresetSetting( gid, "Coarse" )
      SetVarPresetParmVal( gid, sid1, p1, 3 )
      SetVarPresetParmVal( gid, sid1, p2, 5 )

      sid2 = AddVarPresetSetting( gid, "Fine" )
      SetVarPresetParmVal( gid, sid, p1, 35 )
      SetVarPresetParmVal( gid, sid, p2, 21 )

      gid2 = AddVarPresetGroup( "Design" )

      p3 = FindParm( pod1, "Length", "Design" )
      AddVarPresetParm( gid2, p3 )

      p4 = FindParm( pod1, "FineRatio", "Design" )
      AddVarPresetParm( gid2, p4 )

      sid3 = AddVarPresetSetting( gid2, "Normal" )
      SaveVarPresetParmVals( gid2, sid3 )

      sid4 = AddVarPresetSetting( gid2, "ShortFat" )
      SetVarPresetParmVal( gid2, sid4, p3, 3.0 )
      SetVarPresetParmVal( gid2, sid4, p4, 5.0 )

      sid5 = AddVarPresetSetting( gid2, "LongThin" )
      SetVarPresetParmVal( gid2, sid5, p3, 20.0 )
      SetVarPresetParmVal( gid2, sid5, p4, 35.0 )

      # End of setup boiler plate.

      mid1 = CreateAndAddMode( "FatWetAreas", SET_ALL, SET_NONE )
      ModeAddGroupSetting( mid1, gid, sid1 )
      ModeAddGroupSetting( mid1, gid2, sid4 )

      mid2 = CreateAndAddMode( "ThinAero", SET_FIRST_USER, SET_FIRST_USER + 1 )
      ModeAddGroupSetting( mid2, gid, sid2 )
      ModeAddGroupSetting( mid1, gid2, sid5 )

      ApplyModeSettings( mid2 )
      Update()

      nmod = GetNumModes()

  Return type:

    int

  Returns:

    int Number of Modes in model.

openvsp.vsp.GetNumPredefinedUserParms()

  Get the number of pre-defined user parameters

      n = GetNumPredefinedUserParms()

  Return type:

    int

  Returns:

    int Number of pre-defined user Parms

openvsp.vsp.GetNumResults(name)

  Get the number of results for a particular result name

      #==== Write Some Fake Test Results =====//
      WriteTestResults()

      if ( GetNumResults( "Test_Results" ) != 2 ): print( "---> Error: API GetNumResults" )

  Parameters:

    [in] – name string Input name

  Return type:

    int

  Returns:

    int Number of results

openvsp.vsp.GetNumRoutingPts(routing_id)

  Get the number of routing points in a RoutingGeom

      pod1 = vsp.AddGeom('POD', '')

      pod2 = vsp.AddGeom('POD', '')
      ypod2 = vsp.GetParm(pod2, 'Y_Rel_Location', 'XForm')
      vsp.SetParmVal(ypod2, 2.0)

      routing_geom = vsp.AddGeom('ROUTING', '')

      rpt0 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u0 = vsp.GetParm( rpt0, 'U', 'RoutePt')
      vsp.SetParmVal(u0, 0.0)

      rpt1 = vsp.AddRoutingPt(routing_geom, pod2, 0)

      rpt2 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u2 = vsp.GetParm( rpt2, 'U', 'RoutePt')
      vsp.SetParmVal(u2, 1.0)

      npt = vsp.GetNumRoutingPts(routing_geom)

  See also: AddRoutingPt, DelRoutingPt :param [in]: routing_id string RoutingGeom Geom ID :rtype: int :return: int Number of routing points in specified RoutingGeom

openvsp.vsp.GetNumSets()

  Get the total number of defined sets. Named sets are used to group components and read/write on them. The number of named sets will be 10 for OpenVSP versions up to 3.17.1 and 20 for later versions.

      if  GetNumSets() <= 0 : print( "---> Error: API GetNumSets " )

  Return type:

    int

  Returns:

    int Number of sets

openvsp.vsp.GetNumSubSurf(geom_id)

  Get the number of sub-surfaces for the specified Geom

      wid = AddGeom( "WING", "" )                             # Add Wing

      ss_line_id = AddSubSurf( wid, SS_LINE )                      # Add Sub Surface Line
      ss_rec_id = AddSubSurf( wid, SS_RECTANGLE )                        # Add Sub Surface Rectangle

      num_ss = GetNumSubSurf( wid )

      num_str = "Number of SubSurfaces: {num_ss}"

      print( num_str )

  Parameters:

    [in] – geom_id string Geom ID

  Return type:

    int

  Returns:

    int Number of Sub-surfaces

openvsp.vsp.GetNumUnsteadyGroups()

  Get the number of unsteady groups in the current VSPAERO set. Each propeller is placed in its own unsteady group. All symmetric copies of propellers are also placed in an unsteady group. All other component types are placed in a single fixed component unsteady group.

      # Set VSPAERO set index to SET_ALL
      SetParmVal( FindParm( FindContainer( "VSPAEROSettings", 0 ), "GeomSet", "VSPAERO" ), SET_ALL )

      # Add a propeller
      prop_id = AddGeom( "PROP" )
      SetParmValUpdate( prop_id, "PropMode", "Design", PROP_DISK )

      num_group = GetNumUnsteadyGroups() # Should be 0

      SetParmValUpdate( prop_id, "PropMode", "Design", PROP_BLADES )

      num_group = GetNumUnsteadyGroups() # Should be 1

      wing_id = AddGeom( "WING" )

      num_group = GetNumUnsteadyGroups() # Should be 2 (includes fixed component group)

  See also: PROP_MODE, GetNumUnsteadyRotorGroups :rtype: int :return: int Number of unsteady groups in the current VSPAERO set

openvsp.vsp.GetNumUnsteadyRotorGroups()

  Get the number of unsteady rotor groups in the current VSPAERO set. This is equivalent to the total number of propeller Geoms, including each symmetric copy, in the current VSPAERO set. While all fixed components (wings, fuseleage, etc.) are placed in their own unsteady group, this function does not consider them.

      # Set VSPAERO set index to SET_ALL
      SetParmVal( FindParm( FindContainer( "VSPAEROSettings", 0 ), "GeomSet", "VSPAERO" ), SET_ALL )

      # Add a propeller
      prop_id = AddGeom( "PROP" )
      SetParmValUpdate( prop_id, "PropMode", "Design", PROP_DISK )

      num_group = GetNumUnsteadyRotorGroups() # Should be 0

      SetParmValUpdate( prop_id, "PropMode", "Design", PROP_BLADES )

      num_group = GetNumUnsteadyRotorGroups() # Should be 1

      wing_id = AddGeom( "WING" )

      num_group = GetNumUnsteadyRotorGroups() # Should be 1 still (fixed group not included)

  See also: PROP_MODE, GetNumUnsteadyGroups :rtype: int :return: int Number of unsteady rotor groups in the current VSPAERO set

openvsp.vsp.GetNumUserParms()

  Get the number of user parameters

      n = GetNumUserParms()

  Return type:

    int

  Returns:

    int Number of user Parms

openvsp.vsp.GetNumXSec(xsec_surf_id)

  Get number of XSecs in an XSecSurf

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      # Flatten ends
      num_xsecs = GetNumXSec( xsec_surf )

      for i in range(num_xsecs):

          xsec = GetXSec( xsec_surf, i )

          SetXSecTanAngles( xsec, XSEC_BOTH_SIDES, 0, -1.0e12, -1.0e12, -1.0e12 )       # Set Tangent Angles At Cross Section

          SetXSecTanStrengths( xsec, XSEC_BOTH_SIDES, 0.0, -1.0e12, -1.0e12, -1.0e12 )  # Set Tangent Strengths At Cross Section

  Parameters:

    [in] – xsec_surf_id string XSecSurf ID

  Return type:

    int

  Returns:

    int Number of XSecs

openvsp.vsp.GetNumXSecSurfs(geom_id)

  Get the number of XSecSurfs for the specified Geom

      #==== Add Fuselage Geometry ====//
      fuseid = AddGeom( "FUSELAGE", "" )

      num_xsec_surfs = GetNumXSecSurfs( fuseid )

      if  num_xsec_surfs != 1 : print( "---> Error: API GetNumXSecSurfs  " )

  Parameters:

    [in] – geom_id string Geom ID

  Return type:

    int

  Returns:

    int Number of XSecSurfs

openvsp.vsp.GetObjectName(attachID)

  Get the name of an OpenVSP Entity by ID

      ##==== Attributes: GetObjectName ====##
      AttachIDs = FindAttributedObjects()
      for AttachID in AttachIDs:
          ObjName = GetObjectName( AttachID )
          print( ObjName )

  Return type:

    string

  Returns:

    string return string of object name

  Parameters:

    [in] – attachID string ID of an OpenVSP object

openvsp.vsp.GetObjectParent(id)

  Get the string ID of the entity’s parent Attributes -> Attribute Collections Attribute Collections -> Objects that contain attribute Collections Geoms->Parent Geoms Parms->ParmContainers etc.

      ##==== Attributes: GetObjectParent ====##

      WingID = AddGeom( "WING" )
      PodID = AddGeom( "POD", WingID )
      ParentID = GetObjectParent( PodID )

      if ParentID == WingID:
          print( "Parent of Pod is Wing")

      #Get first attribute in vehicle as an example
      AttrID = FindAllAttributes()[0]
      CollID = GetObjectParent( AttrID )
      CollParentObjID = GetObjectParent( CollID )
      print( CollParentObjID )

  Return type:

    string

  Returns:

    string ID of object parent

openvsp.vsp.GetObjectType(attachID)

  Get the type of an OpenVSP Entity by ID

      ##==== Attributes: GetObjectType ====##
      AttachIDs = FindAttributedObjects()
      for AttachID in AttachIDs:
          ObjType = GetObjectType( AttachID )
          print( ObjType )

  Return type:

    int

  Returns:

    int return string of object name

  Parameters:

    [in] – attachID string ID of an OpenVSP object

openvsp.vsp.GetObjectTypeName(attachID)

  Get the named type of an OpenVSP Entity by ID

      AttachIDs = FindAttributedObjects()
      for AttachID in AttachIDs:
          ObjTypeName = GetObjectTypeName( AttachID )
          print( ObjTypeName )

  Return type:

    string

  Returns:

    string return string of object name

  Parameters:

    [in] – attachID string ID of an OpenVSP object

openvsp.vsp.GetParm(geom_id, name, group)

  Get Parm ID

      #==== Add Pod Geometry ====//
      pid = AddGeom( "POD" )

      lenid = GetParm( pid, "Length", "Design" )

      if  not ValidParm( lenid ) : print( "---> Error: API GetParm  " )

  Parameters:

    - [in] – geom_id string Geom ID

    - [in] – name string Parm name

    - [in] – group string Parm group name

  Return type:

    string

  Returns:

    string Parm ID

openvsp.vsp.GetParmContainer(parm_id)

  Get Parm Container ID for the specified Parm

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE", "" )

      xsec_surf = GetXSecSurf( fuseid, 0 )

      ChangeXSecShape( xsec_surf, GetNumXSec( xsec_surf ) - 1, XS_ROUNDED_RECTANGLE )

      xsec = GetXSec( xsec_surf, GetNumXSec( xsec_surf ) - 1 )

      wid = GetXSecParm( xsec, "RoundedRect_Width" )

      cid = GetParmContainer( wid )

      if  len(cid) == 0 : print( "---> Error: API GetParmContainer " )

  Parameters:

    [in] – parm_id string Parm ID

  Return type:

    string

  Returns:

    string Parm Container ID

openvsp.vsp.GetParmDescript(parm_id)

  Get the description of the specified Parm

      pod_id = AddGeom( "POD" )

      length = FindParm( pod_id, "Length", "Design" )

      SetParmValLimits( length, 10.0, 0.001, 1.0e12 )

      desc = GetParmDescript( length )
      print( desc )

  Parameters:

    [in] – parm_id string Parm ID

  Return type:

    string

  Returns:

    string desc Parm description

openvsp.vsp.GetParmDisplayGroupName(parm_id)

  Get the display group name for the specified Parm

      veh_id = FindContainer( "Vehicle", 0 )

      #==== Get and List All Parms in the Container ====//
      parm_ids = FindContainerParmIDs( veh_id )

      print( "Parm Group Display Names and IDs in Vehicle Parm Container: " )

      for i in range(len(parm_ids)):

          group_str = GetParmDisplayGroupName( parm_ids[i] ) + ": " + parm_ids[i] + "\n"

          print( group_str )

  Parameters:

    [in] – parm_id string Parm ID

  Return type:

    string

  Returns:

    string Parm display group name

openvsp.vsp.GetParmGroupName(parm_id)

  Get the group name for the specified Parm

      veh_id = FindContainer( "Vehicle", 0 )

      #==== Get and List All Parms in the Container ====//
      parm_ids = FindContainerParmIDs( veh_id )

      print( "Parm Groups and IDs in Vehicle Parm Container: " )

      for i in range(len(parm_ids)):

          group_str = GetParmGroupName( parm_ids[i] ) + ": " + parm_ids[i] + "\n"

          print( group_str )

  Parameters:

    [in] – parm_id string Parm ID

  Return type:

    string

  Returns:

    string Parm group name

openvsp.vsp.GetParmLowerLimit(parm_id)

  Get the lower limit value for the specified Parm

      #==== Add Prop Geometry ====//
      prop_id = AddGeom( "PROP" )

      num_blade_id = GetParm( prop_id, "NumBlade", "Design" )

      min_blade = GetParmLowerLimit( num_blade_id )

  Parameters:

    [in] – parm_id string Parm ID

  Return type:

    float

  Returns:

    double Parm lower limit

openvsp.vsp.GetParmName(parm_id)

  Get the name for the specified Parm

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      #==== Get Structure Name and Parm Container ID ====//
      parm_container_name = GetFeaStructName( pod_id, struct_ind )

      parm_container_id = FindContainer( parm_container_name, struct_ind )

      #==== Get and List All Parms in the Container ====//
      parm_ids = FindContainerParmIDs( parm_container_id )

      for i in range(len(parm_ids)):

          name_id = GetParmName( parm_ids[i] ) + ": " + parm_ids[i] + "\n"

          print( name_id )

  Parameters:

    [in] – parm_id string Parm ID

  Return type:

    string

  Returns:

    string Parm name

openvsp.vsp.GetParmType(parm_id)

  Get the data type for the specified Parm

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE", "" )

      xsec_surf = GetXSecSurf( fuseid, 0 )

      ChangeXSecShape( xsec_surf, GetNumXSec( xsec_surf ) - 1, XS_ROUNDED_RECTANGLE )

      xsec = GetXSec( xsec_surf, GetNumXSec( xsec_surf ) - 1 )

      wid = GetXSecParm( xsec, "RoundedRect_Width" )

      if  GetParmType( wid ) != PARM_DOUBLE_TYPE : print( "---> Error: API GetParmType " )

  See also: PARM_TYPE :param [in]: parm_id string Parm ID :rtype: int :return: int Parm data type enum (i.e. PARM_BOOL_TYPE)

openvsp.vsp.GetParmUpperLimit(parm_id)

  Get the upper limit value for the specified Parm

      #==== Add Prop Geometry ====//
      prop_id = AddGeom( "PROP" )

      num_blade_id = GetParm( prop_id, "NumBlade", "Design" )

      max_blade = GetParmUpperLimit( num_blade_id )

  Parameters:

    [in] – parm_id string Parm ID

  Return type:

    float

  Returns:

    double Parm upper limit

openvsp.vsp.GetParmVal(*args)

  Overload 1:

  Get the value of the specified Parm. The data type of the Parm value will be cast to a double

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE", "" )

      xsec_surf = GetXSecSurf( fuseid, 0 )

      ChangeXSecShape( xsec_surf, GetNumXSec( xsec_surf ) - 1, XS_ROUNDED_RECTANGLE )

      xsec = GetXSec( xsec_surf, GetNumXSec( xsec_surf ) - 1 )

      wid = GetXSecParm( xsec, "RoundedRect_Width" )

      SetParmVal( wid, 23.0 )

      if  abs( GetParmVal( wid ) - 23 ) > 1e-6 : print( "---> Error: API Parm Val Set/Get " )

  Parameters:

    [in] – parm_id string Parm ID

  Return type:

    float

  Returns:

    double Parm value

  Overload 2:

  Get the value of the specified Parm. The data type of the Parm value will be cast to a double

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE", "" )

      xsec_surf = GetXSecSurf( fuseid, 0 )

      ChangeXSecShape( xsec_surf, GetNumXSec( xsec_surf ) - 1, XS_ROUNDED_RECTANGLE )

      xsec = GetXSec( xsec_surf, GetNumXSec( xsec_surf ) - 1 )

      wid = GetXSecParm( xsec, "RoundedRect_Width" )

      SetParmVal( wid, 23.0 )

      if  abs( GetParmVal( wid ) - 23 ) > 1e-6 : print( "---> Error: API Parm Val Set/Get " )

  Parameters:

    - [in] – geom_id string Geom ID

    - [in] – name string Parm name

    - [in] – group string Parm group name

  Return type:

    float

  Returns:

    double Parm value

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

openvsp.vsp.GetResultsName(results_id)

  Get the name of a result given its ID

      #==== Analysis: VSPAero Compute Geometry ====//
      analysis_name = "VSPAEROComputeGeometry"

      # Set defaults
      SetAnalysisInputDefaults( analysis_name )

      res_id = ( ExecAnalysis( analysis_name ) )

      print( "Results Name: ", False )

      print( GetResultsName( res_id ) )

  Parameters:

    [in] – results_id string Result ID

  Return type:

    string

  Returns:

    string Result name

openvsp.vsp.GetResultsSetDoc(results_id)

  Get the documentation string for a result given its ID

      #==== Analysis: VSPAero Compute Geometry ====//
      analysis_name = "VSPAEROComputeGeometry"

      # Set defaults
      SetAnalysisInputDefaults( analysis_name )

      res_id = ( ExecAnalysis( analysis_name ) )

      print( "Results doc: ", False )

      print( GetResultsSetDoc( res_id ) )

  Parameters:

    [in] – results_id string Result ID

  Return type:

    string

  Returns:

    string Result documentation string

openvsp.vsp.GetResultsType(results_id, data_name)

  Get the data type for a given result ID and data name

      #==== Write Some Fake Test Results =====//
      WriteTestResults()

      res_id = FindResultsID( "Test_Results" )

      res_array = GetAllDataNames( res_id )

      for j in range(int( len(res_array) )):

          typ = GetResultsType( res_id, res_array[j] )

  See also: RES_DATA_TYPE :param [in]: results_id string Result ID :param [in]: data_name string Data name :rtype: int :return: int Data type enum (i.e. DOUBLE_DATA)

openvsp.vsp.GetRoutingCurve(routing_id, symm_index)

  Get points along a RoutingGeom. These points will follow the curve of a RoutingGeom with radiused routing points. The main copy is symm_index = 0.

      pod1 = vsp.AddGeom('POD', '')

      pod2 = vsp.AddGeom('POD', '')
      ypod2 = vsp.GetParm(pod2, 'Y_Rel_Location', 'XForm')
      vsp.SetParmVal(ypod2, 2.0)

      routing_geom = vsp.AddGeom('ROUTING', '')

      rpt0 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u0 = vsp.GetParm( rpt0, 'U', 'RoutePt')
      vsp.SetParmVal(u0, 0.0)

      rpt1 = vsp.AddRoutingPt(routing_geom, pod2, 0)

      rpt2 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u2 = vsp.GetParm( rpt2, 'U', 'RoutePt')
      vsp.SetParmVal(u2, 1.0)

      vsp.Update()
      pvec = vsp.GetRoutingCurve(rpt1, 0)

  See also: AddRoutingPt, DelRoutingPt, GetMainRoutingPtCoord, GetRoutingPtCoord, GetAllRoutingPtCoords :param [in]: routing_id string RoutingGeom Geom ID :param [in]: symm_index int Symmetry index to get coordinate of :rtype: vector< vec3d > :return: vector < vec3d > coordinate of points along RoutingGeom curve

openvsp.vsp.GetRoutingPtCoord(routing_id, index, symm_index)

  Get the coordinate location a routing point in a RoutingGeom. The main location is symm_index = 0.

      pod1 = vsp.AddGeom('POD', '')

      pod2 = vsp.AddGeom('POD', '')
      ypod2 = vsp.GetParm(pod2, 'Y_Rel_Location', 'XForm')
      vsp.SetParmVal(ypod2, 2.0)

      routing_geom = vsp.AddGeom('ROUTING', '')

      rpt0 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u0 = vsp.GetParm( rpt0, 'U', 'RoutePt')
      vsp.SetParmVal(u0, 0.0)

      rpt1 = vsp.AddRoutingPt(routing_geom, pod2, 0)

      rpt2 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u2 = vsp.GetParm( rpt2, 'U', 'RoutePt')
      vsp.SetParmVal(u2, 1.0)

      vsp.Update()
      p1 = vsp.GetRoutingPtCoord(rpt1, 1, 0)

  See also: AddRoutingPt, DelRoutingPt, GetMainRoutingPtCoord, GetAllRoutingPtCoords, GetRoutingCurve :param [in]: routing_id string RoutingGeom Geom ID :param [in]: index int Index of routing point to get cordinate of :param [in]: symm_index int Symmetry index to get coordinate of :rtype: `vec3d` :return: vec3d coordinate of routing point

openvsp.vsp.GetRoutingPtID(routing_id, index)

  Get the ParmContainer ID of a routing point within a RoutingGeom.

      pod1 = vsp.AddGeom('POD', '')

      pod2 = vsp.AddGeom('POD', '')
      ypod2 = vsp.GetParm(pod2, 'Y_Rel_Location', 'XForm')
      vsp.SetParmVal(ypod2, 2.0)

      routing_geom = vsp.AddGeom('ROUTING', '')

      rpt0 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u0 = vsp.GetParm( rpt0, 'U', 'RoutePt')
      vsp.SetParmVal(u0, 0.0)

      rpt1 = vsp.AddRoutingPt(routing_geom, pod2, 0)

      rpt2 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u2 = vsp.GetParm( rpt2, 'U', 'RoutePt')
      vsp.SetParmVal(u2, 1.0)

      rid = vsp.GetRoutingPtID(routing_geom, 2)

  See also: AddRoutingPt, DelAllRoutingPt, GetAllRoutingPtIds :param [in]: routing_id string RoutingGeom Geom ID :param [in]: index int Index of routing point to ID to retreive :rtype: string :return: string ParmContainer ID for the specified routing point

openvsp.vsp.GetRoutingPtParentID(pt_id)

  Get the Geom ID of the geom a routing point is anchored to.

      pod1 = vsp.AddGeom('POD', '')

      pod2 = vsp.AddGeom('POD', '')
      ypod2 = vsp.GetParm(pod2, 'Y_Rel_Location', 'XForm')
      vsp.SetParmVal(ypod2, 2.0)

      routing_geom = vsp.AddGeom('ROUTING', '')

      rpt0 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u0 = vsp.GetParm( rpt0, 'U', 'RoutePt')
      vsp.SetParmVal(u0, 0.0)

      rpt1 = vsp.AddRoutingPt(routing_geom, pod2, 0)

      rpt2 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u2 = vsp.GetParm( rpt2, 'U', 'RoutePt')
      vsp.SetParmVal(u2, 1.0)

      gid = vsp.GetRoutingPtParentID(rpt1)

  See also: AddRoutingPt, DelAllRoutingPt, GetAllRoutingPtIds :param [in]: pt_id string ParmContainer ID of desired routing point :rtype: string :return: string Geom ID for the geom the routing point is anchored to

openvsp.vsp.GetScaleIndependentBBoxSet(set)

  Get the corners of the scale independent bounding box of the specified Set.

      #==== Add Pod Geometry ====//
      pid = AddGeom( "POD" )

      Update()

      sethasmembers, xmin, ymin, zmin, xlen, ylen, zlen = GetScaleIndependentBBoxSet( SET_ALL );

  Parameters:

    - [in] – set int Desired Set

    - [out] – xmin_out double Minimum bounding box X coordinate

    - [out] – ymin_out double Minimum bounding box Y coordinate

    - [out] – zmin_out double Minimum bounding box Z coordinate

    - [out] – xlen_out double Maximum bounding box X length

    - [out] – ylen_out double Maximum bounding box Y length

    - [out] – zlen_out double Maximum bounding box Z length

  Return type:

    boolean

  Returns:

    bool Flag indicating whether the set has members (is non-empty)

openvsp.vsp.GetSetFlag(geom_id, set_index)

  Check if a Geom is in the set at the specified set index

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE", "" )

      SetSetFlag( fuseid, 3, True )

      if not GetSetFlag(fuseid, 3):
          print("---> Error: API Set/Get Set Flag")

  Parameters:

    - [in] – geom_id string Geom ID

    - [in] – set_index int Set index

  Return type:

    boolean

  Returns:

    bool True if geom is in the set, false otherwise

openvsp.vsp.GetSetIndex(name)

  Get the set index for the specified set name

      SetSetName( 3, "SetFromScript" )

      if GetSetIndex("SetFromScript") != 3:
          print("ERROR: GetSetIndex")

  Parameters:

    [in] – name string Set name

  Return type:

    int

  Returns:

    int Set index

openvsp.vsp.GetSetName(index)

  Get the name of a set at specified index

      SetSetName( 3, "SetFromScript" )

      if GetSetName(3) != "SetFromScript":
          print("---> Error: API Get/Set Set Name")

  See also: SET_TYPE :param [in]: index int Set index :rtype: string :return: string Set name

openvsp.vsp.GetSettingName(setting_id)

  Get Variable Preset Setting name

      # Add Pod Geom
      pod1 = AddGeom( "POD", "" )

      gid = AddVarPresetGroup( "Tess" )

      sid = AddVarPresetSetting( gid, "Coarse" )

      name = GetSettingName( sid )

  Parameters:

    [in] – setting_id string Var Preset Setting ID

  Return type:

    string

  Returns:

    string Var Preset Setting name

openvsp.vsp.GetStringAnalysisInput(analysis, name, index=0)

  Get the current string values for the particular analysis, input, and data index

      fileNameInput = GetStringAnalysisInput( "ParasiteDrag", "FileName" )

      fileNameInput = ["ParasiteDragExample"]

      SetStringAnalysisInput( "ParasiteDrag", "FileName", fileNameInput )

  See also: RES_DATA_TYPE, SetStringAnalysisInput :param [in]: analysis string Analysis name :param [in]: name string Input name :param [in]: index int Data index :rtype: std::vector< std::string,std::allocator< std::string > > :return: vector<string> Array of analysis input values

openvsp.vsp.GetStringResults(id, name, index=0)

  Get all string values for a particular result, name, and index

      #==== Write Some Fake Test Results =====//
      WriteTestResults()

      res_id = FindResultsID( "Test_Results" )

      str_arr = GetStringResults( res_id, "Test_String" )

      if ( str_arr[0] != "This Is A Test" ): print( "---> Error: API GetStringResults" )

  Parameters:

    - [in] – id string Result ID

    - [in] – name string Data name

    - [in] – index int Data index

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Array of data values

openvsp.vsp.GetSubSurf(*args)

  Overload 1:

  Get the ID of the specified sub-surface

      wid = AddGeom( "WING", "" ) # Add Wing

      ss_rec_1 = AddSubSurf( wid, SS_RECTANGLE ) # Add Sub Surface Rectangle #1

      ss_rec_2 = AddSubSurf( wid, SS_RECTANGLE ) # Add Sub Surface Rectangle #2

      print( ss_rec_2, False )

      print( " = ", False )

      print( GetSubSurf( wid, 1 ) )

  Parameters:

    - [in] – geom_id string Geom ID

    - [in] – index int Sub-surface index

  Return type:

    string

  Returns:

    string Sub-surface ID

  Overload 2:

  Get the ID of the specified sub-surface

      wid = AddGeom( "WING", "" ) # Add Wing

      ss_rec_1 = AddSubSurf( wid, SS_RECTANGLE ) # Add Sub Surface Rectangle #1

      ss_rec_2 = AddSubSurf( wid, SS_RECTANGLE ) # Add Sub Surface Rectangle #2

      print( ss_rec_2, False )

      print( " = ", False )

      print( GetSubSurf( wid, 1 ) )

  Parameters:

    - [in] – geom_id string Geom ID

    - [in] – name string Sub surface name

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Vector of sub-surface ID

openvsp.vsp.GetSubSurfIDVec(geom_id)

  Get a vector of all sub-surface IDs for the specified geometry

      wid = AddGeom( "WING", "" )                             # Add Wing

      ss_line_id = AddSubSurf( wid, SS_LINE )                      # Add Sub Surface Line
      ss_rec_id = AddSubSurf( wid, SS_RECTANGLE )                        # Add Sub Surface Rectangle

      id_vec = GetSubSurfIDVec( wid )

      id_type_str = "SubSurface IDs and Type Indexes -> "

      for i in range(len(id_vec)):

          id_type_str += id_vec[i]

          id_type_str += ": "

          id_type_str += f'{GetSubSurfType(id_vec[i])}'

          id_type_str += "\t"

      id_type_str += "\n"

      print( id_type_str )

  Parameters:

    [in] – geom_id string Geom ID

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<int> Array of sub-surface IDs

openvsp.vsp.GetSubSurfIndex(sub_id)

  Get the index of the specified sub-surface in its parent Geom’s sub-surface vector

      wid = AddGeom( "WING", "" )                             # Add Wing

      ss_line_id = AddSubSurf( wid, SS_LINE )                      # Add Sub Surface Line
      ss_rec_id = AddSubSurf( wid, SS_RECTANGLE )                        # Add Sub Surface Rectangle

      ind = GetSubSurfIndex( ss_rec_id )

      ind_str = f"Index of SS_Rectangle: {ind}"

      print( ind_str )

  Parameters:

    [in] – sub_id string Sub-surface ID

  Return type:

    int

  Returns:

    int Sub-surface index

openvsp.vsp.GetSubSurfName(*args)

  Overload 1:

  Get the name of the specified sub-surface

      wid = AddGeom( "WING", "" )                             # Add Wing

      ss_rec_id = AddSubSurf( wid, SS_RECTANGLE )                        # Add Sub Surface Rectangle

      rec_name = GetSubSurfName( wid, ss_rec_id )

      name_str = "Current Name of SS_Rectangle: " + rec_name + "\n"

      print( name_str )

  Parameters:

    - [in] – geom_id string Geom ID

    - [in] – sub_id string Sub-surface ID

  Return type:

    string

  Returns:

    string Sub-surface name

  Overload 2:

  Get the name of the specified sub-surface

      wid = AddGeom( "WING", "" )                             # Add Wing

      ss_rec_id = AddSubSurf( wid, SS_RECTANGLE )                        # Add Sub Surface Rectangle

      rec_name = GetSubSurfName( wid, ss_rec_id )

      name_str = "Current Name of SS_Rectangle: " + rec_name + "\n"

      print( name_str )

  Parameters:

    [in] – sub_id string Sub-surface ID

  Return type:

    string

  Returns:

    string Sub-surface name

openvsp.vsp.GetSubSurfParmIDs(sub_id)

  Get the vector of Parm IDs for specified sub-surface

      wid = AddGeom( "WING", "" )                             # Add Wing

      ss_line_id = AddSubSurf( wid, SS_LINE )                      # Add Sub Surface Line

      # Get and list all Parm info for SS_Line
      parm_id_vec = GetSubSurfParmIDs( ss_line_id )

      for i in range(len(parm_id_vec)):

          id_name_str = "\tName: " + GetParmName(parm_id_vec[i]) + ", Group: " + GetParmDisplayGroupName(parm_id_vec[i]) + ", ID: " + str(parm_id_vec[i]) + "\n"

          print( id_name_str )

  Parameters:

    [in] – sub_id string Sub-surface ID

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Vector of Parm IDs

openvsp.vsp.GetSubSurfType(sub_id)

  Get the type for the specified sub-surface (i.e. SS_RECTANGLE)

      wid = AddGeom( "WING", "" )                             # Add Wing

      ss_line_id = AddSubSurf( wid, SS_LINE )                      # Add Sub Surface Line
      ss_rec_id = AddSubSurf( wid, SS_RECTANGLE )                        # Add Sub Surface Rectangle

      id_vec = GetSubSurfIDVec( wid )

      id_type_str = "SubSurface IDs and Type Indexes -> "

      for i in range(len(id_vec)):

          id_type_str += id_vec[i]

          id_type_str += ": "

          id_type_str += f'{GetSubSurfType(id_vec[i])}'

          id_type_str += "\t"

      id_type_str += "\n"

      print( id_type_str )

  See also: SUBSURF_TYPE :param [in]: sub_id string Sub-surface ID :rtype: int :return: int Sub-surface type enum (i.e. SS_RECTANGLE)

openvsp.vsp.GetTotalNumSurfs(geom_id)

  Get the total number of surfaces for the specified Geom. This is equivalent to the number of main surface multiplied by the number of symmetric copies.

      #==== Add Wing Geometry ====//
      wing_id = AddGeom( "WING" )

      num_surf = 0

      num_surf = GetTotalNumSurfs( wing_id ) # Wings default with XZ symmetry on -> 2 surfaces

      print( "Total Number of Wing Surfaces: ", False )

      print( num_surf )

  Parameters:

    [in] – geom_id string Geom ID

  Return type:

    int

  Returns:

    int Number of main surfaces

openvsp.vsp.GetUWTess01(geom_id, surf_indx)

  Get the surface coordinate point of each intersection of the tessellated wireframe for a particular surface

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      surf_indx = 0

      utess, wtess = GetUWTess01( geom_id, surf_indx )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – surf_indx int Main surface index from the parent Geom

    - [out] – u_out_vec vector<double> Output vector of U (0 - 1) surface coordinates

    - [out] – w_out_vec vector<double> Output vector of W (0 - 1) surface coordinates

openvsp.vsp.GetUnsteadyGroupCompIDs(group_index)

  Get an array of IDs for all components in the unsteady group at the specified index.

      # Add a pod and wing
      pod_id = AddGeom( "POD", "" )
      wing_id = AddGeom( "WING", pod_id ) # Default with symmetry on -> 2 surfaces

      SetParmVal( wing_id, "X_Rel_Location", "XForm", 2.5 )
      Update()

      comp_ids = GetUnsteadyGroupCompIDs( 0 )

      if  len(comp_ids) != 3 :
          print( "ERROR: GetUnsteadyGroupCompIDs" )

  See also: GetUnsteadyGroupSurfIndexes :param [in]: group_index int Unsteady group index for the current VSPAERO set :rtype: std::vector< std::string,std::allocator< std::string > > :return: vector <string> Array of component IDs

openvsp.vsp.GetUnsteadyGroupName(group_index)

  Get the name of the unsteady group at the specified index.

      # Add a pod and wing
      pod_id = AddGeom( "POD", "" )
      wing_id = AddGeom( "WING", pod_id )

      SetParmVal( wing_id, "X_Rel_Location", "XForm", 2.5 )
      Update()

      print( GetUnsteadyGroupName( 0 ) )

  See also: SetUnsteadyGroupName :param [in]: group_index int Unsteady group index for the current VSPAERO set :rtype: string :return: string Unsteady group name

openvsp.vsp.GetUnsteadyGroupSurfIndexes(group_index)

  Get an array of surface indexes for all components in the unsteady group at the specified index.

      # Add a pod and wing
      pod_id = AddGeom( "POD", "" )
      wing_id = AddGeom( "WING", pod_id ) # Default with symmetry on -> 2 surfaces

      SetParmVal( wing_id, "X_Rel_Location", "XForm", 2.5 )
      Update()

      surf_indexes = GetUnsteadyGroupSurfIndexes( 0 )

      if  len(surf_indexes) != 3 :
          print( "ERROR: GetUnsteadyGroupSurfIndexes" )

  See also: GetUnsteadyGroupCompIDs :param [in]: group_index int Unsteady group index for the current VSPAERO set :rtype: std::vector< int,std::allocator< int > > :return: vector <int> Array of surface indexes

openvsp.vsp.GetUpperCSTCoefs(xsec_id)

  Get the CST coefficients for the upper surface of an airfoil. The XSec must be of type XS_CST_AIRFOIL See also: SetUpperCST :param [in]: xsec_id string XSec ID :rtype: std::vector< double,std::allocator< double > > :return: vector<double> Vector of CST coefficients for the upper airfoil surface

openvsp.vsp.GetUpperCSTDegree(xsec_id)

  Get the CST degree for the upper surface of an airfoil. The XSec must be of type XS_CST_AIRFOIL See also: SetUpperCST :param [in]: xsec_id string XSec ID :rtype: int :return: int CST Degree for upper airfoil surface

openvsp.vsp.GetUserParmContainer()

  Get the user parm container ID

      up_id = GetUserParmContainer()

  Return type:

    string

  Returns:

    string User parm container ID

openvsp.vsp.GetVKTAirfoilCpDist(alpha, epsilon, kappa, tau, xyz_data)

  Get the pressure coefficient (Cp) along a Von Kármán-Trefftz airfoil of specified shape at specified points along the airfoil

      pi = 3.14159265358979323846

      npts = 122

      alpha = 0.0

      epsilon = 0.1

      kappa = 0.1

      tau = 10

      xyz_airfoil = GetVKTAirfoilPnts(npts, alpha, epsilon, kappa, tau*(pi/180) )

      cp_dist = GetVKTAirfoilCpDist( alpha, epsilon, kappa, tau*(pi/180), xyz_airfoil )

  See also: GetVKTAirfoilPnts :param [in]: alpha double Airfoil angle of attack (Radians) :param [in]: epsilon double Airfoil thickness :param [in]: kappa double Airfoil camber :param [in]: tau double Airfoil trailing edge angle (Radians) :param [in]: xyz_data vector<vec3d> Vector of points on the airfoil to evaluate :rtype: std::vector< double,std::allocator< double > > :return: vector<double> Vector of Cp values for each point in xydata

openvsp.vsp.GetVKTAirfoilPnts(npts, alpha, epsilon, kappa, tau)

  Get the 2D coordinates an input number of points along a Von K�rm�n-Trefftz airfoil of specified shape

      pi = 3.14159265358979323846

      npts = 122

      alpha = 0.0

      epsilon = 0.1

      kappa = 0.1

      tau = 10

      xyz_airfoil = GetVKTAirfoilPnts(npts, alpha, epsilon, kappa, tau*(pi/180) )

      cp_dist = GetVKTAirfoilCpDist( alpha, epsilon, kappa, tau*(pi/180), xyz_airfoil )

  Parameters:

    - [in] – npts int Number of points along the airfoil to return

    - [in] – alpha double Airfoil angle of attack (Radians)

    - [in] – epsilon double Airfoil thickness

    - [in] – kappa double Airfoil camber

    - [in] – tau double Airfoil trailing edge angle (Radians)

  Return type:

    std::vector< vec3d,std::allocator< vec3d > >

  Returns:

    vector<vec3d> Array of points on the VKT airfoil (size = npts)

openvsp.vsp.GetVSPAEROControlGroupName(CSGroupIndex)

  Get the name of the control surface group at the specified index

      wid = AddGeom( "WING", "" ) # Add Wing

      aileron_id = AddSubSurf( wid, SS_CONTROL ) # Add Control Surface Sub-Surface

      group_index = CreateVSPAEROControlSurfaceGroup() # Empty control surface group

      SetVSPAEROControlGroupName( "Example_CS_Group", group_index )

      print( "CS Group name: ", False )

      print( GetVSPAEROControlGroupName( group_index ) )

  Parameters:

    [in] – CSGroupIndex int Index of the control surface group

openvsp.vsp.GetVSPAEROPath()

  Get the path that OpenVSP will use to look for all VSPAERO executables (Solver, Slicer, and Viewer) when attempting to execute VSPAERO. If the VSPAERO executables are not in this location, they must either be copied there or the VSPAERO path must be set using SetVSPAEROPath.

      if  not CheckForVSPAERO( GetVSPAEROPath() ) :
          print( "VSPAERO is not where OpenVSP thinks it is. I should move the VSPAERO executable or call SetVSPAEROPath." )

  See also: GetVSPExePath, CheckForVSPAERO, SetVSPAEROPath :rtype: string :return: string Path OpenVSP will look for VSPAERO

openvsp.vsp.GetVSPAERORefWingID()

  Get ID of the current VSPAERO reference Geom :rtype: string :return: string Reference Geom ID

openvsp.vsp.GetVSPExePath()

  Get the path to the OpenVSP executable. OpenVSP will assume that the VSPAERO, VSPSLICER, and VSPVIEWER are in the same directory unless instructed otherwise.

      print( "The current VSP executable path is: ", False )

      print( GetVSPExePath() )

  See also: SetVSPAEROPath, CheckForVSPAERO, GetVSPAEROPath :rtype: string :return: string Path to the OpenVSP executable

openvsp.vsp.GetVSPFileName()

  Get the file name of the current OpenVSP project

      fid = AddGeom( "FUSELAGE", "" )             # Add Fuselage

      fname = "example_fuse.vsp3"

      SetVSP3FileName( fname )

      Update()

      #==== Save Vehicle to File ====//
      print( "\tSaving vehicle file to: ", False )

      print( fname )

      WriteVSPFile( GetVSPFileName(), SET_ALL )

  Return type:

    string

  Returns:

    string File name for the current OpenVSP project

openvsp.vsp.GetVSPHelpPath()

  Get the path that OpenVSP will use to look for all OpenVSP help files. If the OpenVSP help files are not in this location, they must either be copied there or the VSPHelp path must be set using SetVSPHelpPath.

      if  not CheckForVSPHelp( GetVSPHelpPath() ) :
          print( "VSPAERO is not where OpenVSP thinks it is. I should move the VSPAERO executable or call SetVSPAEROPath." )

  See also: GetVSPExePath, CheckForVSPHelp, SetVSPHelpPath :rtype: string :return: string Path OpenVSP will look for help files

openvsp.vsp.GetVSPVersion()

  Get the version of the OpenVSP instance currently running

      print( "The current OpenVSP version is: ", False )

      print( GetVSPVersion() )

  Return type:

    string

  Returns:

    string OpenVSP version string (i.e. “OpenVSP 3.17.1”)

openvsp.vsp.GetVSPVersionChange()

  Get the change version of the OpenVSP instance currently running as an integer

      print( "The current OpenVSP version is: ", False )

      major = GetVSPVersionMajor()
      minor = GetVSPVersionMinor()
      change = GetVSPVersionChange()

      print( f"{major}.{minor}.{change}" )

  Return type:

    int

  Returns:

    int OpenVSP change version number (i.e. Y in 3.X.Y)

openvsp.vsp.GetVSPVersionMajor()

  Get the major version of the OpenVSP instance currently running as an integer

      print( "The current OpenVSP version is: ", False )

      major = GetVSPVersionMajor()
      minor = GetVSPVersionMinor()
      change = GetVSPVersionChange()

      print( f"{major}.{minor}.{change}" )

  Return type:

    int

  Returns:

    int OpenVSP major version number (i.e. 3 in 3.X.Y)

openvsp.vsp.GetVSPVersionMinor()

  Get the minor version of the OpenVSP instance currently running as an integer

      print( "The current OpenVSP version is: ", False )

      major = GetVSPVersionMajor()
      minor = GetVSPVersionMinor()
      change = GetVSPVersionChange()

      print( f"{major}.{minor}.{change}" )

  Return type:

    int

  Returns:

    int OpenVSP minor version number (i.e. X in 3.X.Y)

openvsp.vsp.GetVarPresetGroups()

  Get group_ids for Variable Preset Groups

      # Add Pod Geom
      pod1 = AddGeom( "POD", "" )

      gid = AddVarPresetGroup( "Tess" )

      sid = AddVarPresetSetting( gid, "Coarse" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )

      AddVarPresetParm( gid, p1 )

      group_ids = GetVarPresetGroups()

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    array<string> Array of Variable Preset Group IDs

openvsp.vsp.GetVarPresetParmIDs(group_id)

  Get ParmIDs for Variable Preset Group

      # Add Pod Geom
      pod1 = AddGeom( "POD", "" )

      gid = AddVarPresetGroup( "Tess" )

      sid = AddVarPresetSetting( gid, "Coarse" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )

      AddVarPresetParm( gid, p1 )

      parmids = GetVarPresetParmIDs( gid )

  Parameters:

    [in] – group_id string Var Preset Group ID

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    array<string> Array of Variable Preset Group ParmIDs

openvsp.vsp.GetVarPresetParmVal(group_id, setting_id, parm_id)

  Get value for Parm in Var Preset Setting

      # Add Pod Geom
      pod1 = AddGeom( "POD", "" )

      gid = AddVarPresetGroup( "Tess" )

      sid = AddVarPresetSetting( gid, "Coarse" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )

      AddVarPresetParm( gid, p1 )

      val = GetVarPresetParmVal( gid, sid, p1 )

  Parameters:

    - [in] – group_id string Var Preset Group ID

    - [in] – setting_id string Var Preset Setting ID

    - [in] – parm_id string Var Parm ID

  Return type:

    float

  Returns:

    double Var Preset Parm value

openvsp.vsp.GetVarPresetParmVals(setting_id)

  Get Parm values for Variable Preset Setting

      # Add Pod Geom
      pod1 = AddGeom( "POD", "" )

      gid = AddVarPresetGroup( "Tess" )

      sid = AddVarPresetSetting( gid, "Coarse" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )

      AddVarPresetParm( gid, p1 )

      parmval_vec = GetVarPresetParmVals( sid )

  Parameters:

    [in] – setting_id string Var Preset Setting ID

  Return type:

    std::vector< double,std::allocator< double > >

  Returns:

    array<double> Var Preset Parm values for Setting

openvsp.vsp.GetVarPresetSettings(group_id)

  Get Setting IDs for Variable Preset Group

      # Add Pod Geom
      pod1 = AddGeom( "POD", "" )

      gid = AddVarPresetGroup( "Tess" )

      sid = AddVarPresetSetting( gid, "Coarse" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )

      AddVarPresetParm( gid, p1 )

      settingds = GetVarPresetSettings( gid )

  Parameters:

    [in] – group_id string Var Preset Group ID

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    array<string> Array of Variable Preset Group ParmIDs

openvsp.vsp.GetVec3dAnalysisInput(analysis, name, index=0)

  Get the current vec3d values for the particular analysis, input, and data index

      # PlanarSlice
      norm = GetVec3dAnalysisInput( "PlanarSlice", "Norm" )

      norm[0].set_xyz( 0.23, 0.6, 0.15 )

      SetVec3dAnalysisInput( "PlanarSlice", "Norm", norm )

  See also: RES_DATA_TYPE, SetVec3dAnalysisInput :param [in]: analysis string Analysis name :param [in]: name string Input name :param [in]: index int Data index :rtype: std::vector< vec3d,std::allocator< vec3d > > :return: vector<vec3d> Array of analysis input values

openvsp.vsp.GetVec3dResults(id, name, index=0)

  Get all vec3d values for a particular result, name, and index

      #==== Write Some Fake Test Results =====//

      tol = 0.00001

      WriteTestResults()

      res_id = FindLatestResultsID( "Test_Results" )

      vec3d_vec = GetVec3dResults( res_id, "Test_Vec3d" )

      print( "X: ", False )
      print( vec3d_vec[0].x(), False )

      print( "\tY: ", False )
      print( vec3d_vec[0].y(), False )

      print( "\tZ: ", False )
      print( vec3d_vec[0].z() )

  Parameters:

    - [in] – id string Result ID

    - [in] – name string Data name

    - [in] – index int Data index

  Return type:

    std::vector< vec3d,std::allocator< vec3d > >

  Returns:

    vector<vec3d> Array of data values

openvsp.vsp.GetVehicleID()

  Get the ID of the Vehicle Parm Container

      #===== Get Vehicle Parm Container ID ====//
      veh_id = GetVehicleID()

  Return type:

    string

  Returns:

    string Vehicle ID

openvsp.vsp.GetXSec(xsec_surf_id, xsec_index)

  Get Xsec ID for a particular XSecSurf at given index

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      # Identify XSec 1
      xsec_1 = GetXSec( xsec_surf, 1 )

  Parameters:

    - [in] – xsec_surf_id string XSecSurf ID

    - [in] – xsec_index int Xsec index

  Return type:

    string

  Returns:

    string Xsec ID

openvsp.vsp.GetXSecAlias(id)

  Get XSec Alias by ID

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      # Identify XSec 1
      xsec_1 = GetXSec( xsec_surf, 1 )

      # Set Alias and verify alias match
      alias = "XSec_One_Alias"

      SetXSecAlias( xsec_1, alias )

      get_alias = GetXSecAlias( xsec_1 )

      if alias != get_alias:
          print("SetXSecAlias/GetXSecAlias error!")

  Parameters:

    [in] – id string XSec ID

  Return type:

    string

  Returns:

    string Xsec alias

openvsp.vsp.GetXSecCurveAlias(id)

  Get XSecCurve Alias by XSec ID

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      # Identify XSec 1
      xsec_1 = GetXSec( xsec_surf, 1 )

      # Set Alias and verify alias match
      alias = "XSecCurve_One_Alias"

      SetXSecCurveAlias( xsec_1, alias )

      get_alias = GetXSecCurveAlias( xsec_1 )

      if alias != get_alias:
          print("SetXSecCurveAlias/GetXSecCurveAlias error!")

  Parameters:

    [in] – id string XSec ID

openvsp.vsp.GetXSecHeight(xsec_id)

  Get the height of an XSec. Note that POINT type XSecs have a width and height of 0, regardless of what width and height it is set to.

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE", "" )

      xsec_surf = GetXSecSurf( fuseid, 0 )

      xsec = GetXSec( xsec_surf, GetNumXSec( xsec_surf ) - 2 ) # Get 2nd to last XSec

      SetXSecWidthHeight( xsec, 3.0, 6.0 )

      if  abs( GetXSecHeight( xsec ) - 6.0 ) > 1e-6 : print( "---> Error: API Get/Set Width " )

  See also: SetXSecHeight :param [in]: xsec_id string XSec ID :rtype: float :return: double Xsec height

openvsp.vsp.GetXSecParm(xsec_id, name)

  Get a specific Parm ID from an Xsec

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE", "" )

      xsec_surf = GetXSecSurf( fuseid, 0 )

      ChangeXSecShape( xsec_surf, GetNumXSec( xsec_surf ) - 1, XS_ROUNDED_RECTANGLE )

      xsec = GetXSec( xsec_surf, GetNumXSec( xsec_surf ) - 1 )

      wid = GetXSecParm( xsec, "RoundedRect_Width" )

      if  not ValidParm( wid ) : print( "---> Error: API GetXSecParm " )

  Parameters:

    - [in] – xsec_id string XSec ID

    - [in] – name string Parm name

  Return type:

    string

  Returns:

    string Parm ID

openvsp.vsp.GetXSecParmIDs(xsec_id)

  Get all Parm IDs for specified XSec Parm Container

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE", "" )

      xsec_surf = GetXSecSurf( fuseid, 0 )

      xsec = GetXSec( xsec_surf, GetNumXSec( xsec_surf ) - 1 )

      parm_array = GetXSecParmIDs( xsec )

      if  len(parm_array) < 1 : print( "---> Error: API GetXSecParmIDs " )

  Parameters:

    [in] – xsec_id string XSec ID

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Array of Parm IDs

openvsp.vsp.GetXSecShape(xsec_id)

  Get the shape of an XSec

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      ChangeXSecShape( xsec_surf, 1, XS_EDIT_CURVE )

      xsec = GetXSec( xsec_surf, 1 )

      if  GetXSecShape( xsec ) != XS_EDIT_CURVE : print( "ERROR: GetXSecShape" )

  See also: XSEC_CRV_TYPE :param [in]: xsec_id string XSec ID :rtype: int :return: int XSec type enum (i.e. XS_ELLIPSE)

openvsp.vsp.GetXSecSurf(geom_id, index)

  Get the XSecSurf ID for a particular Geom and XSecSurf index

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

  Parameters:

    - [in] – geom_id string Geom ID

    - [in] – index int XSecSurf index

  Return type:

    string

  Returns:

    string XSecSurf ID

openvsp.vsp.GetXSecSurfGlobalXForm(xsec_surf_id)

  Get the global surface transform matrix for given XSecSurf :param [in]: xsec_surf_id string XSecSurf ID :rtype: `Matrix4d` :return: Matrix4d Transformation matrix

openvsp.vsp.GetXSecWidth(xsec_id)

  Get the width of an XSec. Note that POINT type XSecs have a width and height of 0, regardless of what width and height it is set to.

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE", "" )

      xsec_surf = GetXSecSurf( fuseid, 0 )

      xsec = GetXSec( xsec_surf, GetNumXSec( xsec_surf ) - 2 ) # Get 2nd to last XSec

      SetXSecWidthHeight( xsec, 3.0, 6.0 )

      if  abs( GetXSecWidth( xsec ) - 3.0 ) > 1e-6 : print( "---> Error: API Get/Set Width " )

  See also: SetXSecWidth :param [in]: xsec_id string XSec ID :rtype: float :return: double Xsec width

openvsp.vsp.HEIGHT_XSEC_DRIVER = 2

  Height driver

openvsp.vsp.HINGE_GEOM_SCREEN = 10

  Hinge geom screen

openvsp.vsp.HUMAN_GEOM_SCREEN = 16

  Human geom screen

openvsp.vsp.HWRATIO_XSEC_DRIVER = 3

  Height/width ratio driver

openvsp.vsp.HideAllBackground3Ds()

  Hide all Background3Ds in model

      # Add Background3D
      AddBackground3D()
      AddBackground3D()
      AddBackground3D()

      HideAllBackground3Ds()

      DelAllBackground3Ds()

openvsp.vsp.HideScreen(s)

  Hide an OpenVSP GUI screen

      HideScreen( VSP_CFD_MESH_SCREEN )

  Parameters:

    [in] – s int GUI_VSP_SCREEN enum for screen

openvsp.vsp.ID_LENGTH_ATTR = 8

  ID for Attributes are length 8

openvsp.vsp.ID_LENGTH_ATTRCOLL = 9

  ID for Attribute Collections are length 9

openvsp.vsp.ID_LENGTH_PARM = 11

  ID for Parms are length 11

openvsp.vsp.ID_LENGTH_PARMCONTAINER = 10

  ID for Parm Containers are length 10

openvsp.vsp.ID_LENGTH_PRESET_GROUP = 5

  ID for Var Preset Groups are length 5

openvsp.vsp.ID_LENGTH_PRESET_SETTING = 6

  ID for Var Preset Settings are length 6

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.INTERMEDIATE_FRAGMENT = 1

  Intermediate rotor fragment

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 = 1

  Integer data type

openvsp.vsp.INT_MATRIX_DATA = 5

  Int matrix data type

openvsp.vsp.INVALID_TYPE = -1

  Invalid data type

openvsp.vsp.ImportFile(file_name, file_type, parent)

  Import a file into OpenVSP. Many formats are available, such as NASCART, V2, and BEM). The imported Geom, mesh, or other object is inserted as a child of the specified parent. If no parent or an invalid parent is given, the import will be done at the top level. See also: IMPORT_TYPE :param [in]: file_name string Import file name :param [in]: file_type int File type enum (i.e. IMPORT_PTS) :param [in]: parent string Parent Geom ID (ignored with empty string)

openvsp.vsp.InitGUI()

  Low level routine that should be called to set up GUI before running StartGUI()

      InitGUI()

openvsp.vsp.InsertFeaPolySparPt(pspar_id, index)

  Insert a point into an FEA Poly Spar before the given index and return its ID.

      wing_id = AddGeom( "WING" )

      struct_ind = AddFeaStruct( wing_id )

      pspar_id = AddFeaPart( wing_id, struct_ind, FEA_POLY_SPAR )

      # Insert a new intermediate point between the two default endpoints
      pt_id = InsertFeaPolySparPt( pspar_id, 1 )

      if GetFeaPolySparNumPt( pspar_id ) != 3:
          print( "Error: InsertFeaPolySparPt" )

  See also: AddFeaPolySparPt, DelFeaPolySparPt, GetFeaPolySparNumPt :param [in]: pspar_id string FEA Poly Spar part ID :param [in]: index int Index before which the new point is inserted :rtype: string :return: string ID of the newly inserted Poly Spar point

openvsp.vsp.InsertRoutingPt(routing_id, index, geom_id, surf_index)

  Add a routing point to a RoutingGeom. The new point will be inserted before the specified index. The new point will be anchored to the specified geom and surface.

      pod1 = vsp.AddGeom('POD', '')

      pod2 = vsp.AddGeom('POD', '')
      ypod2 = vsp.GetParm(pod2, 'Y_Rel_Location', 'XForm')
      vsp.SetParmVal(ypod2, 2.0)

      routing_geom = vsp.AddGeom('ROUTING', '')

      rpt0 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u0 = vsp.GetParm( rpt0, 'U', 'RoutePt')
      vsp.SetParmVal(u0, 0.0)

      rpt1 = vsp.AddRoutingPt(routing_geom, pod2, 0)

      rpt2 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u2 = vsp.GetParm( rpt2, 'U', 'RoutePt')
      vsp.SetParmVal(u2, 1.0)

      npt = vsp.GetNumRoutingPts(routing_geom)
      rptPre2 = vsp.InsertRoutingPt(routing_geom, 2, pod2, 0)
      uPre2 = vsp.GetParm( rptPre2, 'U', 'RoutePt')
      vsp.SetParmVal(uPre2, 0.)

  See also: AddRoutingPt, DelRoutingPt :param [in]: routing_id string RoutingGeom Geom ID :param [in]: index int Index of routing point to insert new point before :param [in]: geom_id string Geom ID of geom to anchor new routing point to :param [in]: surf_index int Index of surf to anchor new routing point to :rtype: string :return: string ParmContainer ID for the newly added routing point

openvsp.vsp.InsertVSPFile(file_name, parent_geom_id)

  Insert an external OpenVSP project into the current project. All Geoms in the external project are placed as children of the specified parent. If no parent or an invalid parent is given, the Geoms are inserted at the top level. :param [in]: file_name string *.vsp3 filename :param [in]: parent_geom_id string Parent geom ID (ignored with empty string)

openvsp.vsp.InsertXSec(geom_id, index, type)

  Insert a cross-section of particular type to the specified geometry after the given index

      wing_id = AddGeom( "WING" )

      #===== Add XSec ====//
      InsertXSec( wing_id, 1, XS_SIX_SERIES )

  See also: XSEC_CRV_TYPE :param [in]: geom_id string Geom ID :param [in]: index int XSec index :param [in]: type int XSec type enum (i.e. XS_GENERAL_FUSE)

openvsp.vsp.InsideSurf(geom_id, surf_indx, pt)

  Test whether a given point is inside a specified surface.

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      surf_indx = 0

      r = 0.12
      s = 0.68
      t = 0.56

      pnt = CompPntRST( geom_id, surf_indx, r, s, t )

      res = InsideSurf( geom_id, surf_indx, pnt )

      if  res :
          print( "Inside" )
      else:
          print( "Outside" )

  See also: VecInsideSurf :param [in]: geom_id string Parent Geom ID :param [in]: surf_indx int Main surface index from the parent Geom :param [in]: pt vec3d Input 3D coordinate point :rtype: boolean :return: bool Boolean true if the point is inside the surface, false otherwise.

class openvsp.vsp.IntVecVec(*args)

  Bases: `object`

  Proxy of C++ std::vector< std::vector< int > > class.

  append(IntVecVec self, IntVector x)
  assign(IntVecVec self, std: :vector< std::vector< int > >::size_type n, IntVector x)
  back(IntVecVec self) → IntVector
  begin(IntVecVec self) → std::vector< std::vector< int > >::iterator
  capacity(IntVecVec self) → std::vector< std::vector< int > >::size_type
  clear(IntVecVec self)
  empty(IntVecVec self) → bool
  end(IntVecVec self) → std::vector< std::vector< int > >::iterator
  erase(IntVecVec self, std: :vector< std::vector< int > >::iterator pos) → std::vector< std::vector< int > >::iterator
  erase(IntVecVec self, std: :vector< std::vector< int > >::iterator first, std: :vector< std::vector< int > >::iterator last) → std::vector< std::vector< int > >::iterator
  front(IntVecVec self) → IntVector
  get_allocator(IntVecVec self) → std::vector< std::vector< int > >::allocator_type
  insert(IntVecVec self, std: :vector< std::vector< int > >::iterator pos, IntVector x) → std::vector< std::vector< int > >::iterator
  insert(IntVecVec self, std: :vector< std::vector< int > >::iterator pos, std: :vector< std::vector< int > >::size_type n, IntVector x)
  iterator(IntVecVec self) → SwigPyIterator
  pop(IntVecVec self) → IntVector
  pop_back(IntVecVec self)
  push_back(IntVecVec self, IntVector x)
  rbegin(IntVecVec self) → std::vector< std::vector< int > >::reverse_iterator
  rend(IntVecVec self) → std::vector< std::vector< int > >::reverse_iterator
  reserve(IntVecVec self, std: :vector< std::vector< int > >::size_type n)
  resize(IntVecVec self, std: :vector< std::vector< int > >::size_type new_size)
  resize(IntVecVec self, std: :vector< std::vector< int > >::size_type new_size, IntVector x)
  size(IntVecVec self) → std::vector< std::vector< int > >::size_type
  swap(IntVecVec self, IntVecVec v)
  property thisown

    The membership flag

class openvsp.vsp.IntVector(*args)

  Bases: `object`

  Proxy of C++ std::vector< int > class.

  append(IntVector self, std: :vector< int >::value_type const & x)
  assign(IntVector self, std: :vector< int >::size_type n, std: :vector< int >::value_type const & x)
  back(IntVector self) → std::vector< int >::value_type const &
  begin(IntVector self) → std::vector< int >::iterator
  capacity(IntVector self) → std::vector< int >::size_type
  clear(IntVector self)
  empty(IntVector self) → bool
  end(IntVector self) → std::vector< int >::iterator
  erase(IntVector self, std: :vector< int >::iterator pos) → std::vector< int >::iterator
  erase(IntVector self, std: :vector< int >::iterator first, std: :vector< int >::iterator last) → std::vector< int >::iterator
  front(IntVector self) → std::vector< int >::value_type const &
  get_allocator(IntVector self) → std::vector< int >::allocator_type
  insert(IntVector self, std: :vector< int >::iterator pos, std: :vector< int >::value_type const & x) → std::vector< int >::iterator
  insert(IntVector self, std: :vector< int >::iterator pos, std: :vector< int >::size_type n, std: :vector< int >::value_type const & x)
  iterator(IntVector self) → SwigPyIterator
  pop(IntVector self) → std::vector< int >::value_type
  pop_back(IntVector self)
  push_back(IntVector self, std: :vector< int >::value_type const & x)
  rbegin(IntVector self) → std::vector< int >::reverse_iterator
  rend(IntVector self) → std::vector< int >::reverse_iterator
  reserve(IntVector self, std: :vector< int >::size_type n)
  resize(IntVector self, std: :vector< int >::size_type new_size)
  resize(IntVector self, std: :vector< int >::size_type new_size, std: :vector< int >::value_type const & x)
  size(IntVector self) → std::vector< int >::size_type
  swap(IntVector self, IntVector v)
  property thisown

    The membership flag

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

openvsp.vsp.IntersectSubSurf(sub_id)

  Trigger intersection for SS_INTERSECT type subsurfaces

      pid = AddGeom( "POD", "" )
      p2id = AddGeom( "POD", "" )

      xpod2 = GetParm( p2id, "X_Rel_Location", "XForm" )
      SetParmVal( xpod2, 4.0 )

      zrotpod2 = GetParm( p2id, "Z_Rel_Rotation", "XForm" )
      SetParmVal( zrotpod2, 60.0 )

      sub_id = AddSubSurf( pid, SS_INTERSECT )

      Update()

      SetIntersectSubSurfGeomID( sub_id, p2id )

      IntersectSubSurf( sub_id )

  Parameters:

    [in] – sub_id string Sub-surface ID

openvsp.vsp.IsEventLoopRunning()

  Test if the OpenVSP GUI event loop is running.

      StartGUI()

      if ( IsEventLoopRunning() ):
          print( "Event loop is running." )

  Return type:

    boolean

  Returns:

    bool True if the OpenVSP GUI event loop is running. False otherwise.

openvsp.vsp.IsFacade()

  Returns True if the facade API is in use.

      is_facade = IsFacade()

openvsp.vsp.IsGUIBuild()

  Test if the current OpenVSP build includes graphics capabilities.

      if ( IsGUIBuild() ):
          print( "OpenVSP build is graphics capable." )
      else:
          print( "OpenVSP build is not graphics capable." )

  Return type:

    boolean

  Returns:

    bool True if the current OpenVSP build includes graphics capabilities. False otherwise.

openvsp.vsp.IsGUIRunning()

  Returns True if the GUI event loop is running.

      is_gui_active = IsGUIRunning()

openvsp.vsp.J_PROP_DRIVER = 5

  Advance ratio driver

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.LINEAR_SWEPT_VOLUME_ANALYSIS = 12

  Interference with linear swept volume

openvsp.vsp.LINE_SOURCE = 1

  Line source

openvsp.vsp.L_TRIM = 1

  Trim by L coordinate

openvsp.vsp.LimitedIntersectSurfaces(StringVector geomvec, vector< vector< vec3d > > & ptchains, vector< vector< vec3d > > & uwchains)

openvsp.vsp.ListAnalysis()

  Get the name of every available analysis in the Analysis Manager

      analysis_array = ListAnalysis()

      print( "List of Available Analyses: " )

      for i in range(int( len(analysis_array) )):

          print( "    " + analysis_array[i] )

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Array of analysis names

openvsp.vsp.Lock()

  Obtain the lock on the OpenVSP GUI event loop. This will prevent the interactive GUI from updating or accepting user input until the lock is released – thereby allowing longer-time commands including analyses to execute without the chance of the OpenVSP state changing during execution.

      StartGUI()

      pod_id = AddGeom( "POD" )

      Lock()
      rid = ExecAnalysis( "CompGeom" )

      mesh_id_vec = GetStringResults( rid, "Mesh_GeomID" )

      DeleteGeomVec( mesh_id_vec )
      Unlock()

  See also: Unlock

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_PROP = 18

  Calculate mass properties

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.MODE_TARGET = 2

  Mode target type

openvsp.vsp.MOTION_NUM_EXTENT_TYPES = 7

  Number of swept volume extent types.

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 = 11

  Multiple geom screen

openvsp.vsp.MakeMeshGeom(ga_id)

  Create a MeshGeom from the results of the specified Geometry Analysis case and return the new Geom’s ID. The case must have been evaluated first (run the “GeometryAnalysis” analysis for the case) so that its result meshes exist. The resulting MeshGeom is added to the model and made the active Geom.

      ga_id = AddGeometryAnalysis()
      # ... configure the case's Parms (interference type, primary/secondary geoms or sets, ...) ...

      # Evaluate the case through the Analysis framework so that its result meshes exist.
      SetAnalysisInputDefaults( "GeometryAnalysis" )

      SetStringAnalysisInput( "GeometryAnalysis", "CaseID", [ga_id] )

      ExecAnalysis( "GeometryAnalysis" )

      # Turn the case's result meshes into a MeshGeom.
      mesh_id = MakeMeshGeom( ga_id )

  See also: AddGeometryAnalysis, SetActiveGeometryAnalysis :param [in]: ga_id string Geometry Analysis case ID :rtype: string :return: string Geom ID of the newly created MeshGeom

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

  Matrix4d is typically used to perform rotations, translations, scaling, projections, and other transformations in 3D space.

  affineInverse()

    Perform an affine transform on the Matrix4d

            #==== Test Matrix4d ====//
        Matrix4d m()                            # Default Constructor

        m.loadIdentity()

        m.rotateY( 10.0 )
        m.rotateX( 20.0 )
        m.rotateZ( 30.0 )

        vec3d c = m.xform( vec3d( 1.0, 1.0, 1.0 ) )

        m.affineInverse()

  buildXForm(pos, rot, cent_rot)

    Translate the Matrix4d to a given position and rotate it a about a given center of rotation :param [in]: pos Position to translate to :param [in]: rot Angle of rotation (degrees) :param [in]: cent_rot Center of rotation

  const_data(Matrix4d self) → double const *
  data(Matrix4d self) → double *
  flipx(Matrix4d self)
  getAngles()

    Calculate the Matrix4d’s angles between the X, Y and Z axes

            Matrix4d mat
        PI = 3.14

        mat.loadIdentity()

        m.rotate( PI / 4, vec3d( 0.0, 0.0, 1.0 ) )      # Radians

        vec3d angles = mat.getAngles()

    Return type:

      `vec3d`

    Returns:

      Angle measurement between each axis (degrees)

  getArcballAngles(Matrix4d self) → vec3d
  getBasis(Matrix4d self, vec3d xdir, vec3d ydir, vec3d zdir)
  getMat(Matrix4d self, double * m)
  getRotationAxis(Matrix4d self, vec3d axis_dir, vec3d axis_pnt, double & angle)
  getTranslation(Matrix4d self) → vec3d
  initMat(Matrix4d self, double const * m)
  initMat(Matrix4d self, Matrix4d m)
  loadIdentity()

    Create a 4x4 identity matrix

            #==== Test Matrix4d ====//
        Matrix4d m()                            # Default Constructor
        m.loadIdentity()

  loadXYRef()

    Load an identy Matrix4d and set the Z coordinate of the diagonal (index 10) to -1

            #==== Test Matrix4d ====//
        Matrix4d m()                            # Default Constructor

        m.loadXYRef()

        vec3d b = m.xform( vec3d( 1, 2, 3 ) )

  loadXZRef()

    Load an identy Matrix4d and set the Y coordinate of the diagonal (index 5) to -1

            #==== Test Matrix4d ====//
        Matrix4d m()                            # Default Constructor

        m.loadXZRef()

        vec3d b = m.xform( vec3d( 1, 2, 3 ) )

  loadYZRef()

    Load an identy Matrix4d and set the X coordinate of the diagonal (index 0) to -1

            #==== Test Matrix4d ====//
        Matrix4d m()                            # Default Constructor

        m.loadYZRef()

        vec3d b = m.xform( vec3d( 1, 2, 3 ) )

  matMult(Matrix4d self, double const * m)
  matMult(Matrix4d self, Matrix4d m)
  mirrory()

    Transform the Matrix4d by the given vector

            #==== Test Matrix4d ====//
        Matrix4d m()                            # Default Constructor

        m.loadIdentity()

        vec3d a = m.xform( vec3d( 1.0, 2.0, 3.0 ) )

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

    Rotate the Matrix4d about an arbitrary axis

            #==== Test Matrix4d ====//
        Matrix4d m()                            # Default Constructor
        PI = 3.14

        m.loadIdentity()

        m.rotate( PI / 4, vec3d( 0.0, 0.0, 1.0 ) )      # Radians

    Parameters:

      - [in] – angle Angle of rotation (rad)

      - [in] – axis Vector to rotate about

  rotateX(ang)

    Rotate the Matrix4d about the X axis

            #==== Test Matrix4d ====//
        Matrix4d m()                            # Default Constructor

        m.loadIdentity()

        m.rotateX( 90.0 )

    Parameters:

      [in] – ang Angle of rotation (degrees)

  rotateY(ang)

    Rotate the Matrix4d about the Y axis

            #==== Test Matrix4d ====//
        Matrix4d m()                            # Default Constructor

        m.loadIdentity()

        m.rotateY( 90.0 )

    Parameters:

      [in] – ang Angle of rotation (degrees)

  rotateZ(ang)

    Rotate the Matrix4d about the Z axis

            #==== Test Matrix4d ====//
        Matrix4d m()                            # Default Constructor

        m.loadIdentity()

        m.rotateZ( 90.0 )

    Parameters:

      [in] – ang Angle of rotation (degrees)

  rotatealongX(Matrix4d self, vec3d dir1)
  scale(scale)

    Multiply the Matrix4d by a scalar value

            #==== Test Matrix4d ====//
        Matrix4d m()                            # Default Constructor

        m.loadXZRef()

        m.scale( 10.0 )

    Parameters:

      [in] – scale Value to scale by

  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(x, y, z)

    Translate the Matrix4d along the given axes values

            #==== Test Matrix4d ====//
        Matrix4d m()                            # Default Constructor

        m.loadIdentity()

        m.translatef( 1.0, 0.0, 0.0 )

    Parameters:

      - [in] – x Translation along the X axis

      - [in] – y Translation along the Y axis

      - [in] – z Translation along the Z axis

  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`

  Proxy of C++ std::vector< Matrix4d > class.

  append(Matrix4dVec self, Matrix4d x)
  assign(Matrix4dVec self, std: :vector< Matrix4d >::size_type n, Matrix4d x)
  back(Matrix4dVec self) → Matrix4d
  begin(Matrix4dVec self) → std::vector< Matrix4d >::iterator
  capacity(Matrix4dVec self) → std::vector< Matrix4d >::size_type
  clear(Matrix4dVec self)
  empty(Matrix4dVec self) → bool
  end(Matrix4dVec self) → std::vector< Matrix4d >::iterator
  erase(Matrix4dVec self, std: :vector< Matrix4d >::iterator pos) → std::vector< Matrix4d >::iterator
  erase(Matrix4dVec self, std: :vector< Matrix4d >::iterator first, std: :vector< Matrix4d >::iterator last) → std::vector< Matrix4d >::iterator
  front(Matrix4dVec self) → Matrix4d
  get_allocator(Matrix4dVec self) → std::vector< Matrix4d >::allocator_type
  insert(Matrix4dVec self, std: :vector< Matrix4d >::iterator pos, Matrix4d x) → std::vector< Matrix4d >::iterator
  insert(Matrix4dVec self, std: :vector< Matrix4d >::iterator pos, std: :vector< Matrix4d >::size_type n, Matrix4d x)
  iterator(Matrix4dVec self) → SwigPyIterator
  pop(Matrix4dVec self) → Matrix4d
  pop_back(Matrix4dVec self)
  push_back(Matrix4dVec self, Matrix4d x)
  rbegin(Matrix4dVec self) → std::vector< Matrix4d >::reverse_iterator
  rend(Matrix4dVec self) → std::vector< Matrix4d >::reverse_iterator
  reserve(Matrix4dVec self, std: :vector< Matrix4d >::size_type n)
  resize(Matrix4dVec self, std: :vector< Matrix4d >::size_type new_size)
  resize(Matrix4dVec self, std: :vector< Matrix4d >::size_type new_size, Matrix4d x)
  size(Matrix4dVec self) → std::vector< Matrix4d >::size_type
  swap(Matrix4dVec self, Matrix4dVec v)
  property thisown

    The membership flag

openvsp.vsp.ModeAddGroupSetting(mid, gid, sid)

  Add a variable preset group and setting to a mode.

      # Illustrating use of Modes requires substantial setup of the model including components, sets, and variable presets.
      #
      # Setup boiler plate.
      pod1 = AddGeom( "POD", "" )
      wing = AddGeom( "WING", pod1 )

      SetParmVal( wing, "Trans_Attach_Flag", "Attach", ATTACH_TRANS_LMN )
      SetParmVal( wing, "L_Attach_Location", "Attach", 0.35 )

      SetSetName( SET_FIRST_USER, "NonLifting" )
      SetSetName( SET_FIRST_USER + 1, "Lifting" )

      SetSetFlag( pod1, SET_FIRST_USER, True )
      SetSetFlag( wing, SET_FIRST_USER + 1, True )

      gid = AddVarPresetGroup( "Tess" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )
      AddVarPresetParm( gid, p1 )

      p2 = FindParm( pod1, "Tess_W", "Shape" )
      AddVarPresetParm( gid, p2 )

      sid = AddVarPresetSetting( gid, "Default" )
      SaveVarPresetParmVals( gid, sid )

      sid1 = AddVarPresetSetting( gid, "Coarse" )
      SetVarPresetParmVal( gid, sid1, p1, 3 )
      SetVarPresetParmVal( gid, sid1, p2, 5 )

      sid2 = AddVarPresetSetting( gid, "Fine" )
      SetVarPresetParmVal( gid, sid, p1, 35 )
      SetVarPresetParmVal( gid, sid, p2, 21 )

      gid2 = AddVarPresetGroup( "Design" )

      p3 = FindParm( pod1, "Length", "Design" )
      AddVarPresetParm( gid2, p3 )

      p4 = FindParm( pod1, "FineRatio", "Design" )
      AddVarPresetParm( gid2, p4 )

      sid3 = AddVarPresetSetting( gid2, "Normal" )
      SaveVarPresetParmVals( gid2, sid3 )

      sid4 = AddVarPresetSetting( gid2, "ShortFat" )
      SetVarPresetParmVal( gid2, sid4, p3, 3.0 )
      SetVarPresetParmVal( gid2, sid4, p4, 5.0 )

      sid5 = AddVarPresetSetting( gid2, "LongThin" )
      SetVarPresetParmVal( gid2, sid5, p3, 20.0 )
      SetVarPresetParmVal( gid2, sid5, p4, 35.0 )

      # End of setup boiler plate.

      mid1 = CreateAndAddMode( "FatWetAreas", SET_ALL, SET_NONE )
      ModeAddGroupSetting( mid1, gid, sid1 )
      ModeAddGroupSetting( mid1, gid2, sid4 )

      mid2 = CreateAndAddMode( "ThinAero", SET_FIRST_USER, SET_FIRST_USER + 1 )
      ModeAddGroupSetting( mid2, gid, sid2 )
      ModeAddGroupSetting( mid1, gid2, sid5 )

      ApplyModeSettings( mid2 )
      Update()

  Parameters:

    - [in] – mid string Mode ID to add variable preset to

    - [in] – gid string Variable preset group ID to add to mode

    - [in] – sid string Variable preset setting ID to add to mode

openvsp.vsp.ModeGetAllGroups(mid)

  Get all var preset group IDs in model.

      # Illustrating use of Modes requires substantial setup of the model including components, sets, and variable presets.
      #
      # Setup boiler plate.
      pod1 = AddGeom( "POD", "" )
      wing = AddGeom( "WING", pod1 )

      SetParmVal( wing, "Trans_Attach_Flag", "Attach", ATTACH_TRANS_LMN )
      SetParmVal( wing, "L_Attach_Location", "Attach", 0.35 )

      SetSetName( SET_FIRST_USER, "NonLifting" )
      SetSetName( SET_FIRST_USER + 1, "Lifting" )

      SetSetFlag( pod1, SET_FIRST_USER, True )
      SetSetFlag( wing, SET_FIRST_USER + 1, True )

      gid = AddVarPresetGroup( "Tess" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )
      AddVarPresetParm( gid, p1 )

      p2 = FindParm( pod1, "Tess_W", "Shape" )
      AddVarPresetParm( gid, p2 )

      sid = AddVarPresetSetting( gid, "Default" )
      SaveVarPresetParmVals( gid, sid )

      sid1 = AddVarPresetSetting( gid, "Coarse" )
      SetVarPresetParmVal( gid, sid1, p1, 3 )
      SetVarPresetParmVal( gid, sid1, p2, 5 )

      sid2 = AddVarPresetSetting( gid, "Fine" )
      SetVarPresetParmVal( gid, sid, p1, 35 )
      SetVarPresetParmVal( gid, sid, p2, 21 )

      gid2 = AddVarPresetGroup( "Design" )

      p3 = FindParm( pod1, "Length", "Design" )
      AddVarPresetParm( gid2, p3 )

      p4 = FindParm( pod1, "FineRatio", "Design" )
      AddVarPresetParm( gid2, p4 )

      sid3 = AddVarPresetSetting( gid2, "Normal" )
      SaveVarPresetParmVals( gid2, sid3 )

      sid4 = AddVarPresetSetting( gid2, "ShortFat" )
      SetVarPresetParmVal( gid2, sid4, p3, 3.0 )
      SetVarPresetParmVal( gid2, sid4, p4, 5.0 )

      sid5 = AddVarPresetSetting( gid2, "LongThin" )
      SetVarPresetParmVal( gid2, sid5, p3, 20.0 )
      SetVarPresetParmVal( gid2, sid5, p4, 35.0 )

      # End of setup boiler plate.

      mid1 = CreateAndAddMode( "FatWetAreas", SET_ALL, SET_NONE )
      ModeAddGroupSetting( mid1, gid, sid1 )
      ModeAddGroupSetting( mid1, gid2, sid4 )

      mid2 = CreateAndAddMode( "ThinAero", SET_FIRST_USER, SET_FIRST_USER + 1 )
      ModeAddGroupSetting( mid2, gid, sid2 )
      ModeAddGroupSetting( mid1, gid2, sid5 )

      ApplyModeSettings( mid2 )
      Update()

      gids = ModeGetAllGroups( mid1 )

  Parameters:

    [in] – mid string Mode ID to return all group IDs

  Return type:

    vector< string >

  Returns:

    array<string> array of Group IDs

openvsp.vsp.ModeGetAllSettings(mid)

  Get all var preset setting IDs in model.

      # Illustrating use of Modes requires substantial setup of the model including components, sets, and variable presets.
      #
      # Setup boiler plate.
      pod1 = AddGeom( "POD", "" )
      wing = AddGeom( "WING", pod1 )

      SetParmVal( wing, "Trans_Attach_Flag", "Attach", ATTACH_TRANS_LMN )
      SetParmVal( wing, "L_Attach_Location", "Attach", 0.35 )

      SetSetName( SET_FIRST_USER, "NonLifting" )
      SetSetName( SET_FIRST_USER + 1, "Lifting" )

      SetSetFlag( pod1, SET_FIRST_USER, True )
      SetSetFlag( wing, SET_FIRST_USER + 1, True )

      gid = AddVarPresetGroup( "Tess" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )
      AddVarPresetParm( gid, p1 )

      p2 = FindParm( pod1, "Tess_W", "Shape" )
      AddVarPresetParm( gid, p2 )

      sid = AddVarPresetSetting( gid, "Default" )
      SaveVarPresetParmVals( gid, sid )

      sid1 = AddVarPresetSetting( gid, "Coarse" )
      SetVarPresetParmVal( gid, sid1, p1, 3 )
      SetVarPresetParmVal( gid, sid1, p2, 5 )

      sid2 = AddVarPresetSetting( gid, "Fine" )
      SetVarPresetParmVal( gid, sid, p1, 35 )
      SetVarPresetParmVal( gid, sid, p2, 21 )

      gid2 = AddVarPresetGroup( "Design" )

      p3 = FindParm( pod1, "Length", "Design" )
      AddVarPresetParm( gid2, p3 )

      p4 = FindParm( pod1, "FineRatio", "Design" )
      AddVarPresetParm( gid2, p4 )

      sid3 = AddVarPresetSetting( gid2, "Normal" )
      SaveVarPresetParmVals( gid2, sid3 )

      sid4 = AddVarPresetSetting( gid2, "ShortFat" )
      SetVarPresetParmVal( gid2, sid4, p3, 3.0 )
      SetVarPresetParmVal( gid2, sid4, p4, 5.0 )

      sid5 = AddVarPresetSetting( gid2, "LongThin" )
      SetVarPresetParmVal( gid2, sid5, p3, 20.0 )
      SetVarPresetParmVal( gid2, sid5, p4, 35.0 )

      # End of setup boiler plate.

      mid1 = CreateAndAddMode( "FatWetAreas", SET_ALL, SET_NONE )
      ModeAddGroupSetting( mid1, gid, sid1 )
      ModeAddGroupSetting( mid1, gid2, sid4 )

      mid2 = CreateAndAddMode( "ThinAero", SET_FIRST_USER, SET_FIRST_USER + 1 )
      ModeAddGroupSetting( mid2, gid, sid2 )
      ModeAddGroupSetting( mid1, gid2, sid5 )

      ApplyModeSettings( mid2 )
      Update()

      sids = ModeGetAllSettings( mid1 )

  Parameters:

    [in] – mid string Mode ID to return all group IDs

  Return type:

    vector< string >

  Returns:

    array<string> array of Group IDs

openvsp.vsp.ModeGetGroup(mid, indx)

  Get the group ID of var preset indx from a mode.

      # Illustrating use of Modes requires substantial setup of the model including components, sets, and variable presets.
      #
      # Setup boiler plate.
      pod1 = AddGeom( "POD", "" )
      wing = AddGeom( "WING", pod1 )

      SetParmVal( wing, "Trans_Attach_Flag", "Attach", ATTACH_TRANS_LMN )
      SetParmVal( wing, "L_Attach_Location", "Attach", 0.35 )

      SetSetName( SET_FIRST_USER, "NonLifting" )
      SetSetName( SET_FIRST_USER + 1, "Lifting" )

      SetSetFlag( pod1, SET_FIRST_USER, True )
      SetSetFlag( wing, SET_FIRST_USER + 1, True )

      gid = AddVarPresetGroup( "Tess" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )
      AddVarPresetParm( gid, p1 )

      p2 = FindParm( pod1, "Tess_W", "Shape" )
      AddVarPresetParm( gid, p2 )

      sid = AddVarPresetSetting( gid, "Default" )
      SaveVarPresetParmVals( gid, sid )

      sid1 = AddVarPresetSetting( gid, "Coarse" )
      SetVarPresetParmVal( gid, sid1, p1, 3 )
      SetVarPresetParmVal( gid, sid1, p2, 5 )

      sid2 = AddVarPresetSetting( gid, "Fine" )
      SetVarPresetParmVal( gid, sid, p1, 35 )
      SetVarPresetParmVal( gid, sid, p2, 21 )

      gid2 = AddVarPresetGroup( "Design" )

      p3 = FindParm( pod1, "Length", "Design" )
      AddVarPresetParm( gid2, p3 )

      p4 = FindParm( pod1, "FineRatio", "Design" )
      AddVarPresetParm( gid2, p4 )

      sid3 = AddVarPresetSetting( gid2, "Normal" )
      SaveVarPresetParmVals( gid2, sid3 )

      sid4 = AddVarPresetSetting( gid2, "ShortFat" )
      SetVarPresetParmVal( gid2, sid4, p3, 3.0 )
      SetVarPresetParmVal( gid2, sid4, p4, 5.0 )

      sid5 = AddVarPresetSetting( gid2, "LongThin" )
      SetVarPresetParmVal( gid2, sid5, p3, 20.0 )
      SetVarPresetParmVal( gid2, sid5, p4, 35.0 )

      # End of setup boiler plate.

      mid1 = CreateAndAddMode( "FatWetAreas", SET_ALL, SET_NONE )
      ModeAddGroupSetting( mid1, gid, sid1 )
      ModeAddGroupSetting( mid1, gid2, sid4 )

      mid2 = CreateAndAddMode( "ThinAero", SET_FIRST_USER, SET_FIRST_USER + 1 )
      ModeAddGroupSetting( mid2, gid, sid2 )
      ModeAddGroupSetting( mid1, gid2, sid5 )

      ApplyModeSettings( mid2 )
      Update()

      gid3 = ModeGetGroup( mid1, 0 )

  Parameters:

    - [in] – mid string Mode ID to return GroupID

    - [in] – indx int Index of Variable preset to return GroupID

  Return type:

    string

  Returns:

    string Group ID for Mode Variable preset indx

openvsp.vsp.ModeGetSetting(mid, indx)

  Get the setting ID of var preset indx from a mode.

      # Illustrating use of Modes requires substantial setup of the model including components, sets, and variable presets.
      #
      # Setup boiler plate.
      pod1 = AddGeom( "POD", "" )
      wing = AddGeom( "WING", pod1 )

      SetParmVal( wing, "Trans_Attach_Flag", "Attach", ATTACH_TRANS_LMN )
      SetParmVal( wing, "L_Attach_Location", "Attach", 0.35 )

      SetSetName( SET_FIRST_USER, "NonLifting" )
      SetSetName( SET_FIRST_USER + 1, "Lifting" )

      SetSetFlag( pod1, SET_FIRST_USER, True )
      SetSetFlag( wing, SET_FIRST_USER + 1, True )

      gid = AddVarPresetGroup( "Tess" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )
      AddVarPresetParm( gid, p1 )

      p2 = FindParm( pod1, "Tess_W", "Shape" )
      AddVarPresetParm( gid, p2 )

      sid = AddVarPresetSetting( gid, "Default" )
      SaveVarPresetParmVals( gid, sid )

      sid1 = AddVarPresetSetting( gid, "Coarse" )
      SetVarPresetParmVal( gid, sid1, p1, 3 )
      SetVarPresetParmVal( gid, sid1, p2, 5 )

      sid2 = AddVarPresetSetting( gid, "Fine" )
      SetVarPresetParmVal( gid, sid, p1, 35 )
      SetVarPresetParmVal( gid, sid, p2, 21 )

      gid2 = AddVarPresetGroup( "Design" )

      p3 = FindParm( pod1, "Length", "Design" )
      AddVarPresetParm( gid2, p3 )

      p4 = FindParm( pod1, "FineRatio", "Design" )
      AddVarPresetParm( gid2, p4 )

      sid3 = AddVarPresetSetting( gid2, "Normal" )
      SaveVarPresetParmVals( gid2, sid3 )

      sid4 = AddVarPresetSetting( gid2, "ShortFat" )
      SetVarPresetParmVal( gid2, sid4, p3, 3.0 )
      SetVarPresetParmVal( gid2, sid4, p4, 5.0 )

      sid5 = AddVarPresetSetting( gid2, "LongThin" )
      SetVarPresetParmVal( gid2, sid5, p3, 20.0 )
      SetVarPresetParmVal( gid2, sid5, p4, 35.0 )

      # End of setup boiler plate.

      mid1 = CreateAndAddMode( "FatWetAreas", SET_ALL, SET_NONE )
      ModeAddGroupSetting( mid1, gid, sid1 )
      ModeAddGroupSetting( mid1, gid2, sid4 )

      mid2 = CreateAndAddMode( "ThinAero", SET_FIRST_USER, SET_FIRST_USER + 1 )
      ModeAddGroupSetting( mid2, gid, sid2 )
      ModeAddGroupSetting( mid1, gid2, sid5 )

      ApplyModeSettings( mid2 )
      Update()

      sid6 = ModeGetSetting( mid1, 0 )

  Parameters:

    - [in] – mid string Mode ID to return settingID

    - [in] – indx int Index of Variable preset to return SettingID

  Return type:

    string

  Returns:

    string Setting ID for Mode Variable preset indx

openvsp.vsp.MoveEditXSecPnt(xsec_id, indx, new_pnt)

  Move an EditCurveXSec control point. The XSec points are nondimensionalized by m_Width and m_Height and defined in 2D, so the Z value of the new coordinate point will be ignored.

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      ChangeXSecShape( xsec_surf, 1, XS_EDIT_CURVE )

      # Identify XSec 1
      xsec_1 = GetXSec( xsec_surf, 1 )

      # Turn off R/L symmetry
      SetParmVal( GetXSecParm( xsec_1, "SymType"), SYM_NONE )

      # Get the control points for the default shape
      xsec1_pts = GetEditXSecCtrlVec( xsec_1, True ) # The returned control points will not be scaled by width and height

      # Identify a control point that lies on the curve and shift it in Y
      move_pnt_ind = 3

      new_pnt = vec3d( xsec1_pts[move_pnt_ind].x(), 2 * xsec1_pts[move_pnt_ind].y(), 0.0 )

      # Move the control point
      MoveEditXSecPnt( xsec_1, move_pnt_ind, new_pnt )

      new_pnts = GetEditXSecCtrlVec( xsec_1, True ) # The returned control points will not be scaled by width and height

      if  dist( new_pnt, new_pnts[move_pnt_ind] ) > 1e-6 :
          print( "Error: MoveEditXSecPnt" )

  Parameters:

    - [in] – xsec_id string XSec ID

    - [in] – indx int Control point index

    - [in] – new_pnt vec3d Coordinate of the new point

openvsp.vsp.MoveFeaPolySparPt(pspar_id, index, reorder_type)

  Move a point within an FEA Poly Spar using a reorder type and return the new index of the moved point.

      wing_id = AddGeom( "WING" )

      struct_ind = AddFeaStruct( wing_id )

      pspar_id = AddFeaPart( wing_id, struct_ind, FEA_POLY_SPAR )

      AddFeaPolySparPt( pspar_id )

      # Move point at index 2 up one position
      new_index = MoveFeaPolySparPt( pspar_id, 2, REORDER_MOVE_UP )

      if new_index != 1:
          print( "Error: MoveFeaPolySparPt" )

  See also: REORDER_TYPE, AddFeaPolySparPt, GetFeaPolySparNumPt :param [in]: pspar_id string FEA Poly Spar part ID :param [in]: index int Index of the point to move :param [in]: reorder_type int Reorder type enum (i.e. REORDER_MOVE_UP, REORDER_MOVE_DOWN, REORDER_MOVE_TOP, REORDER_MOVE_BOTTOM) :rtype: int :return: int New index of the moved point

openvsp.vsp.MoveRoutingPt(routing_id, index, reorder_type)

  Move a specified routing point within the route of a RoutingGeom.

      pod1 = vsp.AddGeom('POD', '')

      pod2 = vsp.AddGeom('POD', '')
      ypod2 = vsp.GetParm(pod2, 'Y_Rel_Location', 'XForm')
      vsp.SetParmVal(ypod2, 2.0)

      routing_geom = vsp.AddGeom('ROUTING', '')

      rpt0 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u0 = vsp.GetParm( rpt0, 'U', 'RoutePt')
      vsp.SetParmVal(u0, 0.0)

      rpt1 = vsp.AddRoutingPt(routing_geom, pod2, 0)

      rpt2 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u2 = vsp.GetParm( rpt2, 'U', 'RoutePt')
      vsp.SetParmVal(u2, 1.0)

      newindx = vsp.MoveRoutingPt( routing_geom, 1, vsp.REORDER_MOVE_DOWN )

  See also: AddRoutingPt, DelRoutingPt, REORDER_TYPE :param [in]: routing_id string RoutingGeom Geom ID :param [in]: index int Index of routing point to move :param [in]: reorder_type int Enum specifying reordering type (i.e. REORDER_MOVE_UP, REORDER_MOVE_DOWN, REORDER_MOVE_TOP, REORDER_MOVE_BOTTOM)

openvsp.vsp.NGON_MESH_GEOM_SCREEN = 5

  NGon Mesh geom screen

openvsp.vsp.NGON_MESH_TYPE = 2

  N-gon mesh

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_ATTR_EVENT_GROUPS = 1

  Number attribute event groups

openvsp.vsp.NUM_AUX_GEOM_MODES = 12

  Number of auxiliary geom modes.

openvsp.vsp.NUM_BOGIE_SPACING_TYPE = 4

  Number of bogie spacing control modes

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_FRAGMENT_MODES = 6

  Number of auxiliary geom modes.

openvsp.vsp.NUM_GDEV_TYPES = 31

  Number of GDEV types

openvsp.vsp.NUM_GEAR_CONFIGURATION_MODES = 5

  Number of gear configuration choices

openvsp.vsp.NUM_GEAR_RETRACT_MODES = 2

  Number of gear retract choices

openvsp.vsp.NUM_GEAR_SUSPENSION_MODES = 3

  Number of gear suspension choices

openvsp.vsp.NUM_GEOM_SCREENS = 21

  Number of geom screens

openvsp.vsp.NUM_INIT_EDIT_XSEC_TYPES = 3

  Number of initializable edit curve types

openvsp.vsp.NUM_INTERFERENCE_TYPES = 20

  Number of interference check types

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_MESH_TYPE = 3

  Number of mesh types

openvsp.vsp.NUM_PCURV_TYPE = 4

  Number of curve types

openvsp.vsp.NUM_POLY_SPAR_POINT_TYPES = 3

  Number of poly spar point 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 = 5

  Number of Projected Area target types

openvsp.vsp.NUM_PROP_AZI = 3

  Number of propeller blade azimuth modes

openvsp.vsp.NUM_PROP_BLADE_MODES = 2

  Number of propeller blade modes

openvsp.vsp.NUM_PROP_DRIVER = 9

  Number of actuator disk drivers

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 = 6

  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_TIRE_CLEARANCE_MODES = 3

  Number of tire clearance modes

openvsp.vsp.NUM_TIRE_CONTACT_MODES = 4

  Number of tire radius modes

openvsp.vsp.NUM_TIRE_DIM_MODES = 3

  Number of tire dimension choices

openvsp.vsp.NUM_TIRE_MODES = 6

  Number of tire choices

openvsp.vsp.NUM_TRIM_TYPES = 3

  Number of conformal component trim types

openvsp.vsp.NUM_WHEEL_TIRE_FAILURE_MODES = 6

  Number of wheel and tire failure modes

openvsp.vsp.NUM_WSECT_DRIVER = 8

  Number of wing section drivers

openvsp.vsp.NUM_XSEC_DRIVER = 4

  Number of XSec drivers

openvsp.vsp.NumFeaBCs(fea_struct_id)

  Return number of FEA BC’s in a structure

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      struct_id = GetFeaStructID( pod_id, struct_ind );

      #==== Add BC ====//
      bc_id = AddFeaBC( struct_id, FEA_BC_STRUCTURE )

      nbc = NumFeaBCs( struct_id )

  Parameters:

    [in] – fea_struct_id string FEA Structure ID

  Return type:

    int

  Returns:

    int Number of FEA BCs

openvsp.vsp.NumFeaParts(fea_struct_id)

  Get the number of FEA Parts for a particular FEA Structure

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      struct_id = GetFeaStructID( pod_id, struct_ind )

      #==== Add FEA Parts ====//
      slice_id = AddFeaPart( pod_id, struct_ind, FEA_SLICE )
      dome_id = AddFeaPart( pod_id, struct_ind, FEA_DOME )

      if  NumFeaParts( struct_id ) != 3 : # Includes FeaSkin

          print( "Error: NumFeaParts" )

  See also: GetFeaPartIDVec :param [in]: fea_struct_id string FEA Structure ID :rtype: int :return: int Number of FEA Parts

openvsp.vsp.NumFeaStructures()

  Get the total number of FEA Structures in the vehicle

      #==== Add Pod Geometry ====//
      wing_id = AddGeom( "WING" )

      #==== Add FeaStructure to Pod ====//
      struct_1 = AddFeaStruct( wing_id )
      struct_2 = AddFeaStruct( wing_id )

      if  NumFeaStructures() != 2 :
          print( "Error: NumFeaStructures" )

  See also: GetFeaStructIDVec :rtype: int :return: int Total Number of FEA Structures

openvsp.vsp.NumFeaSubSurfs(fea_struct_id)

  Get the number of FEA Subsurfaces for a particular FEA Structure

      #==== Add Pod Geometry ====//
      wing_id = AddGeom( "WING" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( wing_id )

      struct_id = GetFeaStructID( wing_id, struct_ind )

      #==== Add SubSurfaces ====//
      line_array_id = AddFeaSubSurf( wing_id, struct_ind, SS_LINE_ARRAY )
      rectangle_id = AddFeaSubSurf( wing_id, struct_ind, SS_RECTANGLE )

      if  NumFeaSubSurfs( struct_id ) != 2 :
          print( "Error: NumFeaSubSurfs" )

  See also: GetFeaSubSurfIDVec :param [in]: fea_struct_id string FEA Structure ID :rtype: int :return: int Number of FEA SubSurfaces

openvsp.vsp.ONE_THIRD_ROTOR_FRAGMENT = 0

  One third rotor fragment

openvsp.vsp.OPEN = 0

  Browse files that already exist

openvsp.vsp.OUTSIDE = 1

  The exterior of the sub-surface is its surface

openvsp.vsp.PACKAGING_INTERFERENCE = 1

  Interference when one body is internal to another

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.PARM_REFERENCE_DATA = 9

  Parm reference data type

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(geom_id, pcurveid, newtype)

  Change the type of a propeller blade curve (P Curve) See also: PCURV_TYPE :param [in]: geom_id string Parent Geom ID :param [in]: pcurveid int P Curve index :param [in]: newtype int Curve type enum (i.e. CEDIT)

openvsp.vsp.PCurveDeletePt(geom_id, pcurveid, indx)

  Delete a propeller blade curve (P Curve) point :param [in]: geom_id string Parent Geom ID :param [in]: pcurveid int P Curve index :param [in]: indx int Point index

openvsp.vsp.PCurveGetTVec(geom_id, pcurveid)

  Get the parameters of a propeller blade curve (P Curve). Each parameter is a fraction of propeller radius. :param [in]: geom_id string Parent Geom ID :param [in]: pcurveid int P Curve index :rtype: std::vector< double,std::allocator< double > > :return: vector <double> Array of parameters

openvsp.vsp.PCurveGetType(geom_id, pcurveid)

  Get the type of a propeller blade curve (P Curve) See also: PCURV_TYPE :param [in]: geom_id string Parent Geom ID :param [in]: pcurveid int P Curve index :rtype: int :return: int Curve type enum (i.e. CEDIT)

openvsp.vsp.PCurveGetValVec(geom_id, pcurveid)

  Get the values of a propeller blade curve (P Curve). What the values represent id dependent on the curve type (i.e. twist, chord, etc.). :param [in]: geom_id string Parent Geom ID :param [in]: pcurveid int P Curve index :rtype: std::vector< double,std::allocator< double > > :return: vector <double> Array of values

openvsp.vsp.PCurveSplit(geom_id, pcurveid, tsplit)

  Split a propeller blade curve (P Curve) at the specified 1D parameter :param [in]: geom_id string Parent Geom ID :param [in]: pcurveid int P Curve index :param [in]: tsplit double 1D parameter split location :rtype: int :return: int Index of new control point

openvsp.vsp.PD_UNITS_IMPERIAL = 0

  Imperial unit system

openvsp.vsp.PD_UNITS_METRIC = 1

  Metric unit system

openvsp.vsp.PLANAR_SLICE = 16

  Calculate planar slices and area distribution

openvsp.vsp.PLANE_1PT_ANGLE_INTERFERENCE = 6

  Interference roll angle between surfaces and a plane

openvsp.vsp.PLANE_2PT_ANGLE_INTERFERENCE = 4

  Interference angle between surfaces and a plane

openvsp.vsp.PLANE_STATIC_DISTANCE_INTERFERENCE = 3

  Interference between surfaces and a plane

openvsp.vsp.POD_GEOM_SCREEN = 0

  Pod geom screen

openvsp.vsp.POINT_END_CAP = 5

  Point end cap

openvsp.vsp.POINT_SOURCE = 0

  Point source

openvsp.vsp.POLY_SPAR_POINT_ETA = 2

  Spar points span specified in eta

openvsp.vsp.POLY_SPAR_POINT_U01 = 0

  Spar points span specified in U01

openvsp.vsp.POLY_SPAR_POINT_U0N = 1

  Spar points span specified in U0N

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.PROJ_AREA = 17

  Calculate projected area

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_BLADE_NONTRADITIONAL = 1

  Non-traditional blades

openvsp.vsp.PROP_BLADE_TRADITIONAL = 0

  Traditional straight 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 = 9

  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 = 8

  Point cloud geom screen

openvsp.vsp.P_PROP_DRIVER = 6

  Power driver

openvsp.vsp.PasteAttribute(coll_id)

  Paste the attribute clipboard to the specified objectID ObjectID can be any OpenVSP entity that contains a AttributeCollection or simply the attributeCollectionID Returns a vector of pasted attributes IDs, if any

      ##==== Attribute: PasteAttribute  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      AttrName = 'Example_String_Attr'
      StringValue = 'Example_String_Attr_DataVal'
      AttrID = AddAttributeString( CollID, AttrName, StringValue )
      CutAttribute( AttrID )

      NewCollID = GetChildCollection( "_AttrWMGroup" )
      NewAttrIDs = PasteAttribute( NewCollID )

      MatchIDs = NewAttrIDs[0] == AttrID
      Attr_Cut_Check = AttrID not in FindAttributesInCollection( CollID )
      Attr_Paste_Check = AttrID in FindAttributesInCollection( NewCollID )
      if MatchIDs and Attr_Cut_Check and Attr_Paste_Check:
          print("Successfully pasted Attribute")
      else:
          print("PasteAttribute Error!")

  Parameters:

    [in] – coll_id string ID of destination for pasting attribute into

openvsp.vsp.PasteGeomClipboard(*args)

  Paste Geom from clipboard into the model. The Geom is pasted as a child of the specified parent, but will be placed at top level if no parent or an invalid one is provided.

      #==== Add Pod Geometries ====//
      pid1 = AddGeom( "POD", "" )
      pid2 = AddGeom( "POD", "" )

      CutGeomToClipboard( pid1 )

      PasteGeomClipboard( pid2 ) # Paste Pod 1 as child of Pod 2

      geom_ids = FindGeoms()

      if  len(geom_ids) != 2 : print( "---> Error: API Cut/Paste Geom  " )

  Parameters:

    [in] – parent string Parent Geom ID

  Return type:

    std::vector< std::string,std::allocator< std::string > >

  Returns:

    vector<string> Vector of pasted Geom IDs

openvsp.vsp.PasteXSec(geom_id, index)

  Paste the cross-section currently held in memory to the specified geometry

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Copy XSec To Clipboard
      CopyXSec( sid, 1 )

      # Paste To XSec 3
      PasteXSec( sid, 3 )

  See also: CutXSec, CopyXSec :param [in]: geom_id string Geom ID :param [in]: index int XSec index

openvsp.vsp.PointInPolygon(vec2d R, std: :vector< vec2d, std: :allocator< vec2d > > const & pnts) → bool

openvsp.vsp.PopupMsg(msg)

  Cause OpenVSP to display a popup message.

      StartGUI()

      PopupMsg( "This is a popup message." )

  Parameters:

    [in] – msg string Message to display.

openvsp.vsp.PrintAnalysisDocs(analysis_name)

  Print to stdout all current input documentation for a specific analysis

      #==== Analysis: VSPAero Compute Geometry ====//
      analysis_name = "VSPAEROComputeGeometry"

      # list inputs, type, and documentation
      PrintAnalysisDocs( analysis_name )

  Parameters:

    [in] – analysis_name string Name of analysis

openvsp.vsp.PrintAnalysisInputs(analysis_name)

  Print to stdout all current input values for a specific analysis

      #==== Analysis: VSPAero Compute Geometry ====//
      analysis_name = "VSPAEROComputeGeometry"

      # list inputs, type, and current values
      PrintAnalysisInputs( analysis_name )

  Parameters:

    [in] – analysis_name string Name of analysis

openvsp.vsp.PrintResults(results_id)

  Print a result’s name value pairs to stdout

      # Add Pod Geom
      pid = AddGeom( "POD" )

      analysis_name = "VSPAEROComputeGeometry"

      rid = ExecAnalysis( analysis_name )

      # Get & Display Results
      PrintResults( rid )

  Parameters:

    [in] – results_id string Result ID

openvsp.vsp.PrintResultsDocs(results_id)

  Print a result’s names and documentation to stdout

      # Add Pod Geom
      pid = AddGeom( "POD" )

      analysis_name = "VSPAEROComputeGeometry"

      rid = ExecAnalysis( analysis_name )

      # Get & Display Results Docs
      PrintResultsDocs( rid )

  Parameters:

    [in] – results_id string Result ID

openvsp.vsp.ProjPnt01(geom_id, surf_indx, pt)

  Determine the nearest surface coordinate for an input 3D coordinate point and calculate the distance between the 3D point and the closest point of the surface.

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      surf_indx = 0

      u = 0.12345
      w = 0.67890

      pnt = CompPnt01( geom_id, surf_indx, u, w )

      norm = CompNorm01( geom_id, surf_indx, u, w )

      # Offset point from surface
      pnt.set_xyz( pnt.x() + norm.x(), pnt.y() + norm.y(), pnt.z() + norm.z() )

      d, uout, wout = ProjPnt01( geom_id, surf_indx, pnt )

      print( f"Dist {d} u {uout} w {wout}" )

  See also: ProjPnt01Guess, ProjPnt01I :param [in]: geom_id string Parent Geom ID :param [in]: surf_indx int Main surface index from the parent Geom :param [in]: pt vec3d Input 3D coordinate point :param [out]: u_out double Output closest U (0 - 1) surface coordinate :param [out]: w_out double Output closest W (0 - 1) surface coordinate :rtype: float :return: double Distance between the 3D point and the closest point of the surface

openvsp.vsp.ProjPnt01Guess(geom_id, surf_indx, pt, u0, w0)

  Determine the nearest surface coordinate for an input 3D coordinate point and calculate the distance between the 3D point and the closest point of the surface. This function takes an input surface coordinate guess for, offering a potential decrease in computation time compared to ProjPnt01.

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      surf_indx = 0

      u = 0.12345
      w = 0.67890

      d = 0

      pnt = CompPnt01( geom_id, surf_indx, u, w )

      norm = CompNorm01( geom_id, surf_indx, u, w )

      # Offset point from surface
      pnt.set_xyz( pnt.x() + norm.x(), pnt.y() + norm.y(), pnt.z() + norm.z() )

      d, uout, wout = ProjPnt01Guess( geom_id, surf_indx, pnt, u + 0.1, w + 0.1 )

      print( f"Dist {d} u {uout} w {wout}" )

  See also: ProjPnt01, ProjPnt01I :param [in]: geom_id string Parent Geom ID :param [in]: surf_indx int Main surface index from the parent Geom :param [in]: pt vec3d Input 3D coordinate point :param [in]: u0 double Input U (0 - 1) surface coordinate guess :param [in]: w0 double Input W (0 - 1) surface coordinate guess :param [out]: u_out double Output closest U (0 - 1) surface coordinate :param [out]: w_out double Output closest W (0 - 1) surface coordinate :rtype: float :return: double Distance between the 3D point and the closest point of the surface

openvsp.vsp.ProjPnt01I(geom_id, pt)

  Determine the nearest surface coordinate and corresponding parent Geom main surface index for an input 3D coordinate point. Return the distance between the closest point and the input.

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      surf_indx = 0

      u = 0.12345
      w = 0.67890

      d = 0

      pnt = CompPnt01( geom_id, surf_indx, u, w )

      norm = CompNorm01( geom_id, surf_indx, u, w )

      # Offset point from surface
      pnt.set_xyz( pnt.x() + norm.x(), pnt.y() + norm.y(), pnt.z() + norm.z() )

      d, surf_indx_out, uout, wout = ProjPnt01I( geom_id, pnt )

      print( f"Dist {d} u {uout} w {wout} surf_index {surf_indx_out}" )

  See also: ProjPnt01, ProjPnt01Guess :param [in]: geom_id string Parent Geom ID :param [in]: pt vec3d Input 3D coordinate point :param [out]: surf_indx_out int Output main surface index from the parent Geom :param [out]: u_out double Output closest U (0 - 1) surface coordinat :param [out]: w_out double Output closest W (0 - 1) surface coordinat :rtype: float :return: double Distance between the 3D point and the closest point of the surface

openvsp.vsp.ProjVecPnt01(geom_id, surf_indx, pts)

  Determine the nearest surface coordinates for an input array of 3D coordinate points and calculate the distance between each 3D point and the closest point of the surface.

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      n = 5

      uvec = [0]*n
      wvec = [0]*n

      for i in range(n):

          uvec[i] = (i+1)*1.0/(n+1)

          wvec[i] = (n-i)*1.0/(n+1)

      ptvec = CompVecPnt01( geom_id, 0, uvec, wvec )

      normvec = CompVecNorm01( geom_id, 0, uvec, wvec )

      for i in range(n):

          ptvec[i].set_xyz( ptvec[i].x() + normvec[i].x(), ptvec[i].y() + normvec[i].y(), ptvec[i].z() + normvec[i].z() )

      uoutv, woutv, doutv = ProjVecPnt01( geom_id, 0, ptvec )

  See also: ProjVecPnt01Guess :param [in]: geom_id string Parent Geom ID :param [in]: surf_indx int Main surface index from the parent Geom :param [in]: pts vector<vec3d> Input vector of 3D coordinate points :param [out]: u_out_vec vector<double> Output vector of the closest U (0 - 1) surface coordinate for each 3D input point :param [out]: w_out_vec vector<double> Output vector of the closest W (0 - 1) surface coordinate for each 3D input point :param [out]: d_out_vec vector<double> Output vector of distances for each 3D point and the closest point of the surface

openvsp.vsp.ProjVecPnt01Guess(geom_id, surf_indx, pts, u0s, w0s)

  Determine the nearest surface coordinates for an input array of 3D coordinate points and calculate the distance between each 3D point and the closest point of the surface. This function takes an input array of surface coordinate guesses for each 3D coordinate, offering a potential decrease in computation time compared to ProjVecPnt01.

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      n = 5

      uvec = [0]*n
      wvec = [0]*n

      for i in range(n):

          uvec[i] = (i+1)*1.0/(n+1)

          wvec[i] = (n-i)*1.0/(n+1)

      ptvec = CompVecPnt01( geom_id, 0, uvec, wvec )

      normvec = CompVecNorm01( geom_id, 0, uvec, wvec )

      for i in range(n):

          ptvec[i].set_xyz( ptvec[i].x() + normvec[i].x(), ptvec[i].y() + normvec[i].y(), ptvec[i].z() + normvec[i].z() )

      u0v = [0]*n
      w0v = [0]*n

      for i in range(n):

          u0v[i] = uvec[i] + 0.01234

          w0v[i] = wvec[i] - 0.05678

      uoutv, woutv, doutv = ProjVecPnt01Guess( geom_id, 0, ptvec, u0v,  w0v )

  See also: ProjVecPnt01, :param [in]: geom_id string Parent Geom ID :param [in]: surf_indx int Main surface index from the parent Geom :param [in]: pts vector<vec3d> Input vector of 3D coordinate points :param [in]: u0s vector<double> Input vector of U (0 - 1) surface coordinate guesses :param [in]: w0s vector<double> Input vector of W (0 - 1) surface coordinate guesses :param [out]: u_out_vec vector<double> Output vector of the closest U (0 - 1) surface coordinate for each 3D input point :param [out]: w_out_vec vector<double> Output vector of the closest W (0 - 1) surface coordinate for each 3D input point :param [out]: d_out_vec vector<double> Output array of distances for each 3D point and the closest point of the surface

openvsp.vsp.PromoteBORCSTLower(bor_id)

  Promote the CST for the lower airfoil surface of a BOR. The XSecCurve must be of type XS_CST_AIRFOIL See also: GetLowerCSTDegree :param [in]: bor_id string Body of revolution Geom ID

openvsp.vsp.PromoteBORCSTUpper(bor_id)

  Promote the CST for the upper airfoil surface of a BOR. The XSecCurve must be of type XS_CST_AIRFOIL See also: GetUpperCSTDegree :param [in]: bor_id string Body of revolution Geom ID

openvsp.vsp.PromoteCSTLower(xsec_id)

  Promote the CST for the lower airfoil surface. The XSec must be of type XS_CST_AIRFOIL See also: GetLowerCSTDegree :param [in]: xsec_id string XSec ID

openvsp.vsp.PromoteCSTUpper(xsec_id)

  Promote the CST for the upper airfoil surface. The XSec must be of type XS_CST_AIRFOIL See also: GetUpperCSTDegree :param [in]: xsec_id string XSec ID

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

openvsp.vsp.QUAD_MESH_TYPE = 1

  Quadrilateral mesh

openvsp.vsp.Q_PROP_DRIVER = 8

  Torque driver

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.RISK_ANGLE = 14

  Calculate risk angle for thrown debris

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.ROUTE_PT_COMP = 0

  Routing point relative to parent body axes

openvsp.vsp.ROUTE_PT_DELTA_COMP = 1

  Routing point offset in parent body frame

openvsp.vsp.ROUTE_PT_DELTA_NUM_TYPES = 3

  Number of routing point offset coordinate types

openvsp.vsp.ROUTE_PT_DELTA_UVN = 2

  Routing point offset in parent surface coordinate frame

openvsp.vsp.ROUTE_PT_DELTA_XYZ = 0

  Routing point ofset in global axes

openvsp.vsp.ROUTE_PT_EtaMN = 4

  Routing point relative to wing parent uniform eta volume coordinate frame

openvsp.vsp.ROUTE_PT_LMN = 3

  Routing point relative to parent uniform volume coordinate frame

openvsp.vsp.ROUTE_PT_NUM_TYPES = 5

  Number of routing point coordinate types

openvsp.vsp.ROUTE_PT_RST = 2

  Routing point relative to parent per-section volume coordinate frame

openvsp.vsp.ROUTE_PT_UV = 1

  Routing point relative to parent surface coordinate frame

openvsp.vsp.ROUTING_GEOM_SCREEN = 17

  Routing geom screen

openvsp.vsp.RPM_PROP_DRIVER = 0

  RPM driver

openvsp.vsp.ReadApplyDESFile(file_name)

  Read in and apply a design file (*.des) to the current OpenVSP project :param [in]: file_name string *.des input file

openvsp.vsp.ReadApplyXDDMFile(file_name)

  Read in and apply a Cart3D XDDM file (*.xddm) to the current OpenVSP project :param [in]: file_name string *.xddm input file

openvsp.vsp.ReadBORFileAirfoil(bor_id, file_name)

  Read in shape from airfoil file and set to the specified BOR XSecCurve. The XSecCurve must be of type XS_FILE_AIRFOIL. Airfoil files may be in Lednicer or Selig format with *.af or *.dat extensions.

      # Add Body of Recolution
      bor_id = AddGeom( "BODYOFREVOLUTION", "" )

      ChangeBORXSecShape( bor_id, XS_FILE_AIRFOIL )

      ReadBORFileAirfoil( bor_id, "airfoil/N0012_VSP.af" )

  Parameters:

    - [in] – bor_id string Body of revolution Geom ID

    - [in] – file_name string Airfoil XSec file name

openvsp.vsp.ReadBORFileXSec(bor_id, file_name)

  Set the coordinate points for a specific BOR. The BOR XSecCurve must be of type XS_FILE_FUSE.

      # Add Body of Recolution
      bor_id = AddGeom( "BODYOFREVOLUTION", "" )

      ChangeBORXSecShape( bor_id, XS_FILE_FUSE )

      vec_array = ReadBORFileXSec( bor_id, "TestXSec.fxs" )

  Parameters:

    - [in] – bor_id string Body of revolution Geom ID

    - [in] – file_name string Fuselage XSec file name

  Return type:

    std::vector< vec3d,std::allocator< vec3d > >

  Returns:

    vector<vec3d> Array of coordinate points read from the file and set to the XSec

openvsp.vsp.ReadFileAirfoil(xsec_id, file_name)

  Read in XSec shape from airfoil file and set to the specified XSec. The XSec must be of type XS_FILE_AIRFOIL. Airfoil files may be in Lednicer or Selig format with *.af or *.dat extensions.

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE", "" )

      xsec_surf = GetXSecSurf( fuseid, 0 )

      ChangeXSecShape( xsec_surf, 1, XS_FILE_AIRFOIL )

      xsec = GetXSec( xsec_surf, 1 )

      ReadFileAirfoil( xsec, "airfoil/N0012_VSP.af" )

  Parameters:

    - [in] – xsec_id string XSec ID

    - [in] – file_name string Airfoil XSec file name

openvsp.vsp.ReadFileXSec(xsec_id, file_name)

  Read in XSec shape from fuselage (*.fsx) file and set to the specified XSec. The XSec must be of type XS_FILE_FUSE.

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE", "" )

      xsec_surf = GetXSecSurf( fuseid, 0 )

      ChangeXSecShape( xsec_surf, 2, XS_FILE_FUSE )

      xsec = GetXSec( xsec_surf, 2 )

      vec_array = ReadFileXSec(xsec, "TestXSec.fxs")

  Parameters:

    - [in] – xsec_id string XSec ID

    - [in] – file_name string Fuselage XSec file name

  Return type:

    std::vector< vec3d,std::allocator< vec3d > >

  Returns:

    vector<vec3d> Array of coordinate points read from the file and set to the XSec

openvsp.vsp.ReadVSPFile(file_name)

  Load an OpenVSP project from a VSP3 file

      fid = AddGeom( "FUSELAGE", "" )             # Add Fuselage

      fname = "example_fuse.vsp3"

      SetVSP3FileName( fname )

      Update()

      #==== Save Vehicle to File ====//
      print( "\tSaving vehicle file to: ", False )

      print( fname )

      WriteVSPFile( GetVSPFileName(), SET_ALL )

      #==== Reset Geometry ====//
      print( "--->Resetting VSP model to blank slate\n" )

      ClearVSPModel()

      ReadVSPFile( fname )

  Parameters:

    [in] – file_name string *.vsp3 file name

openvsp.vsp.RegisterCFDMeshAnalyses()

openvsp.vsp.RemoveAllFromVSPAEROControlSurfaceGroup(CSGroupIndex)

  Remove all used control surfaces from the control surface group at the specified index

      wid = AddGeom( "WING", "" )                             # Add Wing

      aileron_id = AddSubSurf( wid, SS_CONTROL )                      # Add Control Surface Sub-Surface

      group_index = CreateVSPAEROControlSurfaceGroup() # Empty control surface group

      AddAllToVSPAEROControlSurfaceGroup( group_index )

      RemoveAllFromVSPAEROControlSurfaceGroup( group_index ) # Empty control surface group

  Parameters:

    [in] – CSGroupIndex int Index of the control surface group

openvsp.vsp.RemoveAllGroupSettings(mid)

  Remove all variable preset groups and settings from mode.

      # Illustrating use of Modes requires substantial setup of the model including components, sets, and variable presets.
      #
      # Setup boiler plate.
      pod1 = AddGeom( "POD", "" )
      wing = AddGeom( "WING", pod1 )

      SetParmVal( wing, "Trans_Attach_Flag", "Attach", ATTACH_TRANS_LMN )
      SetParmVal( wing, "L_Attach_Location", "Attach", 0.35 )

      SetSetName( SET_FIRST_USER, "NonLifting" )
      SetSetName( SET_FIRST_USER + 1, "Lifting" )

      SetSetFlag( pod1, SET_FIRST_USER, True )
      SetSetFlag( wing, SET_FIRST_USER + 1, True )

      gid = AddVarPresetGroup( "Tess" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )
      AddVarPresetParm( gid, p1 )

      p2 = FindParm( pod1, "Tess_W", "Shape" )
      AddVarPresetParm( gid, p2 )

      sid = AddVarPresetSetting( gid, "Default" )
      SaveVarPresetParmVals( gid, sid )

      sid1 = AddVarPresetSetting( gid, "Coarse" )
      SetVarPresetParmVal( gid, sid1, p1, 3 )
      SetVarPresetParmVal( gid, sid1, p2, 5 )

      sid2 = AddVarPresetSetting( gid, "Fine" )
      SetVarPresetParmVal( gid, sid, p1, 35 )
      SetVarPresetParmVal( gid, sid, p2, 21 )

      gid2 = AddVarPresetGroup( "Design" )

      p3 = FindParm( pod1, "Length", "Design" )
      AddVarPresetParm( gid2, p3 )

      p4 = FindParm( pod1, "FineRatio", "Design" )
      AddVarPresetParm( gid2, p4 )

      sid3 = AddVarPresetSetting( gid2, "Normal" )
      SaveVarPresetParmVals( gid2, sid3 )

      sid4 = AddVarPresetSetting( gid2, "ShortFat" )
      SetVarPresetParmVal( gid2, sid4, p3, 3.0 )
      SetVarPresetParmVal( gid2, sid4, p4, 5.0 )

      sid5 = AddVarPresetSetting( gid2, "LongThin" )
      SetVarPresetParmVal( gid2, sid5, p3, 20.0 )
      SetVarPresetParmVal( gid2, sid5, p4, 35.0 )

      # End of setup boiler plate.

      mid1 = CreateAndAddMode( "FatWetAreas", SET_ALL, SET_NONE )
      ModeAddGroupSetting( mid1, gid, sid1 )
      ModeAddGroupSetting( mid1, gid2, sid4 )

      mid2 = CreateAndAddMode( "ThinAero", SET_FIRST_USER, SET_FIRST_USER + 1 )
      ModeAddGroupSetting( mid2, gid, sid2 )
      ModeAddGroupSetting( mid1, gid2, sid5 )

      ApplyModeSettings( mid2 )
      Update()

      RemoveAllGroupSettings( mid1 )

  Parameters:

    [in] – mid string Mode ID to remove all variable presets from

openvsp.vsp.RemoveGroupSetting(mid, indx)

  Remove the indx’th variable preset group and setting from the specified mode.

      # Illustrating use of Modes requires substantial setup of the model including components, sets, and variable presets.
      #
      # Setup boiler plate.
      pod1 = AddGeom( "POD", "" )
      wing = AddGeom( "WING", pod1 )

      SetParmVal( wing, "Trans_Attach_Flag", "Attach", ATTACH_TRANS_LMN )
      SetParmVal( wing, "L_Attach_Location", "Attach", 0.35 )

      SetSetName( SET_FIRST_USER, "NonLifting" )
      SetSetName( SET_FIRST_USER + 1, "Lifting" )

      SetSetFlag( pod1, SET_FIRST_USER, True )
      SetSetFlag( wing, SET_FIRST_USER + 1, True )

      gid = AddVarPresetGroup( "Tess" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )
      AddVarPresetParm( gid, p1 )

      p2 = FindParm( pod1, "Tess_W", "Shape" )
      AddVarPresetParm( gid, p2 )

      sid = AddVarPresetSetting( gid, "Default" )
      SaveVarPresetParmVals( gid, sid )

      sid1 = AddVarPresetSetting( gid, "Coarse" )
      SetVarPresetParmVal( gid, sid1, p1, 3 )
      SetVarPresetParmVal( gid, sid1, p2, 5 )

      sid2 = AddVarPresetSetting( gid, "Fine" )
      SetVarPresetParmVal( gid, sid, p1, 35 )
      SetVarPresetParmVal( gid, sid, p2, 21 )

      gid2 = AddVarPresetGroup( "Design" )

      p3 = FindParm( pod1, "Length", "Design" )
      AddVarPresetParm( gid2, p3 )

      p4 = FindParm( pod1, "FineRatio", "Design" )
      AddVarPresetParm( gid2, p4 )

      sid3 = AddVarPresetSetting( gid2, "Normal" )
      SaveVarPresetParmVals( gid2, sid3 )

      sid4 = AddVarPresetSetting( gid2, "ShortFat" )
      SetVarPresetParmVal( gid2, sid4, p3, 3.0 )
      SetVarPresetParmVal( gid2, sid4, p4, 5.0 )

      sid5 = AddVarPresetSetting( gid2, "LongThin" )
      SetVarPresetParmVal( gid2, sid5, p3, 20.0 )
      SetVarPresetParmVal( gid2, sid5, p4, 35.0 )

      # End of setup boiler plate.

      mid1 = CreateAndAddMode( "FatWetAreas", SET_ALL, SET_NONE )
      ModeAddGroupSetting( mid1, gid, sid1 )
      ModeAddGroupSetting( mid1, gid2, sid4 )

      mid2 = CreateAndAddMode( "ThinAero", SET_FIRST_USER, SET_FIRST_USER + 1 )
      ModeAddGroupSetting( mid2, gid, sid2 )
      ModeAddGroupSetting( mid1, gid2, sid5 )

      ApplyModeSettings( mid2 )
      Update()

      RemoveGroupSetting( mid1, 0 )

  Parameters:

    - [in] – mid string Mode ID to remove varible preset group and setting from

    - [in] – indx int Index of Variable preset to remove

openvsp.vsp.RemoveSelectedFromCSGroup(selected, CSGroupIndex)

  Remove each control surfaces in the array of control surface indexes from the control surface group at the specified index.

  Warning: The indexes in input “selected” must be matched with active control surfaces identified by GetActiveCSNameVec. The “selected” input uses one-based indexing to associate available control surfaces.

      wid = AddGeom( "WING", "" ) # Add Wing

      aileron_id = AddSubSurf( wid, SS_CONTROL ) # Add Control Surface Sub-Surface

      group_index = CreateVSPAEROControlSurfaceGroup() # Empty control surface group

      cs_name_vec = GetAvailableCSNameVec( group_index )

      cs_ind_vec = [0] * len(cs_name_vec)

      for i in range(int( len(cs_name_vec) )):

          cs_ind_vec[i] = i + 1

      AddSelectedToCSGroup( cs_ind_vec, group_index ) # Add the available control surfaces to the group

      remove_cs_ind_vec = [1]

      RemoveSelectedFromCSGroup( remove_cs_ind_vec, group_index ) # Remove the first control surface

  See also: GetActiveCSNameVec :param [in]: selected vector <int> Array of control surface indexes to remove from the group. Note, the integer values are one based. :param [in]: CSGroupIndex int Index of the control surface group

openvsp.vsp.ReparameterizeEditXSec(xsec_id)

  Perform an equal arc length repareterization on an EditCurveXSec. The reparameterization is performed between specific U values if the Fixed U flag is true. This allows corners, such as at 0.25, 0.5, and 0.75 U, to be held constant while everything between them is reparameterized.

      # Add Wing
      wid = AddGeom( "WING" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( wid, 0 )

      ChangeXSecShape( xsec_surf, 1, XS_EDIT_CURVE )

      # Identify XSec 1
      xsec_1 = GetXSec( xsec_surf, 1 )

      fixed_u_vec = list(GetEditXSecFixedUVec( xsec_1 ))

      fixed_u_vec[3] = True # change a flag

      SetEditXSecFixedUVec( xsec_1, fixed_u_vec )

      ReparameterizeEditXSec( xsec_1 )

  See also: SetEditXSecFixedUVec, GetEditXSecFixedUVec :param [in]: xsec_id string XSec ID

openvsp.vsp.ResetPropellerThicknessCurve(geom_id)

  Reset propeller T/C curve to match basic thickness of file-type airfoils. Typically only used for a propeller that has been constructed with file-type airfoils across the blade. The new thickness curve will be a PCHIP curve with t/c matching the propeller’s XSecs – unless it is a file XSec, then the Base thickness is used.

      # Add Propeller
      prop = AddGeom( "PROP", "" )

      ResetPropellerThicknessCurve( prop )

  Parameters:

    [in] – geom_id string Geom ID

openvsp.vsp.ResetViews()

  Reset views of all viewports

      ResetViews()

openvsp.vsp.ResetXSecSkinParms(xsec_id)

  Reset all skinning Parms for a specified XSec. Set top, bottom, left, and right strengths, slew, angle, and curvature to 0. Set all symmetry and equality conditions to false.

      fid = AddGeom( "FUSELAGE", "" )             # Add Fuselage

      xsec_surf = GetXSecSurf( fid, 0 )           # Get First (and Only) XSec Surf

      num_xsecs = GetNumXSec( xsec_surf )

      xsec = GetXSec( xsec_surf, 1 )

      SetXSecTanAngles( xsec, XSEC_BOTH_SIDES, 0.0, -1.0e12, -1.0e12, -1.0e12 )       # Set Tangent Angles At Cross Section
      SetXSecContinuity( xsec, 1 )                       # Set Continuity At Cross Section

      ResetXSecSkinParms( xsec )

  Parameters:

    [in] – xsec_id string XSec ID

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

openvsp.vsp.RotateSet(set_index, x_rot_deg, y_rot_deg, z_rot_deg)

  Rotate a set about the global X, Y, and Z axes

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE" )

      SetSetFlag( fuseid, 3, True )

      # Rotate 90 degrees about Y
      RotateSet( 3, 0, 90, 0 )

  Parameters:

    - [in] – set_index int Set index

    - [in] – x_rot_deg double Rotation about the X axis (degrees)

    - [in] – y_rot_deg double Rotation about the Y axis (degrees)

    - [in] – z_rot_deg double Rotation about the Z axis (degrees)

openvsp.vsp.SAVE = 1

  Browse file system and enter file name

openvsp.vsp.SCALE_HEIGHT = 1

  Scale image to match desired height with 1:1 AR

openvsp.vsp.SCALE_HEIGHT_AR = 5

  Scale image to match desired height with specified AR

openvsp.vsp.SCALE_RESOLUTION = 3

  Scale image to specified resolution

openvsp.vsp.SCALE_WIDTH = 0

  Scale image to match desired width with 1:1 AR

openvsp.vsp.SCALE_WIDTH_AR = 4

  Scale image to match desired width with specified AR

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.SMALL_FRAGMENT = 4

  Small fragment

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_INTERSECT = 7

  Intersection derived sub-surface type

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 = 8

  Number of sub-surface types

openvsp.vsp.SS_RECTANGLE = 1

  Rectangle sub-surface type

openvsp.vsp.SS_XSEC_CURVE = 6

  XSecCurve based sub-surface type

openvsp.vsp.STABILITY_ADJOINT = 6

  Steady 6DOF stability analysis using adjoint

openvsp.vsp.STABILITY_DEFAULT = 1

  Steady 6DOF stability analysis

openvsp.vsp.STABILITY_NUM_TYPES = 7

  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 = 6

  Stack geom screen

openvsp.vsp.STALL_OFF = 0

  Stall modeling off

openvsp.vsp.STALL_ON = 1

  Stall modeling on

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 = 3

  String 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.SaveVarPresetParmVals(group_id, setting_id)

  Save current Parm values to Variable Preset Setting

      # Add Pod Geom
      pod1 = AddGeom( "POD", "" )

      gid = AddVarPresetGroup( "Tess" )

      sid = AddVarPresetSetting( gid, "Coarse" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )

      AddVarPresetParm( gid, p1 )

      SaveVarPresetParmVals( gid, sid )

  Parameters:

    - [in] – group_id string Var Preset Group ID

    - [in] – setting_id string Var Preset Setting ID

openvsp.vsp.ScaleSet(set_index, scale)

  Apply a scale factor to a set

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE" )

      SetSetFlag( fuseid, 3, True )

      # Scale by a factor of 2
      ScaleSet( 3, 2.0 )

  Parameters:

    - [in] – set_index int Set index

    - [in] – scale double Scale factor

openvsp.vsp.ScreenGrab(fname, w, h, transparentBG, autocrop=False)

  Capture the specified screen and save to file. Note, VSP_USE_FLTK must be defined

      screenw = 2000                                             # Set screenshot width and height
      screenh = 2000

      fname = "test_screen_grab.png"

      ScreenGrab( fname, screenw, screenh, True, True )                # Take PNG screenshot

  Parameters:

    - [in] – fname string Output file name

    - [in] – w int Width of screen grab

    - [in] – h int Height of screen grab

    - [in] – transparentBG bool Transparent background flag

    - [in] – autocrop bool Automatically crop transparent background flag

openvsp.vsp.SearchReplaceAdvLinkCode(index, _from, to)

  Search and replace strings in the advanced link code

      pod = AddGeom( "POD", "" )
      length = FindParm( pod, "Length", "Design" )
      x_pos = GetParm( pod, "X_Rel_Location", "XForm" )

      AddAdvLink( "ExampleLink" )
      indx = GetLinkIndex( "ExampleLink" )
      AddAdvLinkInput( indx, length, "len" )
      AddAdvLinkOutput( indx, x_pos, "x" )

      SetAdvLinkCode( indx, "x = 10.0 - len;" )
      SearchReplaceAdvLinkCode( indx, "10.0", "12.3" )

      code = GetAdvLinkCode( indx )

      print( code )

      BuildAdvLinkScript( indx )

  Parameters:

    - [in] – index int Index for advanced link

    - [in] – from string Search token

    - [in] – to string Replace token

openvsp.vsp.SetActiveGeometryAnalysis(id)

  Set the active Geometry Analysis case. The active case is the one drawn in the Geometry Analysis GUI (and captured by ScreenGrab). Setting it does not require the GUI to be present.

      ga_id = AddGeometryAnalysis()
      SetActiveGeometryAnalysis( ga_id )

  See also: GetActiveGeometryAnalysis, AddGeometryAnalysis :param [in]: id string Geometry Analysis case ID (empty string for none)

openvsp.vsp.SetAdvLinkCode(index, code)

  Get the code from an advanced link

      pod = AddGeom( "POD", "" )
      length = FindParm( pod, "Length", "Design" )
      x_pos = GetParm( pod, "X_Rel_Location", "XForm" )

      AddAdvLink( "ExampleLink" )
      indx = GetLinkIndex( "ExampleLink" )
      AddAdvLinkInput( indx, length, "len" )
      AddAdvLinkOutput( indx, x_pos, "x" )

      SetAdvLinkCode( indx, "x = 10.0 - len;" )

      BuildAdvLinkScript( indx )

  Parameters:

    - [in] – index int Index for advanced link

    - [in] – code string Code for advanced link

openvsp.vsp.SetAirfoilLowerPnts(xsec_id, low_pnt_vec)

  Set the lower points for an airfoil. The XSec must be of type XS_FILE_AIRFOIL.

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE", "" )

      xsec_surf = GetXSecSurf( fuseid, 0 )

      ChangeXSecShape( xsec_surf, 1, XS_FILE_AIRFOIL )

      xsec = GetXSec( xsec_surf, 1 )

      ReadFileAirfoil( xsec, "airfoil/N0012_VSP.af" )

      low_array = GetAirfoilLowerPnts( xsec )

      for i in range(int( len(low_array) )):

          low_array[i].scale_y( 0.5 )

      SetAirfoilUpperPnts( xsec, low_array )

  Parameters:

    - [in] – xsec_id string XSec ID

    - [in] – low_pnt_vec vector<vec3d> Array of points defining the lower surface of the airfoil

openvsp.vsp.SetAirfoilPnts(xsec_id, up_pnt_vec, low_pnt_vec)

  Set the upper and lower points for an airfoil. The XSec must be of type XS_FILE_AIRFOIL.

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE", "" )

      xsec_surf = GetXSecSurf( fuseid, 0 )

      ChangeXSecShape( xsec_surf, 1, XS_FILE_AIRFOIL )

      xsec = GetXSec( xsec_surf, 1 )

      ReadFileAirfoil( xsec, "airfoil/N0012_VSP.af" )

      up_array = GetAirfoilUpperPnts( xsec )

      low_array = GetAirfoilLowerPnts( xsec )

      for i in range(int( len(up_array) )):

          up_array[i].scale_y( 2.0 )

          low_array[i].scale_y( 0.5 )

      SetAirfoilPnts( xsec, up_array, low_array )

  Parameters:

    - [in] – xsec_id string XSec ID

    - [in] – up_pnt_vec vector<vec3d> Array of points defining the upper surface of the airfoil

    - [in] – low_pnt_vec vector<vec3d> Array of points defining the lower surface of the airfoil

openvsp.vsp.SetAirfoilUpperPnts(xsec_id, up_pnt_vec)

  Set the upper points for an airfoil. The XSec must be of type XS_FILE_AIRFOIL.

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE", "" )

      xsec_surf = GetXSecSurf( fuseid, 0 )

      ChangeXSecShape( xsec_surf, 1, XS_FILE_AIRFOIL )

      xsec = GetXSec( xsec_surf, 1 )

      ReadFileAirfoil( xsec, "airfoil/N0012_VSP.af" )

      up_array = GetAirfoilUpperPnts( xsec )

      for i in range(int( len(up_array) )):

          up_array[i].scale_y( 2.0 )

      SetAirfoilUpperPnts( xsec, up_array )

  Parameters:

    - [in] – xsec_id string XSec ID

    - [in] – up_pnt_vec vector<vec3d> Array of points defining the upper surface of the airfoil

openvsp.vsp.SetAllViews(view)

  Set the view of all viewports

      SetAllViews( CAM_CENTER )

  Parameters:

    [in] – view int CAMERA_VIEW enum

openvsp.vsp.SetAnalysisInputDefaults(analysis)

  Set all input values to their defaults for a specific analysis

  >     #==== Analysis: VSPAero Compute Geometry ====//
  >     analysis_name = "VSPAEROComputeGeometry"

  >     # Set defaults
  >     SetAnalysisInputDefaults( analysis_name )

  > param [in]:

  >   analysis string Analysis name

openvsp.vsp.SetAttributeBool(attrID, value)

  Set the Bool value of a bool-type Attribute by ID

      ##==== Attribute: SetAttributeBool  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      InitVal = True
      AttrID = AddAttributeBool( CollID, "TestBoolAttr", InitVal )

      SetVal = False
      SetAttributeBool( AttrID, SetVal )

      GetVal = GetAttributeBoolVal( AttrID )
      if GetVal[0] == SetVal:
          print( "Set matching Bool Value from Attribute" )
      else:
          print( "SetAttributeBoolVal error!" )

  Parameters:

    - [in] – attrID string of attribute ID

    - [in] – value bool boolean value for attribute

openvsp.vsp.SetAttributeDoc(attrID, doc)

  Set the docstring of an Attribute by ID

      ##==== Attribute: SetAttributeDoc  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      InitVal = "Hello_World_of_Attributes"
      AttrID = AddAttributeString( CollID, "TestStringAttr", InitVal )

      DocString = 'New_docstring_for_attribute'

      SetAttributeDoc( AttrID, DocString )
      NewDocString = GetAttributeDoc( AttrID )
      if NewDocString == DocString:
          print( "Got matching DocString from Attribute")
      else:
          print( "SetAttributeDoc error!" )

  Parameters:

    - [in] – attrID string of attribute ID

    - [in] – doc string of documentation for attribute

openvsp.vsp.SetAttributeDouble(attrID, value)

  Set the Double value of a double-type Attribute by ID

      ##==== Attribute: SetAttributeDouble  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      InitVal = 3.14159
      AttrID = AddAttributeDouble( CollID, "TestDoubleAttr", InitVal )

      DoubleVal = 3.15

      SetAttributeDouble( AttrID, DoubleVal )

      GetVal = GetAttributeDoubleVal( AttrID )
      if GetVal[0] == DoubleVal:
          print( "Set matching Double Value from Attribute" )
      else:
          print( "SetAttributeDoubleVal error!" )

  Parameters:

    - [in] – attrID string of attribute ID

    - [in] – value double value for attribute

openvsp.vsp.SetAttributeDoubleMatrix(attrID, value)

  Set the double matrix of a double-matrix-type Attribute by ID

      ##==== Attribute: SetAttributeDoubleMatrix  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      InitVal = [[0., 1.,],[-4., -1000.]]
      AttrID = AddAttributeDoubleMatrix( CollID, "TestDoubleMatrixAttr", InitVal )

      NewDmatVal = [[0.,1.5],[8.4,1.1566]]
      SetAttributeDoubleMatrix( AttrID, NewDmatVal )

      DblMatrixVal = GetAttributeDoubleMatrixVal( AttrID )
      DblMatrixVal = [list(row) for row in DblMatrixVal]

      if DblMatrixVal == NewDmatVal:
          print( "Got matching Double Matrix Value from Attribute" )
      else:
          print( "GetAttributeDoubleMatrixVal error!" )

  Parameters:

    - [in] – attrID string of attribute ID

    - [in] – value double matrix value for attribute

openvsp.vsp.SetAttributeInt(attrID, value)

  Set the Int value of an int-type Attribute by ID

      ##==== Attribute: SetAttributeInt  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      InitVal = 55
      AttrID = AddAttributeInt( CollID, "TestIntAttr", InitVal )

      NewIntVal = -55

      SetAttributeInt( AttrID, NewIntVal )
      GetVal = GetAttributeIntVal( AttrID )
      if GetVal[0] == NewIntVal:
          print( "Set matching Int Value from Attribute" )
      else:
          print( "SetAttributeIntVal error!" )

  Parameters:

    - [in] – attrID string of attribute ID

    - [in] – value int value for attribute

openvsp.vsp.SetAttributeIntMatrix(attrID, value)

  Set the int matrix of a int-matrix-type Attribute by ID

      ##==== Attribute: SetAttributeIntMatrix  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      InitVal = [[0, 1,],[-4, -1000]]
      AttrID = AddAttributeIntMatrix( CollID, "TestIntMatrixAttr", InitVal )

      ImatVal = [[1,5],[-8,0]]
      SetAttributeIntMatrix( AttrID, ImatVal )

      IntMatrixVal = GetAttributeIntMatrixVal( AttrID )
      IntMatrixVal = [list(row) for row in IntMatrixVal]

      if IntMatrixVal == ImatVal:
          print( "Set matching IntMatrix Value from Attribute" )
      else:
          print( "SetAttributeIntMatrixVal error!" )

  Parameters:

    - [in] – attrID string of attribute ID

    - [in] – value int matrix value for attribute

openvsp.vsp.SetAttributeName(attrID, name)

  Set the name of an Attribute by ID

      ##==== Attribute: SetAttributeName  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      InitVal = "Hello_World_of_Attributes"
      AttrID = AddAttributeString( CollID, "TestStringAttr", InitVal )

      NameString = 'NewName_Example'
      SetAttributeName( AttrID, NameString )
      AttrName = GetAttributeName( AttrID )
      if NameString == AttrName:
          print( "Got matching name from Attribute")
      else:
          print( "SetAttributeName error!" )

  Parameters:

    - [in] – attrID string of attribute ID

    - [in] – name string name for attribute

openvsp.vsp.SetAttributeParmID(attrID, value)

  Set the ParmID value of a Parm-type Attribute by ID

      ##==== Attribute: SetAttributeParmID  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )

      PodID = AddGeom( "POD", "" )
      print( "---> Test Get Parm Val" )
      ParmArray = GetGeomParmIDs( PodID )

      ParmID = ParmArray[0]
      AttrID = AddAttributeParm( CollID, "TestParmAttr", ParmID )

      NewParmID = ParmArray[1]
      SetAttributeParmID( AttrID, NewParmID )
      GetID = GetAttributeParmID( AttrID )

      if GetID[0] == NewParmID:
          print( "Set matching Parm ID from Attribute" )
      else:
          print( "SetAttributeParmID error!" )

  Parameters:

    - [in] – attrID string of attribute ID

    - [in] – value string value for attribute

openvsp.vsp.SetAttributeString(attrID, value)

  Set the String value of a string-type Attribute by ID

      ##==== Attribute: SetAttributeString  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      InitVal = "Hello_World_of_Attributes"
      AttrID = AddAttributeString( CollID, "TestStringAttr", InitVal )

      StringVal = "Du bist supergeil!"
      SetAttributeString( AttrID, StringVal )

      GetVal = GetAttributeStringVal( AttrID )
      if GetVal[0] == StringVal:
          print( "Got matching String Value from Attribute" )
      else:
          print( "GetAttributeStringVal error!" )

  Parameters:

    - [in] – attrID string of attribute ID

    - [in] – value string value for attribute

openvsp.vsp.SetAttributeVec3d(attrID, value)

  Set the Vec3d value of a Vec3d-type Attribute by ID

      ##==== Attribute: SetAttributeVec3d  =====##

      VehID = GetVehicleID()
      CollID = GetChildCollection( VehID )
      InitVal = vec3d([1., 0.5, -4.])
      AttrID = AddAttributeVec3d( CollID, "TestVec3dAttr", [InitVal] )

      Vec3dVal = vec3d([0.5, 0.75, -0.4])
      SetAttributeVec3d( AttrID, [Vec3dVal] )

      GetVal = GetAttributeVec3dVal( AttrID )
      if ( GetVal[0].x() == Vec3dVal.x() ) and ( GetVal[0].y() == Vec3dVal.y() ) and ( GetVal[0].z() == Vec3dVal.z() ):
          print( "Set matching Vec3d Value from Attribute" )
      else:
          print( "SetAttributeVec3dVal error!" )

  Parameters:

    - [in] – attrID string of attribute ID

    - [in] – value vec3d value for attribute

openvsp.vsp.SetBEMPropID(prop_id)

  Set the ID of the propeller to be exported to a BEM file. Call this function before ExportFile.

      #==== Add Prop Geometry ====//
      prop_id = AddGeom( "PROP" )

      SetBEMPropID( prop_id )

      ExportFile( "ExampleBEM.bem", SET_ALL, EXPORT_BEM )

  See also: EXPORT_TYPE, ExportFile :param [in]: prop_id string Propeller Geom ID

openvsp.vsp.SetBORAirfoilLowerPnts(bor_id, low_pnt_vec)

  Set the lower points for an airfoil on a BOR. The BOR XSecCurve must be of type XS_FILE_AIRFOIL.

      # Add Body of Recolution
      bor_id = AddGeom( "BODYOFREVOLUTION", "" )

      ChangeBORXSecShape( bor_id, XS_FILE_AIRFOIL )

      ReadBORFileAirfoil( bor_id, "airfoil/N0012_VSP.af" )

      low_array = GetBORAirfoilLowerPnts( bor_id )

      for i in range(int( len(low_array) )):

          low_array[i].scale_y( 0.5 )

      SetBORAirfoilLowerPnts( bor_id, low_array )

  Parameters:

    - [in] – bor_id string Body of revolution Geom ID

    - [in] – low_pnt_vec vector<vec3d> Vector of points defining the lower surface of the airfoil

openvsp.vsp.SetBORAirfoilPnts(bor_id, up_pnt_vec, low_pnt_vec)

  Set the upper and lower points for an airfoil on a BOR. The BOR XSecCurve must be of type XS_FILE_AIRFOIL.

      # Add Body of Recolution
      bor_id = AddGeom( "BODYOFREVOLUTION", "" )

      ChangeBORXSecShape( bor_id, XS_FILE_AIRFOIL )

      ReadBORFileAirfoil( bor_id, "airfoil/N0012_VSP.af" )

      up_array = GetBORAirfoilUpperPnts( bor_id )

      low_array = GetBORAirfoilLowerPnts( bor_id )

      for i in range(int( len(up_array) )):

          up_array[i].scale_y( 2.0 )

          low_array[i].scale_y( 0.5 )

      SetBORAirfoilPnts( bor_id, up_array, low_array )

  Parameters:

    - [in] – bor_id string Body of revolution Geom ID

    - [in] – up_pnt_vec vector<vec3d> Vector of points defining the upper surface of the airfoil

    - [in] – low_pnt_vec vector<_>vec3d> Vector of points defining the lower surface of the airfoil

openvsp.vsp.SetBORAirfoilUpperPnts(bor_id, up_pnt_vec)

  Set the upper points for an airfoil on a BOR. The BOR XSecCurve must be of type XS_FILE_AIRFOIL.

      # Add Body of Recolution
      bor_id = AddGeom( "BODYOFREVOLUTION", "" )

      ChangeBORXSecShape( bor_id, XS_FILE_AIRFOIL )

      ReadBORFileAirfoil( bor_id, "airfoil/N0012_VSP.af" )

      up_array = GetBORAirfoilUpperPnts( bor_id )

      for i in range(int( len(up_array) )):

          up_array[i].scale_y( 2.0 )

      SetBORAirfoilUpperPnts( bor_id, up_array )

  Parameters:

    - [in] – bor_id string Body of revolution Geom ID

    - [in] – up_pnt_vec vector<vec3d> Vector of points defining the upper surface of the airfoil

openvsp.vsp.SetBORLowerCST(bor_id, deg, coefs)

  Set the CST degree and coefficients for the lower surface of an airfoil of a BOR. The number of coefficients should be one more than the CST degree. The XSecCurve must be of type XS_CST_AIRFOIL See also: GetLowerCSTDegree, GetLowerCSTCoefs :param [in]: bor_id string Body of revolution Geom ID :param [in]: deg int CST degree of lower airfoil surface :param [in]: coefs vector<double> Vector of CST coefficients for the lower airfoil surface

openvsp.vsp.SetBORUpperCST(bor_id, deg, coefs)

  Set the CST degree and coefficients for the upper surface of an airfoil of a BOR. The number of coefficients should be one more than the CST degree. The XSecCurve must be of type XS_CST_AIRFOIL See also: GetUpperCSTDegree, GetUpperCSTCoefs :param [in]: bor_id string Body of revolution Geom ID :param [in]: deg int CST degree of upper airfoil surface :param [in]: coefs vector<double> Array of CST coefficients for the upper airfoil surface

openvsp.vsp.SetBORXSecPnts(bor_id, pnt_vec)

  Set the coordinate points for a specific BOR. The BOR XSecCurve must be of type XS_FILE_FUSE.

      # Add Body of Recolution
      bor_id = AddGeom( "BODYOFREVOLUTION", "" )

      ChangeBORXSecShape( bor_id, XS_FILE_FUSE )

      vec_array = ReadBORFileXSec( bor_id, "TestXSec.fxs" )

      if  len(vec_array) > 0 :
          vec_array[1] = vec_array[1] * 2.0
          vec_array[3] = vec_array[3] * 2.0

          SetBORXSecPnts( bor_id, vec_array )

  Parameters:

    - [in] – bor_id string Body of revolution Geom ID

    - [in] – pnt_vec vector<vec3d> Vector of XSec coordinate points

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

  Set the background color

      SetBackground( 1.0, 1.0, 1.0 )                                 # Set background to bright white

  Parameters:

    - [in] – r double Red 8-bit unsigned integer (range: 0-255)

    - [in] – g double Green 8-bit unsigned integer (range: 0-255)

    - [in] – b double Blue 8-bit unsigned integer (range: 0-255)

openvsp.vsp.SetBackground3DAbsolutePath(id, fname)

  Set absolute path to specified Background3D’s image.

      # Add Background3D
      bg_id = AddBackground3D()

      SetBackground3DAbsolutePath( bg_id, "front.png" )
      bg_file = GetBackground3DAbsolutePath( bg_id )

      print( bg_file )

      DelAllBackground3Ds()

  Parameters:

    - [in] – id string Background3D ID

    - [in] – fname string Absolute path to Background3D image file

openvsp.vsp.SetBackground3DRelativePath(id, fname)

  Set relative path to specified Background3D’s image. Note that path is relative to the model’s *.vsp3 file. Consequently, if a file has not yet been saved or assigned a file name, the relative path is meaningless.

      # Add Background3D
      bg_id = AddBackground3D()

      SetBackground3DRelativePath( bg_id, "front.png" )
      bg_file = GetBackground3DRelativePath( bg_id )

      print( bg_file )

      DelAllBackground3Ds()

  Parameters:

    - [in] – id string Background3D ID

    - [in] – fname string Relative path to Background3D image file

openvsp.vsp.SetCFDMeshVal(type, val)

  Set the value of a specific CFD Mesh option

      SetCFDMeshVal( CFD_MIN_EDGE_LEN, 1.0 )

  See also: CFD_CONTROL_TYPE :param [in]: type int CFD Mesh control type enum (i.e. CFD_GROWTH_RATIO) :param [in]: val double Value to set

openvsp.vsp.SetCFDWakeFlag(geom_id, flag)

  Activate or deactivate the CFD Mesh wake for a particular Geom. Note, the wake flag is only applicable for wing-type surfaces. Also, this function is simply an alternative to setting the value of the Parm with the available Parm setting API functions.

      #==== Add Wing Geom ====//
      wid = AddGeom( "WING", "" )

      SetCFDWakeFlag( wid, True )
      # This is equivalent to SetParmValUpdate( wid, "Wake", "Shape", 1.0 )
      # To change the scale: SetParmValUpdate( wid, "WakeScale", "WakeSettings", 10.0 )
      # To change the angle: SetParmValUpdate( wid, "WakeAngle", "WakeSettings", -5.0 )

  See also: SetParmVal, SetParmValUpdate :param [in]: geom_id string Geom ID :param [in]: flag bool True to activate, false to deactivate

openvsp.vsp.SetComputationFileName(file_type, file_name)

  Get the file name of a specified file type. Note, this function cannot be used to set FEA Mesh file names.

      #==== Set File Name ====//
      SetComputationFileName( DEGEN_GEOM_CSV_TYPE, "TestDegenScript.csv" )

      #==== Run Degen Geom ====//
      ComputeDegenGeom( SET_ALL, DEGEN_GEOM_CSV_TYPE )

  See also: COMPUTATION_FILE_TYPE, SetFeaMeshFileName :param [in]: file_type int File type enum (i.e. CFD_TRI_TYPE, COMP_GEOM_TXT_TYPE) :param [in]: file_name string File name

openvsp.vsp.SetDoubleAnalysisInput(analysis, name, indata, index=0)

  Set the value of a particular analysis input of double type

      #==== Analysis: CpSlicer ====//
      analysis_name = "CpSlicer"

      # Setup cuts
      ycuts = []
      ycuts.append( 2.0 )
      ycuts.append( 4.5 )
      ycuts.append( 8.0 )

      SetDoubleAnalysisInput( analysis_name, "YSlicePosVec", ycuts, 0 )

  See also: GetDoubleAnalysisInput :param [in]: analysis string Analysis name :param [in]: name string Input name :param [in]: indata vector<double> Array of double values to set the input to :param [in]: index int Data index

openvsp.vsp.SetDriverGroup(geom_id, section_index, driver_0, driver_1=-1, driver_2=-1)

  Set the driver group for a wing section or a XSecCurve. Care has to be taken when setting these driver groups to ensure a valid combination.

      #==== Add Wing Geometry and Set Parms ====//
      wing_id = AddGeom( "WING", "" )

      #==== Set Wing Section Controls ====//
      SetDriverGroup( wing_id, 1, AR_WSECT_DRIVER, ROOTC_WSECT_DRIVER, TIPC_WSECT_DRIVER )

      Update()

      #==== Set Parms ====//
      SetParmVal( wing_id, "Root_Chord", "XSec_1", 2 )
      SetParmVal( wing_id, "Tip_Chord", "XSec_1", 1 )

      Update()

  See also: WING_DRIVERS, XSEC_DRIVERS :param [in]: geom_id string Geom ID :param [in]: section_index int Wing section index :param [in]: driver_0 int First driver enum (i.e. SPAN_WSECT_DRIVER) :param [in]: driver_1 int Second driver enum (i.e. ROOTC_WSECT_DRIVER) :param [in]: driver_2 int Third driver enum (i.e. TIPC_WSECT_DRIVER)

openvsp.vsp.SetEditXSecFixedUVec(xsec_id, fixed_u_vec)

  Set the vector of fixed U flags for each control point in an EditCurveXSec. The fixed U flag is used to hold the U parameter of the control point constant when performing an equal arc length reparameterization of the curve.

      # Add Wing
      wid = AddGeom( "WING" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( wid, 0 )

      ChangeXSecShape( xsec_surf, 1, XS_EDIT_CURVE )

      # Identify XSec 1
      xsec_1 = GetXSec( xsec_surf, 1 )

      fixed_u_vec = list(GetEditXSecFixedUVec( xsec_1 ))

      fixed_u_vec[3] = True # change a flag

      SetEditXSecFixedUVec( xsec_1, fixed_u_vec )

      ReparameterizeEditXSec( xsec_1 )

  See also: GetEditXSecFixedUVec, ReparameterizeEditXSec :param [in]: xsec_id string XSec ID :param [in]: fixed_u_vec vector <bool> Array of fixed U flags

openvsp.vsp.SetEditXSecPnts(xsec_id, u_vec, control_pts, r_vec)

  Set the U parameter vector and the control point vector for an EditCurveXSec. The arrays must be of equal length, with the values for U defined in increasing order and range 0 - 1. The input control points to SetEditXSecPnts must be nondimensionalized in the approximate range of [-0.5, 0.5].

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      ChangeXSecShape( xsec_surf, 2, XS_EDIT_CURVE )

      # Identify XSec 2
      xsec_2 = GetXSec( xsec_surf, 2 )

      # Set XSec 2 to linear
      EditXSecConvertTo( xsec_2, LINEAR )

      # Turn off R/L symmetry
      SetParmVal( GetXSecParm( xsec_2, "SymType"), SYM_NONE )

      # Define a square
      xsec2_pts = [vec3d(0.5, 0.5, 0.0),
               vec3d(0.5, -0.5, 0.0),
               vec3d(-0.5, -0.5, 0.0),
               vec3d(-0.5, 0.5, 0.0),
               vec3d(0.5, 0.5, 0.0)]

      # u vec must start at 0.0 and end at 1.0
      u_vec = [0.0, 0.25, 0.5, 0.75, 1.0]

      r_vec = [0.0, 0.0, 0.0, 0.0, 0.0]

      SetEditXSecPnts( xsec_2, u_vec, xsec2_pts, r_vec ) # Note: points are unscaled by the width and height parms

      new_pnts = GetEditXSecCtrlVec( xsec_2, True ) # The returned control points will not be scaled by width and height

      if  dist( new_pnts[3], xsec2_pts[3] ) > 1e-6 :
          print( "Error: SetEditXSecPnts")

  Parameters:

    - [in] – xsec_id string XSec ID

    - [in] – u_vec vector <double> Array of U parameter values

    - [in] – r_vec vector <double> Array of R parameter values

    - [in] – control_pts vector <vec3d> Nondimensionalized array of control points

openvsp.vsp.SetFeaMeshFileName(geom_id, fea_struct_ind, file_type, file_name)

  Set the name of a particular FEA Mesh output file for a specified Structure

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      struct_id = GetFeaStructID( pod_id, struct_ind )

      #=== Set Export File Name ===//
      export_name = "FEAMeshTest_calculix.dat"

      #==== Get Parent Geom ID and Index ====//
      parent_id = GetFeaStructParentGeomID( struct_id ) # same as pod_id

      SetFeaMeshFileName( parent_id, struct_ind, FEA_CALCULIX_FILE_NAME, export_name )

  Parameters:

    - [in] – geom_id string Parent Geom ID

    - [in] – fea_struct_ind int FEA Structure index

    - [in] – file_type int FEA output file type enum (i.e. FEA_EXPORT_TYPE)

    - [in] – file_name string Name for the output file

openvsp.vsp.SetFeaMeshStructIndex(struct_index)

  Sets FeaMeshMgr m_FeaMeshStructIndex member using passed in index of a FeaStructure

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      SetFeaMeshStructIndex( struct_ind )

      if  len(FindGeoms()) != 0 : print( "ERROR: VSPRenew" )

openvsp.vsp.SetFeaMeshVal(geom_id, fea_struct_ind, type, val)

  Set the value of a particular FEA Mesh option for the specified Structure. Note, FEA Mesh makes use of enums initially created for CFD Mesh but not all CFD Mesh options are available for FEA Mesh.

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      #==== Adjust FeaMeshSettings ====//
      SetFeaMeshVal( pod_id, struct_ind, CFD_MAX_EDGE_LEN, 0.75 )

      SetFeaMeshVal( pod_id, struct_ind, CFD_MIN_EDGE_LEN, 0.2 )

  See also: CFD_CONTROL_TYPE :param [in]: geom_id string Parent Geom ID :param [in]: fea_struct_ind int FEA Structure index :param [in]: type int FEA Mesh option type enum (i.e. CFD_MAX_EDGE_LEN) :param [in]: val double Value the option is set to

openvsp.vsp.SetFeaPartName(part_id, name)

  Set the name of an FEA Part

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      #==== Add Bulkead ====//
      bulkhead_id = AddFeaPart( pod_id, struct_ind, FEA_SLICE )

      SetFeaPartName( bulkhead_id, "Bulkhead" )

  See also: GetFeaPartName :param [in]: part_id string FEA Part ID :param [in]: name string New name for the FEA Part

openvsp.vsp.SetFeaPartPerpendicularSparID(part_id, perpendicular_spar_id)

  Set the ID of the perpendicular spar for an FEA Rib or Rib Array. Note, the FEA Rib or Rib Array should have “SPAR_NORMAL” set for the “PerpendicularEdgeType” Parm. If it is not, the ID will still be set, but the orientation of the Rib or Rib Array will not change.

      #==== Add Wing Geometry ====//
      wing_id = AddGeom( "WING" )

      #==== Add FeaStructure to Wing ====//
      struct_ind = AddFeaStruct( wing_id )

      #==== Add Rib ====//
      rib_id = AddFeaPart( wing_id, struct_ind, FEA_RIB )

      #==== Add Spars ====//
      spar_id_1 = AddFeaPart( wing_id, struct_ind, FEA_SPAR )
      spar_id_2 = AddFeaPart( wing_id, struct_ind, FEA_SPAR )

      SetParmVal( FindParm( spar_id_1, "RelCenterLocation", "FeaPart" ), 0.25 )
      SetParmVal( FindParm( spar_id_2, "RelCenterLocation", "FeaPart" ), 0.75 )

      #==== Set Perpendicular Edge type to SPAR ====//
      SetParmVal( FindParm( rib_id, "PerpendicularEdgeType", "FeaRib" ), SPAR_NORMAL )

      SetFeaPartPerpendicularSparID( rib_id, spar_id_2 )

      if  spar_id_2 != GetFeaPartPerpendicularSparID( rib_id ) :
          print( "Error: SetFeaPartPerpendicularSparID" )

  See also: FEA_RIB_NORMAL, GetFeaPartPerpendicularSparID :param [in]: part_id string FEA Part ID (Rib or Rib Array Type) :param [in]: perpendicular_spar_id string FEA Spar ID

openvsp.vsp.SetFeaPolySparPtName(pspar_id, index, name)

  Set the name of a point in an FEA Poly Spar.

      wing_id = AddGeom( "WING" )

      struct_ind = AddFeaStruct( wing_id )

      pspar_id = AddFeaPart( wing_id, struct_ind, FEA_POLY_SPAR )

      SetFeaPolySparPtName( pspar_id, 0, "InboardPt" )
      SetFeaPolySparPtName( pspar_id, 1, "OutboardPt" )

      if GetFeaPolySparPtName( pspar_id, 0 ) != "InboardPt":
          print( "Error: SetFeaPolySparPtName" )

  See also: GetFeaPolySparPtName :param [in]: pspar_id string FEA Poly Spar part ID :param [in]: index int Index of the point :param [in]: name string New name for the point

openvsp.vsp.SetFeaStructName(geom_id, fea_struct_ind, name)

  Set the name of an FEA Structure

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      #==== Change the Structure Name ====//
      SetFeaStructName( pod_id, struct_ind, "Example_Struct" )

      parm_container_id = FindContainer( "Example_Struct", struct_ind )

      display_id = "New Structure Parm Container ID: " + parm_container_id + "\n"

      print( display_id )

  See also: GetFeaStructName :param [in]: geom_id string Parent Geom ID :param [in]: fea_struct_ind int FEA Structure index :param [in]: name string New name for the FEA Structure

openvsp.vsp.SetFeaSubSurfName(subsurf_id, name)

  Set the name of an FEA SubSurface

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      #==== Add FeaStructure to Pod ====//
      struct_ind = AddFeaStruct( pod_id )

      #==== Add LineArray ====//
      line_array_id = AddFeaSubSurf( pod_id, struct_ind, SS_LINE_ARRAY )

      SetFeaSubSurfName( line_array_id, "Stiffener_array" )

  Parameters:

    - [in] – subsurf_id string FEA SubSurface ID

    - [in] – name string New name for the FEA SubSurface

openvsp.vsp.SetGUIElementDisable(e, state)

  Set whether all instances of GUI device type are disabled

      SetGUIElementDisable( GDEV_INPUT, True )

  Parameters:

    - [in] – e int GDEV enum for GUI device type

    - [in] – state bool True to disable GUI device type

openvsp.vsp.SetGUIScreenDisable(s, state)

  Set whether screen is disabled

      SetGUIScreenDisable( VSP_CFD_MESH_SCREEN, True )

  Parameters:

    - [in] – s int GUI_VSP_SCREEN enum for screen

    - [in] – state bool True to disable screen

openvsp.vsp.SetGeomDisplayType(geom_id, type)

  Set the display type of the specified geometry

      pid = AddGeom( "POD" )                             # Add Pod for testing

      SetGeomDisplayType( pid, DISPLAY_DEGEN_PLATE )                       # Make pod appear as Bezier plate (Degen Geom)

  See also: DISPLAY_TYPE :param [in]: geom_id string Geom ID :param [in]: type int Display type enum (i.e. DISPLAY_BEZIER)

openvsp.vsp.SetGeomDrawType(geom_id, type)

  Set the draw type of the specified geometry

      pid = AddGeom( "POD", "" )                             # Add Pod for testing

      SetGeomDrawType( pid, GEOM_DRAW_SHADE )                       # Make pod appear as shaded

  See also: DRAW_TYPE :param [in]: geom_id string Geom ID :param [in]: type int Draw type enum (i.e. GEOM_DRAW_SHADE)

openvsp.vsp.SetGeomMaterialName(geom_id, name)

  Set the visualization material the specified geometry

      pid = AddGeom( "POD" )

      SetGeomMaterialName( pid, "Ruby" )

  Parameters:

    - [in] – geom_id string Geom ID

    - [in] – name string Material name

openvsp.vsp.SetGeomName(geom_id, name)

  Set the name of the specified Geom

      #==== Add Pod Geometry ====//
      pid = AddGeom( "POD", "" )

      SetGeomName( pid, "ExamplePodName" )

      geom_ids = FindGeomsWithName( "ExamplePodName" )

      if  len(geom_ids) != 1 :
          print( "---> Error: API FindGeomsWithName " )

  Parameters:

    - [in] – geom_id string Geom ID

    - [in] – name string Geom name

openvsp.vsp.SetGeomParent(geom_id, parent_id)

  Get the parent Geom ID for the input child Geom. “NONE” is returned if the Geom has no parent.

      #==== Reparent two PodGeoms ====#
      pod1 = AddGeom( "POD" )
      pod2 = AddGeom( "POD", pod1 )
      pod3 = AddGeom ("POD" )

      veh_id = GetVehicleID()

      SetGeomParent( pod2, veh_id )
      SetGeomParent( pod3, pod1 )

      pod2_parent = GetGeomParent( pod2 )
      pod3_parent = GetGeomParent( pod3 )

      if ( pod2_parent != "NONE" or pod3_parent != pod1 ):
          print( "SetGeomParent error!" )

  Parameters:

    - [in] – geom_id string Geom ID

    - [in] – parent_id string Parent Geom ID

openvsp.vsp.SetGeomScreenDisable(s, state)

  Set whether geom screen is disabled

      SetGeomScreenDisable( ALL_GEOM_SCREENS, True )

  Parameters:

    - [in] – s int GUI_GEOM_SCREEN enum for geom screen

    - [in] – state bool True to disable geom screen

openvsp.vsp.SetGeomWireColor(geom_id, r, g, b)

  Set the wireframe color of the specified geometry

      pid = AddGeom( "POD", "" )

      SetGeomWireColor( pid, 0, 0, 255 )

  Parameters:

    - [in] – geom_id string Geom ID

    - [in] – r int Red component of color [0, 255]

    - [in] – g int Green component of color [0, 255]

    - [in] – b int Blue component of color [0, 255]

openvsp.vsp.SetGroupName(group_id, group_name)

  Set Variable Preset group name

      # Add Pod Geom
      pod1 = AddGeom( "POD", "" )

      gid = AddVarPresetGroup( "Tess" )

      SetGroupName( gid, "Resolution" )

  Parameters:

    - [in] – group_id string Var Preset Group ID

    - [in] – group_name string New Var Preset Group name

openvsp.vsp.SetIntAnalysisInput(analysis, name, indata, index=0)

  Set the value of a particular analysis input of integer type

      #==== Analysis: VSPAero Compute Geometry ====//
      analysis_name = "VSPAEROComputeGeometry"

      # Set to panel method
      thick_set = GetIntAnalysisInput( analysis_name, "GeomSet" )
      thin_set = GetIntAnalysisInput( analysis_name, "ThinGeomSet" )

      thick_set = [vsp.SET_NONE]
      thin_set = [vsp.SET_ALL]

      SetIntAnalysisInput( analysis_name, "GeomSet", thick_set )
      SetIntAnalysisInput( analysis_name, "ThinGeomSet", thin_set )

  See also: GetIntAnalysisInput :param [in]: analysis string Analysis name :param [in]: name string Input name :param [in]: indata vector<int> Array of integer values to set the input to :param [in]: index int Data index

openvsp.vsp.SetIntersectSubSurfGeomID(sub_id, geom_id)

  Set Geom ID to intersect parent with to create intersection SS_INTERSECT type subsurfaces

      pid = AddGeom( "POD", "" )
      p2id = AddGeom( "POD", "" )

      xpod2 = GetParm( p2id, "X_Rel_Location", "XForm" )
      SetParmVal( xpod2, 4.0 )

      zrotpod2 = GetParm( p2id, "Z_Rel_Rotation", "XForm" )
      SetParmVal( zrotpod2, 60.0 )

      sub_id = AddSubSurf( pid, SS_INTERSECT )

      Update()

      SetIntersectSubSurfGeomID( sub_id, p2id )

      IntersectSubSurf( sub_id )

  Parameters:

    - [in] – sub_id string Sub-surface ID

    - [in] – geom_id string Geom ID to intersect with parent to create subsurface

openvsp.vsp.SetLowerCST(xsec_id, deg, coefs)

  Set the CST degree and coefficients for the lower surface of an airfoil. The number of coefficients should be one more than the CST degree. The XSec must be of type XS_CST_AIRFOIL See also: GetLowerCSTDegree, GetLowerCSTCoefs :param [in]: xsec_id string XSec ID :param [in]: deg int CST degree of lower airfoil surface :param [in]: coefs vector<double> Vector of CST coefficients for the lower airfoil surface

openvsp.vsp.SetPCurve(geom_id, pcurveid, tvec, valvec, newtype)

  Set the parameters, values, and curve type of a propeller blade curve (P Curve) See also: PCURV_TYPE :param [in]: geom_id string Parent Geom ID :param [in]: pcurveid int P Curve index :param [in]: tvec vector <double> Array of parameter values :param [in]: valvec vector <double> Array of values :param [in]: newtype int Curve type enum (i.e. CEDIT)

openvsp.vsp.SetParmDescript(parm_id, desc)

  Set the description of the specified Parm

      pod_id = AddGeom( "POD" )

      length = FindParm( pod_id, "Length", "Design" )

      SetParmValLimits( length, 10.0, 0.001, 1.0e12 )

      SetParmDescript( length, "Total Length of Geom" )

  Parameters:

    - [in] – parm_id string Parm ID

    - [in] – desc string Parm description

openvsp.vsp.SetParmLowerLimit(parm_id, val)

  Set the lower limit value for the specified Parm

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE", "" )

      xsec_surf = GetXSecSurf( fuseid, 0 )

      ChangeXSecShape( xsec_surf, GetNumXSec( xsec_surf ) - 1, XS_ROUNDED_RECTANGLE )

      xsec = GetXSec( xsec_surf, GetNumXSec( xsec_surf ) - 1 )

      wid = GetXSecParm( xsec, "RoundedRect_Width" )

      SetParmVal( wid, 13.0 )

      SetParmLowerLimit( wid, 15.0 )

      if  abs( GetParmVal( wid ) - 15 ) > 1e-6 : print( "---> Error: API SetParmLowerLimit " )

  See also: SetParmValLimits :param [in]: parm_id string Parm ID :param [in]: val double Parm lower limit

openvsp.vsp.SetParmUpperLimit(parm_id, val)

  Set the upper limit value for the specified Parm

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE", "" )

      xsec_surf = GetXSecSurf( fuseid, 0 )

      ChangeXSecShape( xsec_surf, GetNumXSec( xsec_surf ) - 1, XS_ROUNDED_RECTANGLE )

      xsec = GetXSec( xsec_surf, GetNumXSec( xsec_surf ) - 1 )

      wid = GetXSecParm( xsec, "RoundedRect_Width" )

      SetParmVal( wid, 23.0 )

      SetParmUpperLimit( wid, 13.0 )

      if  abs( GetParmVal( wid ) - 13 ) > 1e-6 : print( "---> Error: API SetParmUpperLimit " )

  See also: SetParmValLimits :param [in]: parm_id string Parm ID :param [in]: val double Parm upper limit

openvsp.vsp.SetParmVal(*args)

  Overload 1:

  Set the value of the specified Parm.

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE", "" )

      xsec_surf = GetXSecSurf( fuseid, 0 )

      ChangeXSecShape( xsec_surf, GetNumXSec( xsec_surf ) - 1, XS_ROUNDED_RECTANGLE )

      xsec = GetXSec( xsec_surf, GetNumXSec( xsec_surf ) - 1 )

      wid = GetXSecParm( xsec, "RoundedRect_Width" )

      SetParmVal( wid, 23.0 )

      if  abs( GetParmVal( wid ) - 23 ) > 1e-6 : print( "---> Error: API Parm Val Set/Get " )

  See also: SetParmValUpdate :param [in]: parm_id string Parm ID :param [in]: val double Parm value to set :rtype: float :return: double Value that the Parm was set to

  Overload 2:

  Set the value of the specified Parm.

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE", "" )

      xsec_surf = GetXSecSurf( fuseid, 0 )

      ChangeXSecShape( xsec_surf, GetNumXSec( xsec_surf ) - 1, XS_ROUNDED_RECTANGLE )

      xsec = GetXSec( xsec_surf, GetNumXSec( xsec_surf ) - 1 )

      wid = GetXSecParm( xsec, "RoundedRect_Width" )

      SetParmVal( wid, 23.0 )

      if  abs( GetParmVal( wid ) - 23 ) > 1e-6 : print( "---> Error: API Parm Val Set/Get " )

  See also: SetParmValUpdate :param [in]: geom_id string Geom ID :param [in]: name string Parm name :param [in]: group string Parm group name :param [in]: val double Parm value to set :rtype: float :return: double Value that the Parm was set to

openvsp.vsp.SetParmValLimits(parm_id, val, lower_limit, upper_limit)

  Set the value along with the upper and lower limits of the specified Parm

      pod_id = AddGeom( "POD" )

      length = FindParm( pod_id, "Length", "Design" )

      SetParmValLimits( length, 10.0, 0.001, 1.0e12 )

      SetParmDescript( length, "Total Length of Geom" )

  See also: SetParmLowerLimit, SetParmUpperLimit :param [in]: parm_id string Parm ID :param [in]: val double Parm value to set :param [in]: lower_limit double Parm lower limit :param [in]: upper_limit double Parm upper limit :rtype: float :return: double Value that the Parm was set to

openvsp.vsp.SetParmValUpdate(*args)

  Overload 1:

  Set the value of the specified Parm and force an Update.

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      parm_id = GetParm( pod_id, "X_Rel_Location", "XForm" )

      SetParmValUpdate( parm_id, 5.0 )

  See also: SetParmVal :param [in]: parm_id string Parm ID :param [in]: val double Parm value to set :rtype: float :return: double Value that the Parm was set to

  Overload 2:

  Set the value of the specified Parm and force an Update.

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      parm_id = GetParm( pod_id, "X_Rel_Location", "XForm" )

      SetParmValUpdate( parm_id, 5.0 )

  See also: SetParmVal :param [in]: geom_id string Geom ID :param [in]: parm_name string Parm name :param [in]: parm_group_name string Parm group name :param [in]: val double Parm value to set :rtype: float :return: double Value that the Parm was set to

openvsp.vsp.SetRoutingPtParentID(pt_id, parent_id)

  Set the Geom ID of the geom a routing point is anchored to.

      pod1 = vsp.AddGeom('POD', '')

      pod2 = vsp.AddGeom('POD', '')
      ypod2 = vsp.GetParm(pod2, 'Y_Rel_Location', 'XForm')
      vsp.SetParmVal(ypod2, 2.0)

      routing_geom = vsp.AddGeom('ROUTING', '')

      rpt0 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u0 = vsp.GetParm( rpt0, 'U', 'RoutePt')
      vsp.SetParmVal(u0, 0.0)

      rpt1 = vsp.AddRoutingPt(routing_geom, pod2, 0)

      rpt2 = vsp.AddRoutingPt(routing_geom, pod1, 0)
      u2 = vsp.GetParm( rpt2, 'U', 'RoutePt')
      vsp.SetParmVal(u2, 1.0)

      vsp.SetRoutingPtParentID(rpt1, pod1)

  See also: AddRoutingPt, DelAllRoutingPt, GetAllRoutingPtIds :param [in]: pt_id string ParmContainer ID of desired routing point :param [in]: parent_id string Geom ID for the geom to anchor the routing point to

openvsp.vsp.SetSetFlag(geom_id, set_index, flag)

  Set whether or not a Geom is a member of the set at specified set index

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE", "" )

      SetSetFlag( fuseid, 3, True )

      if not GetSetFlag(fuseid, 3):
          print("---> Error: API Set/Get Set Flag")

  Parameters:

    - [in] – geom_id string Geom ID

    - [in] – set_index int Set index

    - [in] – flag bool Flag that indicates set membership

openvsp.vsp.SetSetName(index, name)

  Set the name of a set at specified index

      SetSetName( 3, "SetFromScript" )

      if GetSetName(3) != "SetFromScript":
          print("---> Error: API Get/Set Set Name")

  See also: SET_TYPE :param [in]: index int Set index :param [in]: name string Set name

openvsp.vsp.SetSettingName(setting_id, setting_name)

  Set Variable Preset Setting name

      # Add Pod Geom
      pod1 = AddGeom( "POD", "" )

      gid = AddVarPresetGroup( "Tess" )

      sid = AddVarPresetSetting( gid, "Coarse" )

      SetSettingName( sid, "Low" )

  Parameters:

    - [in] – setting_id string Var Preset Setting ID

    - [in] – setting_name string New Var Preset Setting name

openvsp.vsp.SetShowBorders(brdr)

  Toggle viewing the border frame

      SetShowBorders( False )                                        # Turn off red/black border on active window

  Parameters:

    [in] – brdr bool True to show the border frame, false to hide the border frame

openvsp.vsp.SetStringAnalysisInput(analysis, name, indata, index=0)

  Set the value of a particular analysis input of string type

      fileNameInput = GetStringAnalysisInput( "ParasiteDrag", "FileName" )

      fileNameInput = ["ParasiteDragExample"]

      SetStringAnalysisInput( "ParasiteDrag", "FileName", fileNameInput )

  See also: GetStringAnalysisInput :param [in]: analysis string Analysis name :param [in]: name string Input name :param [in]: indata vector<string> Array of string values to set the input to :param [in]: index int Data index

openvsp.vsp.SetSubSurfName(*args)

  Overload 1:

  Set the name of the specified sub-surface

      wid = AddGeom( "WING", "" )                             # Add Wing

      ss_rec_id = AddSubSurf( wid, SS_RECTANGLE )                        # Add Sub Surface Rectangle

      new_name = "New_SS_Rec_Name"

      SetSubSurfName( wid, ss_rec_id, new_name )

  Parameters:

    - [in] – geom_id string Geom ID

    - [in] – sub_id string Sub-surface ID

    - [in] – name string Sub-surface name

  Overload 2:

  Set the name of the specified sub-surface

      wid = AddGeom( "WING", "" )                             # Add Wing

      ss_rec_id = AddSubSurf( wid, SS_RECTANGLE )                        # Add Sub Surface Rectangle

      new_name = "New_SS_Rec_Name"

      SetSubSurfName( ss_rec_id, new_name )

  Parameters:

    - [in] – sub_id string Sub-surface ID

    - [in] – name string Sub-surface name

openvsp.vsp.SetUpperCST(xsec_id, deg, coefs)

  Set the CST degree and coefficients for the upper surface of an airfoil. The number of coefficients should be one more than the CST degree. The XSec must be of type XS_CST_AIRFOIL See also: GetUpperCSTDegree, GetUpperCSTCoefs :param [in]: xsec_id string XSec ID :param [in]: deg int CST degree of upper airfoil surface :param [in]: coefs vector<double> Vector of CST coefficients for the upper airfoil surface

openvsp.vsp.SetVSP3FileName(file_name)

  Set the file name of a OpenVSP project

      fid = AddGeom( "FUSELAGE", "" )             # Add Fuselage

      fname = "example_fuse.vsp3"

      SetVSP3FileName( fname )

      Update()

      #==== Save Vehicle to File ====//
      print( "\tSaving vehicle file to: ", False )

      print( fname )

      WriteVSPFile( GetVSPFileName(), SET_ALL )

      #==== Reset Geometry ====//
      print( "--->Resetting VSP model to blank slate\n" )

      ClearVSPModel()

      ReadVSPFile( fname )

  Parameters:

    [in] – file_name string File name

openvsp.vsp.SetVSPAEROControlGroupName(name, CSGroupIndex)

  Set the name for the control surface group at the specified index

      wid = AddGeom( "WING", "" ) # Add Wing

      aileron_id = AddSubSurf( wid, SS_CONTROL ) # Add Control Surface Sub-Surface

      group_index = CreateVSPAEROControlSurfaceGroup() # Empty control surface group

      SetVSPAEROControlGroupName( "Example_CS_Group", group_index )

      print( "CS Group name: ", False )

      print( GetVSPAEROControlGroupName( group_index ) )

  Parameters:

    - [in] – name string Name to set for the control surface group

    - [in] – CSGroupIndex int Index of the control surface group

openvsp.vsp.SetVSPAEROPath(path)

  Set the path to the VSPAERO executables (Solver, Viewer, and Slicer). By default, OpenVSP will assume that the VSPAERO executables are in the same directory as the VSP executable. However, this may need to be changed when using certain API languages like MATLAB and Python. For example, Python may treat the location of the Python executable as the VSP executable path, so either the VSPAERO executable needs to be moved to the same directory or this function can be called to tell Python where to look for VSPAERO.

      if  not CheckForVSPAERO( GetVSPExePath() ) :
          vspaero_path = "C:/Users/example_user/Documents/OpenVSP_3.4.5"
          SetVSPAEROPath( vspaero_path )

  See also: GetVSPExePath, CheckForVSPAERO, GetVSPAEROPath :param [in]: path string Absolute path to directory containing VSPAERO executable :rtype: boolean :return: bool Flag that indicates whether or not the path was set correctly

openvsp.vsp.SetVSPAERORefWingID(geom_id)

  Set the current VSPAERO reference Geom ID

      #==== Add Wing Geom and set some parameters =====//
      wing_id = AddGeom( "WING" )

      SetGeomName( wing_id, "MainWing" )

      #==== Add Vertical tail and set some parameters =====//
      vert_id = AddGeom( "WING" )

      SetGeomName( vert_id, "Vert" )

      SetParmValUpdate( vert_id, "TotalArea", "WingGeom", 10.0 )
      SetParmValUpdate( vert_id, "X_Rel_Location", "XForm", 8.5 )
      SetParmValUpdate( vert_id, "X_Rel_Rotation", "XForm", 90 )

      #==== Set VSPAERO Reference lengths & areas ====//
      SetVSPAERORefWingID( wing_id ) # Set as reference wing for VSPAERO

      print( "VSPAERO Reference Wing ID: ", False )

      print( GetVSPAERORefWingID() )

  Parameters:

    [in] – geom_id string Reference Geom ID

openvsp.vsp.SetVSPHelpPath(path)

  Set the path to the OpenVSP help files. By default, OpenVSP will assume that the OpenVSP help directory is in the same directory as the VSP executable. However, this may need to be changed when using certain API languages like MATLAB and Python. For example, Python may treat the location of the Python executable as the VSP executable path, so either the VSPAERO executable needs to be moved to the same directory or this function can be called to tell Python where to look for help.

      if  not CheckForVSPHelp( GetVSPExePath() ) :
          vsphelp_path = "C:/Users/example_user/Documents/OpenVSP_3.4.5/help"
          SetVSPHelpPath( vsphelp_path )

  See also: GetVSPExePath, CheckForVSPHelp, GetVSPHelpPath :param [in]: path string Absolute path to directory containing OpenVSP help files :rtype: boolean :return: bool Flag that indicates whether or not the path was set correctly

openvsp.vsp.SetVarPresetParmVal(group_id, setting_id, parm_id, parm_val)

  Set value for Parm in Var Preset Setting

      # Add Pod Geom
      pod1 = AddGeom( "POD", "" )

      gid = AddVarPresetGroup( "Tess" )

      sid = AddVarPresetSetting( gid, "Coarse" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )

      AddVarPresetParm( gid, p1 )

      SetVarPresetParmVal( gid, sid, p1, 51 )

  Parameters:

    - [in] – group_id string Var Preset Group ID

    - [in] – setting_id string Var Preset Setting ID

    - [in] – parm_id string Var Parm ID

    - [in] – parm_val double Parm value

openvsp.vsp.SetVarPresetParmVals(setting_id, parm_vals)

  Set Parm values for Variable Preset Setting

      # Add Pod Geom
      pod1 = AddGeom( "POD", "" )

      gid = AddVarPresetGroup( "Tess" )

      sid = AddVarPresetSetting( gid, "Coarse" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )

      AddVarPresetParm( gid, p1 )

      vals = [ 45 ]

      SetVarPresetParmVals( sid, vals )

  Parameters:

    - [in] – setting_id string Var Preset Setting ID

    - [in] – parm_vals array<double> Array of Variable Preset Group Parm values

openvsp.vsp.SetVec3dAnalysisInput(analysis, name, indata, index=0)

  Set the value of a particular analysis input of vec3d type

      # PlanarSlice
      norm = GetVec3dAnalysisInput( "PlanarSlice", "Norm" )

      norm[0].set_xyz( 0.23, 0.6, 0.15 )

      SetVec3dAnalysisInput( "PlanarSlice", "Norm", norm )

  See also: GetVec3dAnalysisInput :param [in]: analysis string Analysis name :param [in]: name string Input name :param [in]: indata vector<vec3d> Array of vec3d values to set the input to :param [in]: index int Data index

openvsp.vsp.SetView(viewport, view)

  Set the view of a particular viewports

      SetView( 0, CAM_CENTER )

  Parameters:

    - [in] – viewport int Viewport to set view

    - [in] – view int CAMERA_VIEW enum

openvsp.vsp.SetViewAxis(vaxis)

  Toggle viewing the axis

      SetViewAxis( False )                                           # Turn off axis marker in corner of viewscreen

  Parameters:

    [in] – vaxis bool True to show the axis, false to hide the axis

openvsp.vsp.SetWindowLayout(r, c)

  Set the rows and columns of the window layout

      SetWindowLayout( 2, 2 )

  Parameters:

    - [in] – r int Number of viewport rows

    - [in] – c int Number of viewport columns

openvsp.vsp.SetXSecAlias(id, alias)

  Set XSec Alias by ID

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      # Identify XSec 1
      xsec_1 = GetXSec( xsec_surf, 1 )

      # Set Alias and verify alias match
      alias = "XSec_One_Alias"

      SetXSecAlias( xsec_1, alias )

      get_alias = GetXSecAlias( xsec_1 )

      if alias != get_alias:
          print("SetXSecAlias/GetXSecAlias error!")

  Parameters:

    - [in] – id string XSec ID

    - [in] – alias string Xsec alias

openvsp.vsp.SetXSecContinuity(xsec_id, cx)

  Set C-type continuity enforcement for a particular XSec

      fid = AddGeom( "FUSELAGE", "" )             # Add Fuselage

      xsec_surf = GetXSecSurf( fid, 0 )           # Get First (and Only) XSec Surf

      num_xsecs = GetNumXSec( xsec_surf )

      for i in range(num_xsecs):

          xsec = GetXSec( xsec_surf, i )

          SetXSecContinuity( xsec, 1 )                       # Set Continuity At Cross Section

  Parameters:

    - [in] – xsec_id string XSec ID

    - [in] – cx int Continuity level (0, 1, or 2)

openvsp.vsp.SetXSecCurvatures(xsec_id, side, top, right, bottom, left)

  Set curvatures for the specified XSec

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      # Flatten ends
      num_xsecs = GetNumXSec( xsec_surf )

      for i in range(num_xsecs):

          xsec = GetXSec( xsec_surf, i )

          SetXSecCurvatures( xsec, XSEC_BOTH_SIDES, 0.2, -1.0e12, -1.0e12, -1.0e12 )  # Set Tangent Strengths At Cross Section

  See also: XSEC_SIDES_TYPE :param [in]: xsec_id string XSec ID :param [in]: side int Side type enum (i.e. XSEC_BOTH_SIDES) :param [in]: top double Top curvature :param [in]: right double Right curvature :param [in]: bottom double Bottom curvature :param [in]: left double Left curvature

openvsp.vsp.SetXSecCurveAlias(id, alias)

  Set XSecCurve Alias by XSec ID

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      # Identify XSec 1
      xsec_1 = GetXSec( xsec_surf, 1 )

      # Set Alias and verify alias match
      alias = "XSecCurve_One_Alias"

      SetXSecCurveAlias( xsec_1, alias )

      get_alias = GetXSecCurveAlias( xsec_1 )

      if alias != get_alias:
          print("SetXSecCurveAlias/GetXSecCurveAlias error!")

  Parameters:

    - [in] – id string XSec ID

    - [in] – alias string XsecCurve alias

openvsp.vsp.SetXSecHeight(xsec_id, h)

  Set the height of an XSec. Note that POINT type XSecs have a width and height of 0, regardless of what is input to SetXSecHeight.

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      # Identify XSec 2
      xsec_2 = GetXSec( xsec_surf, 2 )

      SetXSecHeight( xsec_2, 1.5 )

  See also: GetXSecHeight :param [in]: xsec_id string XSec ID :param [in]: h double Xsec height

openvsp.vsp.SetXSecPnts(xsec_id, pnt_vec)

  Set the coordinate points for a specific XSec. The XSec must be of type XS_FILE_FUSE.

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE", "" )

      xsec_surf = GetXSecSurf( fuseid, 0 )

      ChangeXSecShape( xsec_surf, 2, XS_FILE_FUSE )

      xsec = GetXSec( xsec_surf, 2 )

      vec_array = ReadFileXSec(xsec, "TestXSec.fxs")

      if  len(vec_array) > 0 :
          vec_array[1] = vec_array[1] * 2.0
          vec_array[3] = vec_array[3] * 2.0

          SetXSecPnts( xsec, vec_array )

  Parameters:

    - [in] – xsec_id string XSec ID

    - [in] – pnt_vec vector<vec3d> Vector of XSec coordinate points

openvsp.vsp.SetXSecSurfGlobalXForm(xsec_surf_id, mat)

  Set the global surface transform matrix for given XSecSurf :param [in]: xsec_surf_id string XSecSurf ID :param [in]: mat Matrix4d Transformation matrix

openvsp.vsp.SetXSecTanAngles(xsec_id, side, top, right, bottom, left)

  Set the tangent angles for the specified XSec

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      num_xsecs = GetNumXSec( xsec_surf )

      for i in range(num_xsecs):

          xsec = GetXSec( xsec_surf, i )

          SetXSecTanAngles( xsec, XSEC_BOTH_SIDES, 10.0, -1.0e12, -1.0e12, -1.0e12 )       # Set Tangent Angles At Cross Section

  See also: XSEC_SIDES_TYPE :param [in]: xsec_id string XSec ID :param [in]: side int Side type enum (i.e. XSEC_BOTH_SIDES) :param [in]: top double Top angle (degrees) :param [in]: right double Right angle (degrees) :param [in]: bottom double Bottom angle (degrees) :param [in]: left double Left angle (degrees)

openvsp.vsp.SetXSecTanSlews(xsec_id, side, top, right, bottom, left)

  Set the tangent slew angles for the specified XSec

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      num_xsecs = GetNumXSec( xsec_surf )

      for i in range(num_xsecs):

          xsec = GetXSec( xsec_surf, i )

          SetXSecTanSlews( xsec, XSEC_BOTH_SIDES, 5.0, -1.0e12, -1.0e12, -1.0e12 )       # Set Tangent Slews At Cross Section

  See also: XSEC_SIDES_TYPE :param [in]: xsec_id string XSec ID :param [in]: side int Side type enum (i.e. XSEC_BOTH_SIDES) :param [in]: top double Top angle (degrees) :param [in]: right double Right angle (degrees) :param [in]: bottom double Bottom angle (degrees) :param [in]: left double Left angle (degrees)

openvsp.vsp.SetXSecTanStrengths(xsec_id, side, top, right, bottom, left)

  Set the tangent strengths for the specified XSec

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      # Flatten ends
      num_xsecs = GetNumXSec( xsec_surf )

      for i in range(num_xsecs):

          xsec = GetXSec( xsec_surf, i )

          SetXSecTanStrengths( xsec, XSEC_BOTH_SIDES, 0.8, -1.0e12, -1.0e12, -1.0e12 )  # Set Tangent Strengths At Cross Section

  See also: XSEC_SIDES_TYPE :param [in]: xsec_id string XSec ID :param [in]: side int Side type enum (i.e. XSEC_BOTH_SIDES) :param [in]: top double Top strength :param [in]: right double Right strength :param [in]: bottom double Bottom strength :param [in]: left double Left strength

openvsp.vsp.SetXSecWidth(xsec_id, w)

  Set the width of an XSec. Note that POINT type XSecs have a width and height of 0, regardless of what is input to SetXSecWidth.

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      # Identify XSec 2
      xsec_2 = GetXSec( xsec_surf, 2 )

      SetXSecWidth( xsec_2, 1.5 )

  See also: GetXSecWidth :param [in]: xsec_id string XSec ID :param [in]: w double Xsec width

openvsp.vsp.SetXSecWidthHeight(xsec_id, w, h)

  Set the width and height of an XSec. Note, if the XSec is an EDIT_CURVE type and PreserveARFlag is true, the input width value will be ignored and instead set from on the input height and aspect ratio. Use SetXSecWidth and SetXSecHeight directly to avoid this.

      # Add Stack
      sid = AddGeom( "STACK", "" )

      # Get First (and Only) XSec Surf
      xsec_surf = GetXSecSurf( sid, 0 )

      # Identify XSec 2
      xsec_2 = GetXSec( xsec_surf, 2 )

      SetXSecWidthHeight( xsec_2, 1.5, 1.5 )

  See also: SetXSecWidth, SetXSecHeight :param [in]: xsec_id string XSec ID :param [in]: w double Xsec width :param [in]: h double Xsec height

openvsp.vsp.ShowAllBackground3Ds()

  Show all Background3Ds in model

      # Add Background3D
      AddBackground3D()
      AddBackground3D()
      AddBackground3D()

      ShowAllBackground3Ds()

      DelAllBackground3Ds()

openvsp.vsp.ShowOnlyMode(mid)

  Show-only a mode in a model.

      # Illustrating use of Modes requires substantial setup of the model including components, sets, and variable presets.
      #
      # Setup boiler plate.
      pod1 = AddGeom( "POD", "" )
      wing = AddGeom( "WING", pod1 )

      SetParmVal( wing, "Trans_Attach_Flag", "Attach", ATTACH_TRANS_LMN )
      SetParmVal( wing, "L_Attach_Location", "Attach", 0.35 )

      SetSetName( SET_FIRST_USER, "NonLifting" )
      SetSetName( SET_FIRST_USER + 1, "Lifting" )

      SetSetFlag( pod1, SET_FIRST_USER, True )
      SetSetFlag( wing, SET_FIRST_USER + 1, True )

      gid = AddVarPresetGroup( "Tess" )

      p1 = FindParm( pod1, "Tess_U", "Shape" )
      AddVarPresetParm( gid, p1 )

      p2 = FindParm( pod1, "Tess_W", "Shape" )
      AddVarPresetParm( gid, p2 )

      sid = AddVarPresetSetting( gid, "Default" )
      SaveVarPresetParmVals( gid, sid )

      sid1 = AddVarPresetSetting( gid, "Coarse" )
      SetVarPresetParmVal( gid, sid1, p1, 3 )
      SetVarPresetParmVal( gid, sid1, p2, 5 )

      sid2 = AddVarPresetSetting( gid, "Fine" )
      SetVarPresetParmVal( gid, sid, p1, 35 )
      SetVarPresetParmVal( gid, sid, p2, 21 )

      gid2 = AddVarPresetGroup( "Design" )

      p3 = FindParm( pod1, "Length", "Design" )
      AddVarPresetParm( gid2, p3 )

      p4 = FindParm( pod1, "FineRatio", "Design" )
      AddVarPresetParm( gid2, p4 )

      sid3 = AddVarPresetSetting( gid2, "Normal" )
      SaveVarPresetParmVals( gid2, sid3 )

      sid4 = AddVarPresetSetting( gid2, "ShortFat" )
      SetVarPresetParmVal( gid2, sid4, p3, 3.0 )
      SetVarPresetParmVal( gid2, sid4, p4, 5.0 )

      sid5 = AddVarPresetSetting( gid2, "LongThin" )
      SetVarPresetParmVal( gid2, sid5, p3, 20.0 )
      SetVarPresetParmVal( gid2, sid5, p4, 35.0 )

      # End of setup boiler plate.

      mid1 = CreateAndAddMode( "FatWetAreas", SET_ALL, SET_NONE )
      ModeAddGroupSetting( mid1, gid, sid1 )
      ModeAddGroupSetting( mid1, gid2, sid4 )

      mid2 = CreateAndAddMode( "ThinAero", SET_FIRST_USER, SET_FIRST_USER + 1 )
      ModeAddGroupSetting( mid2, gid, sid2 )
      ModeAddGroupSetting( mid1, gid2, sid5 )

      ApplyModeSettings( mid2 )
      Update()

      ShowOnlyMode( mid1 )

  Parameters:

    [in] – mid string Mode ID of mode to show-only

openvsp.vsp.ShowScreen(s)

  Show an OpenVSP GUI screen

      ShowScreen( VSP_CFD_MESH_SCREEN )

  Parameters:

    [in] – s int GUI_VSP_SCREEN enum for screen

openvsp.vsp.SnapParm(*args)

  Snap the specified Parm to input target minimum clearance distance

      #Add Geoms
      fid = AddGeom( "FUSELAGE", "" )             # Add Fuselage

      pid = AddGeom( "POD", "" )                     # Add Pod

      x = GetParm( pid, "X_Rel_Location", "XForm" )

      SetParmVal( x, 3.0 )

      Update()

      min_dist = SnapParm( x, 0.1, True, SET_ALL )

  Parameters:

    - [in] – parm_id string Parm ID

    - [in] – target_min_dist double Target minimum clearance distance

    - [in] – inc_flag bool Direction indication flag. If true, upper parm limit is used and direction is set to positive

    - [in] – set int Collision set enum (i.e. SET_ALL)

    - [in] – useMode bool Flag determine if mode is used instead of sets

    - [in] – modeID string ID of Mode to use

  Return type:

    float

  Returns:

    double Minimum clearance distance

openvsp.vsp.SplitWingXSec(wing_id, section_index)

  Split a given wing section.

      wing_id = AddGeom( "WING", "" )

      #==== Set Wing Section Controls ====//
      SplitWingXSec( wing_id, 1 )

      Update()

  See also: WING_DRIVERS, XSEC_DRIVERS :param [in]: wing_id string Geom ID :param [in]: section_index int Wing section index

openvsp.vsp.StartGUI()

  Launch the interactive OpenVSP GUI. In a multi-threaded environment, this must be called from the main thread only. This starts the GUI event loop. It will also show the main screen and screens displayed when StopGUI() was previously called.

      StartGUI()

openvsp.vsp.StopGUI()

  Stop OpenVSP GUI event loop and hide screens. Keep OpenVSP running and in memory.

      StartGUI()

      StopGUI()

      StartGUI()

  See also: StartGUI

class openvsp.vsp.StringVecVec(*args)

  Bases: `object`

  Proxy of C++ std::vector< std::vector< std::string > > class.

  append(StringVecVec self, StringVector x)
  assign(StringVecVec self, std: :vector< std::vector< std::string > >::size_type n, StringVector x)
  back(StringVecVec self) → StringVector
  begin(StringVecVec self) → std::vector< std::vector< std::string > >::iterator
  capacity(StringVecVec self) → std::vector< std::vector< std::string > >::size_type
  clear(StringVecVec self)
  empty(StringVecVec self) → bool
  end(StringVecVec self) → std::vector< std::vector< std::string > >::iterator
  erase(StringVecVec self, std: :vector< std::vector< std::string > >::iterator pos) → std::vector< std::vector< std::string > >::iterator
  erase(StringVecVec self, std: :vector< std::vector< std::string > >::iterator first, std: :vector< std::vector< std::string > >::iterator last) → std::vector< std::vector< std::string > >::iterator
  front(StringVecVec self) → StringVector
  get_allocator(StringVecVec self) → std::vector< std::vector< std::string > >::allocator_type
  insert(StringVecVec self, std: :vector< std::vector< std::string > >::iterator pos, StringVector x) → std::vector< std::vector< std::string > >::iterator
  insert(StringVecVec self, std: :vector< std::vector< std::string > >::iterator pos, std: :vector< std::vector< std::string > >::size_type n, StringVector x)
  iterator(StringVecVec self) → SwigPyIterator
  pop(StringVecVec self) → StringVector
  pop_back(StringVecVec self)
  push_back(StringVecVec self, StringVector x)
  rbegin(StringVecVec self) → std::vector< std::vector< std::string > >::reverse_iterator
  rend(StringVecVec self) → std::vector< std::vector< std::string > >::reverse_iterator
  reserve(StringVecVec self, std: :vector< std::vector< std::string > >::size_type n)
  resize(StringVecVec self, std: :vector< std::vector< std::string > >::size_type new_size)
  resize(StringVecVec self, std: :vector< std::vector< std::string > >::size_type new_size, StringVector x)
  size(StringVecVec self) → std::vector< std::vector< std::string > >::size_type
  swap(StringVecVec self, StringVecVec v)
  property thisown

    The membership flag

class openvsp.vsp.StringVector(*args)

  Bases: `object`

  Proxy of C++ std::vector< std::string > class.

  append(StringVector self, std: :vector< std::string >::value_type const & x)
  assign(StringVector self, std: :vector< std::string >::size_type n, std: :vector< std::string >::value_type const & x)
  back(StringVector self) → std::vector< std::string >::value_type const &
  begin(StringVector self) → std::vector< std::string >::iterator
  capacity(StringVector self) → std::vector< std::string >::size_type
  clear(StringVector self)
  empty(StringVector self) → bool
  end(StringVector self) → std::vector< std::string >::iterator
  erase(StringVector self, std: :vector< std::string >::iterator pos) → std::vector< std::string >::iterator
  erase(StringVector self, std: :vector< std::string >::iterator first, std: :vector< std::string >::iterator last) → std::vector< std::string >::iterator
  front(StringVector self) → std::vector< std::string >::value_type const &
  get_allocator(StringVector self) → std::vector< std::string >::allocator_type
  insert(StringVector self, std: :vector< std::string >::iterator pos, std: :vector< std::string >::value_type const & x) → std::vector< std::string >::iterator
  insert(StringVector self, std: :vector< std::string >::iterator pos, std: :vector< std::string >::size_type n, std: :vector< std::string >::value_type const & x)
  iterator(StringVector self) → SwigPyIterator
  pop(StringVector self) → std::vector< std::string >::value_type
  pop_back(StringVector self)
  push_back(StringVector self, std: :vector< std::string >::value_type const & x)
  rbegin(StringVector self) → std::vector< std::string >::reverse_iterator
  rend(StringVector self) → std::vector< std::string >::reverse_iterator
  reserve(StringVector self, std: :vector< std::string >::size_type n)
  resize(StringVector self, std: :vector< std::string >::size_type new_size)
  resize(StringVector self, std: :vector< std::string >::size_type new_size, std: :vector< std::string >::value_type const & x)
  size(StringVector self) → std::vector< std::string >::size_type
  swap(StringVector self, StringVector v)
  property thisown

    The membership flag

openvsp.vsp.SummarizeAttributes()

  Print a tab-delimited summary of all Attributes in the vehicle, denoting Name, Type, Data, Description, and path from Root of vehicle to Attribute

      ##==== Attributes: SummarizeAttributes ====##
      SummaryText = SummarizeAttributes()
      print( SummaryText )

  Return type:

    string

  Returns:

    string Tab-delimited summary of all Attributes in vehicle

openvsp.vsp.SummarizeAttributesAsTree()

  Print a plain-text tree summary of all Attribute in the vehicle, each branch node showing the name and ID of the VSP object in the path to the attribute

      ##==== Attributes: SummarizeAttributesAsTree ====##
      SummaryTextTree = SummarizeAttributesAsTree();
      print( SummaryTextTree )

  Return type:

    string

  Returns:

    string Plain-text attribute tree of vehicle

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

  Bases: `object`

  Proxy of C++ swig::SwigPyIterator class.

  advance(SwigPyIterator self, ptrdiff_t n) → SwigPyIterator
  copy(SwigPyIterator self) → SwigPyIterator
  decr(SwigPyIterator self, size_t n=1) → SwigPyIterator
  distance(SwigPyIterator self, SwigPyIterator x) → ptrdiff_t
  equal(SwigPyIterator self, SwigPyIterator x) → bool
  incr(SwigPyIterator self, size_t n=1) → SwigPyIterator
  next(SwigPyIterator self) → PyObject *
  previous(SwigPyIterator self) → PyObject *
  property thisown

    The membership flag

  value(SwigPyIterator self) → PyObject *

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.TIRE_BALLOON = 3

  Balloon tire

openvsp.vsp.TIRE_BALLOON_FAIR_WHEEL = 5

  Balloon tire with faired wheel

openvsp.vsp.TIRE_BALLOON_WHEEL = 4

  Balloon tire with wheel

openvsp.vsp.TIRE_CLEARANCE = 2

  TRA clearance envelope

openvsp.vsp.TIRE_DIM_FRAC = 2

  Tire dimensions as fractions

openvsp.vsp.TIRE_DIM_IN = 0

  Tire dimensions in inches

openvsp.vsp.TIRE_DIM_MODEL = 1

  Tire dimensions in model units

openvsp.vsp.TIRE_FAIR_FLANGE = 1

  TRA with faired flange / flank

openvsp.vsp.TIRE_FAIR_WHEEL = 2

  TRA with faired wheel

openvsp.vsp.TIRE_FLAT_CONTACT = 3

  Tire flat tire radius

openvsp.vsp.TIRE_GROWTH_CLEARANCE = 1

  Tire growth (spinning) clearance

openvsp.vsp.TIRE_GROWTH_CONTACT = 2

  Tire growth (spinning) radius

openvsp.vsp.TIRE_NOMINAL_CLEARANCE = 0

  Tire nominal shape

openvsp.vsp.TIRE_NOMINAL_CONTACT = 1

  Tire nominal radius

openvsp.vsp.TIRE_STATIC_LODED_CONTACT = 0

  Tire static loaded radius

openvsp.vsp.TIRE_TRA = 0

  Full TRA model

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.TRI_MESH_TYPE = 0

  Triangle mesh

openvsp.vsp.T_PROP_DRIVER = 3

  Thrust driver

openvsp.vsp.ToCartesian(vec3d v) → vec3d

openvsp.vsp.ToSpherical(vec3d v) → vec3d

openvsp.vsp.ToSpherical2(vec3d v, vec3d vdet) → vec3d

openvsp.vsp.TransformSet(set_index, translation_vec, x_rot_deg, y_rot_deg, z_rot_deg, scale, scale_translations_flag)

  Apply translation, rotation, and scale transformations to a set

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE" )

      SetSetFlag( fuseid, 3, True )

      # Translate 2 units in X and 3 units in Y, rotate 90 degrees about Y, and scale by a factor of 2
      TransformSet( 3, vec3d( 2, 3, 0 ), 0, 90, 0, 2.0, True )

  See also: TranslateSet, RotateSet, ScaleSet :param [in]: set_index int Set index :param [in]: translation_vec vec3d Translation vector :param [in]: x_rot_deg double Rotation about the X axis (degrees) :param [in]: y_rot_deg double Rotation about the Y axis (degrees) :param [in]: z_rot_deg double Rotation about the Z axis (degrees) :param [in]: scale double Scale factor :param [in]: scale_translations_flag bool Flag to apply the scale factor to translations

openvsp.vsp.TranslateSet(set_index, translation_vec)

  Translate a set along a given vector

      # Add Fuselage Geom
      fuseid = AddGeom( "FUSELAGE" )

      SetSetFlag( fuseid, 3, True )

      # Translate 2 units in X and 3 units in Y
      TranslateSet( 3, vec3d( 2, 3, 0 ) )

  Parameters:

    - [in] – set_index int Set index

    - [in] – translation_vec vec3d Translation vector

openvsp.vsp.ULINE_SOURCE = 3

  Constant U Line source

openvsp.vsp.U_TRIM = 0

  Trim by U coordinate

openvsp.vsp.Unlock()

  Release the lock on the OpenVSP GUI event loop.

      StartGUI()

      pod_id = AddGeom( "POD" )

      Lock()
      rid = ExecAnalysis( "CompGeom" )

      mesh_id_vec = GetStringResults( rid, "Mesh_GeomID" )

      DeleteGeomVec( mesh_id_vec )
      Unlock()

  See also: Lock

openvsp.vsp.Update(update_managers=True)

  Update the entire vehicle and all lower level children. An input, which is true by default, is available to specify if managers should be updated as well. The managers are typically updated by their respective GUI, so must be updated through the API as well to avoid unexpected behavior.

      fid = AddGeom( "FUSELAGE", "" )             # Add Fuselage

      xsec_surf = GetXSecSurf( fid, 0 )           # Get First (and Only) XSec Surf

      num_xsecs = GetNumXSec( xsec_surf )

      #==== Set Tan Angles At Nose/Tail
      SetXSecTanAngles( GetXSec( xsec_surf, 0 ), XSEC_BOTH_SIDES, 90, -1.0e12, -1.0e12, -1.0e12 )
      SetXSecTanAngles( GetXSec( xsec_surf, num_xsecs - 1 ), XSEC_BOTH_SIDES, -90, -1.0e12, -1.0e12, -1.0e12 )

      Update()       # Force Surface Update

  Parameters:

    update_managers (boolean, optional) – bool Flag to indicate if managers should be updated

openvsp.vsp.UpdateGUI()

  Tell OpenVSP that the GUI needs to be updated.

      StartGUI()

      pod_id = AddGeom( "POD" )

      length = FindParm( pod_id, "Length", "Design" )

      SetParmVal( length, 13.0 )

      UpdateGUI()

  See also: StartGUI

openvsp.vsp.UpdateGeom(geom_id)

  Perform an update for the specified Geom

      #==== Add Wing Geometry ====//
      wing_id = AddGeom( "WING" )

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      SetParmVal( pod_id, "X_Rel_Location", "XForm", 5.0 )

      UpdateGeom( pod_id ) # Faster than updating the whole vehicle

  See also: Update() :param [in]: geom_id string Geom ID

openvsp.vsp.UpdateParasiteDrag()

  Update any reference geometry, atmospheric properties, excressences, etc. in the Parasite Drag Tool

openvsp.vsp.VEC3D_DATA = 4

  Vec3d 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.VISIBLE_AT_SURF_ANALYSIS = 13

  Calculate visibility of a surface from a direction

openvsp.vsp.VISIBLE_FROM_POINT_ANALYSIS = 10

  Calculate az,el domain visible from a point

openvsp.vsp.VSPAERO_PROP_NUM_MODES = 3

  Number of ways to model propeller blades in VSPAERO

openvsp.vsp.VSPAERO_PROP_PSEUDO_STEADY = 2

  Model propellers with pseudo steady model

openvsp.vsp.VSPAERO_PROP_STATIC = 0

  Model propellers as static, non-rotating blades – i.e. used as a wing.

openvsp.vsp.VSPAERO_PROP_UNSTEADY = 1

  Model propellers as unsteady rotating blades

openvsp.vsp.VSPCheckSetup()

  Check if OpenVSP has been initialized successfully. If not, the OpenVSP instance will be exited. This call should be placed at the beginning of all API scripts.

      VSPCheckSetup()

      # Continue to do things...

openvsp.vsp.VSPCrash(crash_type)

  Cause OpenVSP to crash in a variety of ways. :param [in]: crash_type int Type of crash to attempt.

openvsp.vsp.VSPExit(error_code)

  Exit the program with a specific error code :param [in]: error_code int Error code

openvsp.vsp.VSPRenew()

  Clear and reinitialize OpenVSP to all default settings

      #==== Add Pod Geometry ====//
      pod_id = AddGeom( "POD" )

      SetParmVal( pod_id, "Y_Rel_Location", "XForm", 2.0 )

      VSPRenew()

      if  len(FindGeoms()) != 0 : print( "ERROR: 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 = 66

  Flag for all screens

openvsp.vsp.VSP_AMBIGUOUS_SUBSURF = 17

  Ambiguous flow-through sub-surface error

openvsp.vsp.VSP_ATTRIBUTE_EXPLORER_SCREEN = 5

  Attribute details screen

openvsp.vsp.VSP_BACKGROUND3D_PREVIEW_SCREEN = 8

  Background3D preview screen

openvsp.vsp.VSP_BACKGROUND3D_SCREEN = 7

  Background3D control screen

openvsp.vsp.VSP_BACKGROUND_SCREEN = 6

  Background control screen

openvsp.vsp.VSP_BEM_OPTIONS_SCREEN = 9

  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 = 10

  CFD Mesh screen

openvsp.vsp.VSP_CLIPPING_SCREEN = 11

  Clipping screen

openvsp.vsp.VSP_COMP_GEOM_SCREEN = 12

  CompGeom screen

openvsp.vsp.VSP_CONFORMAL_PARENT_UNSUPPORTED = 20

  Unsupported Conformal Geom parent error

openvsp.vsp.VSP_COR_SCREEN = 13

  Center of rotation screen

openvsp.vsp.VSP_COULD_NOT_CREATE_BACKGROUND3D = 31

  Could not create and add Background3D

openvsp.vsp.VSP_CURVE_EDIT_SCREEN = 14

  Curve edit screen

openvsp.vsp.VSP_DEGEN_GEOM_SCREEN = 15

  Degen geom screen

openvsp.vsp.VSP_DEPRECATED = 26

  This capability has been deprecated and is not longer supported

openvsp.vsp.VSP_DESIGN_VAR_SCREEN = 16

  Design variables screen

openvsp.vsp.VSP_DUPLICATE_NAME = 29

  A duplicate name has been provided

openvsp.vsp.VSP_DXF_OPTIONS_SCREEN = 17

  DXF options screen

openvsp.vsp.VSP_EXPORT_CUSTOM_SCRIPT = 24

  Custom geom export screen

openvsp.vsp.VSP_EXPORT_SCREEN = 18

  Export screen

openvsp.vsp.VSP_FEA_PART_EDIT_SCREEN = 19

  FEA Part edit screen

openvsp.vsp.VSP_FEA_XSEC_SCREEN = 20

  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 = 21

  Fit model screen

openvsp.vsp.VSP_GEOMETRY_ANALYSIS_SCREEN = 25

  Geometry analysis screen

openvsp.vsp.VSP_GUI_DEVICE_DEACTIVATED = 30

  A deactivated GUI device was touched

openvsp.vsp.VSP_IGES_OPTIONS_SCREEN = 22

  IGES options screen

openvsp.vsp.VSP_IGES_STRUCTURE_OPTIONS_SCREEN = 23

  IGES structure options screen

openvsp.vsp.VSP_IMPORT_SCREEN = 26

  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 = 27

  Lighting screen

openvsp.vsp.VSP_LINK_LOOP_DETECTED = 27

  A parameter link loop was detected and stopped

openvsp.vsp.VSP_LINK_OUTPUT_NOT_ASSIGNED = 28

  An output of a parameter link was not set

openvsp.vsp.VSP_MAIN_SCREEN = 64

  Main screen

openvsp.vsp.VSP_MANAGE_GEOM_SCREEN = 28

  Manage geom screen

openvsp.vsp.VSP_MANAGE_TEXTURE_SCREEN = 29

  Texture mapping screen

openvsp.vsp.VSP_MASS_PROP_SCREEN = 30

  Mass properties screen

openvsp.vsp.VSP_MATERIAL_EDIT_SCREEN = 31

  Material edit screen

openvsp.vsp.VSP_MEASURE_SCREEN = 32

  Measure screen

openvsp.vsp.VSP_MODE_EDITOR_SCREEN = 33

  Mode editor screen

openvsp.vsp.VSP_NERF_MANAGE_GEOM_SCREEN = 34

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

openvsp.vsp.VSP_NUM_ERROR_CODE = 32

  Total number of VSP error codes

openvsp.vsp.VSP_NUM_SCREENS = 65

  Number of screens

openvsp.vsp.VSP_OK = 0

  No error

openvsp.vsp.VSP_PARASITE_DRAG_SCREEN = 36

  Parasite drg screen

openvsp.vsp.VSP_PARM_DEBUG_SCREEN = 37

  Parameter debug screen

openvsp.vsp.VSP_PARM_LINK_SCREEN = 38

  Parameter linking screen

openvsp.vsp.VSP_PARM_SCREEN = 39

  Parameter screen

openvsp.vsp.VSP_PICK_SET_SCREEN = 40

  Pick set screen

openvsp.vsp.VSP_PREFERENCES_SCREEN = 41

  Preferences screen

openvsp.vsp.VSP_PROJECTION_SCREEN = 42

  Projected area screen

openvsp.vsp.VSP_PSLICE_SCREEN = 43

  Planar slicing screen

openvsp.vsp.VSP_RESULTS_VIEWER_SCREEN = 44

  Results viewing screen

openvsp.vsp.VSP_SCREENSHOT_SCREEN = 45

  Screenshot screen

openvsp.vsp.VSP_SELECT_FILE_SCREEN = 46

  Select file screen

openvsp.vsp.VSP_SET_EDITOR_SCREEN = 47

  Set editor screen

openvsp.vsp.VSP_SNAP_TO_SCREEN = 35

  Snap to screen

openvsp.vsp.VSP_STEP_OPTIONS_SCREEN = 48

  STEP options screen

openvsp.vsp.VSP_STEP_STRUCTURE_OPTIONS_SCREEN = 49

  STEP structure options screen

openvsp.vsp.VSP_STL_OPTIONS_SCREEN = 50

  STL options screen

openvsp.vsp.VSP_STRUCT_ASSEMBLY_SCREEN = 52

  Structure assembly screen

openvsp.vsp.VSP_STRUCT_SCREEN = 51

  Structure definition screen

openvsp.vsp.VSP_SURFACE_INTERSECTION_SCREEN = 53

  Surface intersection screen

openvsp.vsp.VSP_SVG_OPTIONS_SCREEN = 54

  SVG options screen

openvsp.vsp.VSP_UNEXPECTED_RESET_REMAP_ID = 21

  Unexpected reset remap ID error

openvsp.vsp.VSP_UNKNOWN = -1

  Unknown error

openvsp.vsp.VSP_USER_PARM_SCREEN = 55

  User parameter screen

openvsp.vsp.VSP_VAR_PRESET_SCREEN = 56

  Variable presets editor screen

openvsp.vsp.VSP_VEH_NOTES_SCREEN = 57

  Vehicle notes screen

openvsp.vsp.VSP_VEH_SCREEN = 58

  Veh geom screen

openvsp.vsp.VSP_VIEW_SCREEN = 59

  Adjust viewpoint screen

openvsp.vsp.VSP_VSPAERO_PLOT_SCREEN = 60

  VSPAERO results manager screen

openvsp.vsp.VSP_VSPAERO_SCREEN = 61

  VSPAERO screen

openvsp.vsp.VSP_WAVEDRAG_SCREEN = 63

  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 = 62

  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(id)

  Check if given Parm is valid

      #==== Add Pod Geometry ====//
      pid = AddGeom( "POD" )

      lenid = GetParm( pid, "Length", "Design" )

      if  not ValidParm( lenid ) : print( "---> Error: API GetParm  " )

  Parameters:

    [in] – id string Parm ID

  Return type:

    boolean

  Returns:

    bool True if Parm ID is valid, false otherwise

openvsp.vsp.ValidateAdvLinkParms(index)

  Validate the input and output parameters for an advanced link

      pod = AddGeom( "POD", "" )
      length = FindParm( pod, "Length", "Design" )
      x_pos = GetParm( pod, "X_Rel_Location", "XForm" )

      AddAdvLink( "ExampleLink" )
      indx = GetLinkIndex( "ExampleLink" )
      AddAdvLinkInput( indx, length, "len" )
      AddAdvLinkOutput( indx, x_pos, "x" )

      SetAdvLinkCode( indx, "x = 10.0 - len;" )

      BuildAdvLinkScript( indx )

      valid = ValidateAdvLinkParms( indx )

      if  valid :
          print( "Advanced link Parms are valid." )
      else:
          print( "Advanced link Parms are not valid." )

  Parameters:

    [in] – index int Index for advanced link

  Return type:

    boolean

  Returns:

    bool Flag indicating whether parms are valid

class openvsp.vsp.Vec3dVec(*args)

  Bases: `object`

  Proxy of C++ std::vector< vec3d > class.

  append(Vec3dVec self, vec3d x)
  as_numpy()
  assign(Vec3dVec self, std: :vector< vec3d >::size_type n, vec3d x)
  back(Vec3dVec self) → vec3d
  begin(Vec3dVec self) → std::vector< vec3d >::iterator
  capacity(Vec3dVec self) → std::vector< vec3d >::size_type
  clear(Vec3dVec self)
  empty(Vec3dVec self) → bool
  end(Vec3dVec self) → std::vector< vec3d >::iterator
  erase(Vec3dVec self, std: :vector< vec3d >::iterator pos) → std::vector< vec3d >::iterator
  erase(Vec3dVec self, std: :vector< vec3d >::iterator first, std: :vector< vec3d >::iterator last) → std::vector< vec3d >::iterator
  front(Vec3dVec self) → vec3d
  get_allocator(Vec3dVec self) → std::vector< vec3d >::allocator_type
  insert(Vec3dVec self, std: :vector< vec3d >::iterator pos, vec3d x) → std::vector< vec3d >::iterator
  insert(Vec3dVec self, std: :vector< vec3d >::iterator pos, std: :vector< vec3d >::size_type n, vec3d x)
  iterator(Vec3dVec self) → SwigPyIterator
  pop(Vec3dVec self) → vec3d
  pop_back(Vec3dVec self)
  push_back(Vec3dVec self, vec3d x)
  rbegin(Vec3dVec self) → std::vector< vec3d >::reverse_iterator
  rend(Vec3dVec self) → std::vector< vec3d >::reverse_iterator
  reserve(Vec3dVec self, std: :vector< vec3d >::size_type n)
  resize(Vec3dVec self, std: :vector< vec3d >::size_type new_size)
  resize(Vec3dVec self, std: :vector< vec3d >::size_type new_size, vec3d x)
  size(Vec3dVec self) → std::vector< vec3d >::size_type
  swap(Vec3dVec self, Vec3dVec v)
  property thisown

    The membership flag

openvsp.vsp.VecInsideSurf(geom_id, surf_indx, pts)

  Test whether a vector of points are inside a specified surface.

      # Add Pod Geom
      geom_id = AddGeom( "POD", "" )

      surf_indx = 0

      n = 5

      rvec = [0]*n
      svec = [0]*n
      tvec = [0]*n

      for i in range(n):

          rvec[i] = (i+1)*1.0/(n+1)

          svec[i] = (n-i)*1.0/(n+1)

          tvec[i] = (i+1)*1.0/(n+1)

      ptvec = CompVecPntRST( geom_id, 0, rvec, svec, tvec )

      res = VecInsideSurf( geom_id, surf_indx, ptvec )

  See also: VecInsideSurf :param [in]: geom_id string Parent Geom ID :param [in]: surf_indx int Main surface index from the parent Geom :param [in]: pts vector<vec3d> Input vector of 3D coordinate points :rtype: std::vector< bool,std::allocator< bool > > :return: vector <bool> Boolean vector for each point. True if it is inside the surface, false otherwise.

openvsp.vsp.WHEEL_TIRE_1LG = 0

  Large tire debris

openvsp.vsp.WHEEL_TIRE_1SM = 1

  Small tire debris

openvsp.vsp.WHEEL_TIRE_2 = 2

  Wheel flange debris

openvsp.vsp.WHEEL_TIRE_3E = 3

  Flailing tire strip extended

openvsp.vsp.WHEEL_TIRE_3R = 4

  Flailing tire strip retracted

openvsp.vsp.WHEEL_TIRE_4 = 5

  Tire burst pressure (Not implemented)

openvsp.vsp.WIDTH_XSEC_DRIVER = 0

  Width driver

openvsp.vsp.WING_SURF = 1

  Wing VSP surface

openvsp.vsp.WIRE_FRAME_GEOM_SCREEN = 15

  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(file_name, atmos_type)

  Calculate the atmospheric properties determined by a specified model for a preset array of altitudes ranging from 0 to 90000 m and write the results to a CSV output file

      print( "Starting USAF Atmosphere 1966 Table Creation. \n" )

      WriteAtmosphereCSVFile( "USAFAtmosphere1966Data.csv", ATMOS_TYPE_HERRINGTON_1966 )

  See also: ATMOS_TYPE :param [in]: file_name string Output CSV file :param [in]: atmos_type int Atmospheric model enum (i.e. ATMOS_TYPE_HERRINGTON_1966)

openvsp.vsp.WriteBezierAirfoil(file_name, geom_id, foilsurf_u)

  Write out the untwisted unit-length 2D Bezier curve for the specified airfoil in custom*.bz format. The output will describe the analytical shape of the airfoil. See BezierAirfoilExample.m and BezierCtrlToCoordPnts.m for examples of discretizing the Bezier curve and generating a Selig airfoil file.

      #==== Add Wing Geometry and Set Parms ====//
      wing_id = AddGeom( "WING", "" )

      u = 0.5 # export airfoil at mid span location

      #==== Write Bezier Airfoil File ====//
      WriteBezierAirfoil( "Example_Bezier.bz", wing_id, u )

  Parameters:

    - [in] – file_name string Airfoil (*.bz) output file name

    - [in] – geom_id string Geom ID

    - [in] – foilsurf_u double U location (range: 0 - 1) along the surface. The foil surface does not include root and tip caps (i.e. 2 section wing -> XSec0 @ u=0, XSec1 @ u=0.5, XSec2 @ u=1.0)

openvsp.vsp.WriteBodyFFCSVFile(file_name)

  Calculate the form factor from each body FF equation (i.e. Hoerner Streamlined Body) and write the results to a CSV output file

      print( "Starting Body Form Factor Data Creation. \n" )
      WriteBodyFFCSVFile( "BodyFormFactorData.csv" )

  Parameters:

    [in] – file_name string Output CSV file

openvsp.vsp.WriteCfEqnCSVFile(file_name)

  Calculate the coefficient of friction from each Cf equation (i.e. Power Law Blasius) and write the results to a CSV output file

      print( "Starting Turbulent Friciton Coefficient Data Creation. \n" )
      WriteCfEqnCSVFile( "FrictionCoefficientData.csv" )

  Parameters:

    [in] – file_name string Output CSV file

openvsp.vsp.WriteDESFile(file_name)

  Write all design variables to a design file (*.des) :param [in]: file_name string *.des output file

openvsp.vsp.WritePartialCfMethodCSVFile(file_name)

  Calculate the partial coefficient of friction and write the results to a CSV output file

      print( "Starting Partial Friction Method Data Creation. \n" )
      WritePartialCfMethodCSVFile( "PartialFrictionMethodData.csv" )

  Parameters:

    [in] – file_name string Output CSV file

openvsp.vsp.WriteResultsCSVFile(id, file_name)

  Export a result to CSV

      # Add Pod Geom
      pid = AddGeom( "POD" )

      analysis_name = "VSPAEROComputeGeometry"

      rid = ExecAnalysis( analysis_name )

      WriteResultsCSVFile( rid, "CompGeomRes.csv" )

  Parameters:

    - [in] – id string Rsult ID

    - [in] – file_name string CSV output file name

openvsp.vsp.WriteSeligAirfoil(file_name, geom_id, foilsurf_u)

  Write out the untwisted unit-length 2D coordinate points for the specified airfoil in Selig format. Coordinate points follow the on-screen wire frame W tessellation.

      #==== Add Wing Geometry and Set Parms ====//
      wing_id = AddGeom( "WING", "" )

      u = 0.5 # export airfoil at mid span location

      #==== Write Selig Airfoil File ====//
      WriteSeligAirfoil( "Example_Selig.dat", wing_id, u )

  See also: GetAirfoilCoordinates :param [in]: file_name string Airfoil (*.dat) output file name :param [in]: geom_id string Geom ID :param [in]: foilsurf_u double U location (range: 0 - 1) along the surface. The foil surface does not include root and tip caps (i.e. 2 section wing -> XSec0 @ u=0, XSec1 @ u=0.5, XSec2 @ u=1.0)

openvsp.vsp.WriteTestResults()

  Generate some example results for testing.

      #==== Write Some Fake Test Results =====//
      WriteTestResults()

      results_array = GetAllResultsNames()

      for i in range( len( results_array ) ):
          resid = FindLatestResultsID( results_array[i] )
          PrintResults( resid )

openvsp.vsp.WriteVSPFile(*args)

  Save the current OpenVSP project to a VSP3 file

      fid = AddGeom( "FUSELAGE", "" )             # Add Fuselage

      fname = "example_fuse.vsp3"

      SetVSP3FileName( fname )

      Update()

      #==== Save Vehicle to File ====//
      print( "\tSaving vehicle file to: ", False )

      print( fname )

      WriteVSPFile( GetVSPFileName(), SET_ALL )

      #==== Reset Geometry ====//
      print( "--->Resetting VSP model to blank slate\n" )

      ClearVSPModel()

      ReadVSPFile( fname )

  Parameters:

    - [in] – file_name string *.vsp3 file name

    - [in] – set int Set index to write (i.e. SET_ALL)

openvsp.vsp.WriteWingFFCSVFile(file_name)

  Calculate the form factor from each wing FF equation (i.e. Schemensky 4 Series Airfoil) and write the results to a CSV output file

      print( "Starting Wing Form Factor Data Creation. \n" )
      WriteWingFFCSVFile( "WingFormFactorData.csv" )

  Parameters:

    [in] – file_name string Output CSV file

openvsp.vsp.WriteXDDMFile(file_name)

  Write all design variables to a Cart3D XDDM file (*.xddm) :param [in]: file_name string *.xddm output file

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_AC25_773 = 19

  FAA AC 25.773 pilot view requirement

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 = 20

  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.XYZ_TARGET = 4

  XYZ point target type

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.Z_TARGET = 3

  Z plane target type

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

openvsp.vsp.angle_pnt_2_plane(vec3d ptplane, vec3d norm, vec3d ptaxis, vec3d axis, vec3d pt, int ccw, vec3d prot) → double
openvsp.vsp.angle_pnt_2_plane(vec3d ptplane, vec3d norm, vec3d ptaxis, vec3d axis, vec3d pt, int ccw, vec3d prot1, vec3d prot2, double & theta1, double & theta2)

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

openvsp.vsp.bi_lin_interp(vec2d p0, vec2d p1, vec2d p2, vec2d p3, double s, double t, vec2d p)

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

openvsp.vsp.clip_seg_rect(double x_min, double y_min, double x_max, double y_max, vec2d pnt1, vec2d pnt2, int & visible)

openvsp.vsp.compsum(Vec3dVec x) → vec3d

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

openvsp.vsp.cross(vec3d a, vec3d b) → vec3d
openvsp.vsp.cross(vec2d a, vec2d b) → double

openvsp.vsp.det(vec2d p0, vec2d p1, vec2d offset) → double

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

openvsp.vsp.dist3D_Segment_to_Segment(vec3d S1P0, vec3d S1P1, vec3d S2P0, vec3d S2P1) → double
openvsp.vsp.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_pnt_2_ray(vec3d line_pt1, vec3d dir_unit_vec, vec3d pnt) → double

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

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

openvsp.vsp.encode(double x_min, double y_min, double x_max, double y_max, vec2d pnt, int [4] code)

openvsp.vsp.inverse_bi_lin_interp(vec2d p0, vec2d p1, vec2d p2, vec2d p3, vec2d p, double & s, double & t, double & s2, double & t2) → int

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.orient2d(vec2d p0, vec2d p1, vec2d p) → double

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

openvsp.vsp.plane_plane_intersection(vec3d p0, vec3d n0, vec3d p1, vec3d n1, vec3d p, vec3d v) → bool

openvsp.vsp.plane_ray_intersect(vec3d A, vec3d B, vec3d C, vec3d D, vec3d E, double & t) → int
openvsp.vsp.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, vec3d pnearest) → double

openvsp.vsp.pointLineDistSquared(vec3d p, vec3d lp0, vec3d lp1, double & t, vec3d pon) → double

openvsp.vsp.pointSegDistSquared(vec3d p, vec3d sp0, vec3d sp1, double & t, vec3d pon) → double

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

openvsp.vsp.poly_area(Vec3dVec pnt_vec) → double
openvsp.vsp.poly_area(std: :vector< vec2d, std: :allocator< vec2d > > const & pnt_vec) → double

openvsp.vsp.poly_centroid(std: :vector< vec2d, std: :allocator< vec2d > > const & pnt_vec) → vec2d

openvsp.vsp.printpt(vec3d v)

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_line_seg(vec2d line_A, vec2d line_B, vec2d pnt) → vec2d

openvsp.vsp.proj_pnt_on_line_u(vec2d line_A, vec2d line_B, vec2d pnt) → double

openvsp.vsp.proj_pnt_on_ray(vec3d line_pt1, vec3d line_dir, vec3d pnt) → vec3d
openvsp.vsp.proj_pnt_on_ray(vec3d line_pt1, vec3d line_dir, vec3d pnt, double & t) → vec3d

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

openvsp.vsp.proj_u_on_v(vec3d u, vec3d v) → 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.raySphereIntersectionFromInside(vec3d p, vec3d v, vec3d c, double r, vec3d x) → bool

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

openvsp.vsp.seg_seg_intersect(vec2d pnt_A, vec2d pnt_B, vec2d pnt_C, vec2d pnt_D, vec2d int_pnt, double & t1, double & t2) → int

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

openvsp.vsp.signed_dist_pnt_2_plane(vec3d org, vec3d norm, vec3d pnt) → 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, vec3d p1, vec3d p2) → double

openvsp.vsp.triangle_plane_intersect_test(vec3d org, vec3d norm, vec3d p1, vec3d p2, vec3d p3) → bool

openvsp.vsp.triangle_plane_maximum_dist(vec3d org, vec3d norm, vec3d p1, vec3d p2, vec3d p3, vec3d pa, vec3d pb) → double

openvsp.vsp.triangle_plane_minimum_dist(vec3d org, vec3d norm, vec3d p1, vec3d p2, vec3d p3, vec3d pa, vec3d pb) → double

class openvsp.vsp.vec2d(*args)

  Bases: `object`

  Proxy of C++ vec2d class.

  data(vec2d self) → double *
  mag(vec2d self) → double
  normalize(vec2d self)
  set_x(vec2d self, double xx) → vec2d
  set_xy(vec2d self, double xx, double yy) → vec2d
  set_y(vec2d self, double yy) → vec2d
  property thisown

    The membership flag

  transform(vec2d self, float [3][3] mat) → vec2d
  transform(vec2d self, double [3][3] mat) → vec2d
  property v

    v : a(2).double

  x(vec2d self) → double
  y(vec2d self) → double

class openvsp.vsp.vec3d(*args)

  Bases: `object`

  vec3d is typically used to describe coordinate points and vectors in 3D space. All 3 elements in the vector are of type double.

  FlipNormal(vec3d self)
  Transform(vec3d self, Matrix4d m)
  as_numpy()
  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()

    Get the magnitude of a vec3d

        import math
        #==== Test Vec3d ====//
        vec3d a()                                # Default Constructor

        #==== Test Mag ====//
        a.set_xyz( 1.0, 2.0, 3.0 )

        if  abs( a.mag() - math.sqrt( 14 ) ) > 1e-6 : Print( "---> Error: Vec3d Mag " ); }

    Return type:

      float

    Returns:

      Magnitude

  magsq(vec3d self) → double
  major_comp(vec3d self) → int
  minor_comp(vec3d self) → int
  normalize()

    Normalize the vec3d

            #==== Test Vec3d ====//
        vec3d a(), b(), c()                                # Default Constructor

        #==== Test Cross ====//
        a.set_xyz( 4.0, 0.0, 0.0 )
        b.set_xyz( 0.0, 3.0, 0.0 )

        c = cross( a, b )

        c.normalize()

  offset_i(vec3d self, double offset, int idir)
  offset_x(offset)

    Offset the X coordinate of the vec3d

            #==== Test Vec3d ====//
        vec3d a()                                # Default Constructor

        #===== Test Offset ====//
        a.set_xyz( 2.0, 2.0, 2.0 )

        a.offset_x( 10.0 )

    Parameters:

      [in] – offset Offset for the X value

  offset_y(offset)

    Offset the Y coordinate of the vec3d

            #==== Test Vec3d ====//
        vec3d a()                                # Default Constructor

        #===== Test Offset ====//
        a.set_xyz( 2.0, 2.0, 2.0 )

        a.offset_y( 10.0 )

    Parameters:

      [in] – offset Offset for the Y value

  offset_z(offset)

    Offset the Z coordinate of the vec3d

            #==== Test Vec3d ====//
        vec3d a()                                # Default Constructor

        #===== Test Offset ====//
        a.set_xyz( 2.0, 2.0, 2.0 )

        a.offset_z( 10.0 )

    Parameters:

      [in] – offset Offset for the Z value

  reflect_xy()

    Reflect the vec3d across the XY plane

            #==== Test Vec3d ====//
        vec3d a(), b()                                # Default Constructor

        #===== Test Reflect ====//
        a.set_xyz( 1.0, 2.0, 3.0 )

        b = a.reflect_xy()

    Return type:

      `vec3d`

    Returns:

      Reflected vec3d

  reflect_xz()

    Reflect the vec3d across the XZ plane

            #==== Test Vec3d ====//
        vec3d a(), b()                                # Default Constructor

        #===== Test Reflect ====//
        a.set_xyz( 1.0, 2.0, 3.0 )

        b = a.reflect_xz()

    Return type:

      `vec3d`

    Returns:

      Reflected vec3d

  reflect_yz()

    Reflect the vec3d across the YZ plane

            #==== Test Vec3d ====//
        vec3d a(), b()                                # Default Constructor

        #===== Test Reflect ====//
        a.set_xyz( 1.0, 2.0, 3.0 )

        b = a.reflect_yz()

    Return type:

      `vec3d`

    Returns:

      Reflected vec3d

  rotate_x(theta)

    Rotate the vec3d about the X axis.

        import math
        #==== Test Vec3d ====//
        vec3d a()                                # Default Constructor
        PI = 3.14

        a.set_xyz( 1.0, 0.0, 0.0 )

        a.rotate_x( 0.5 * PI )

    Parameters:

      [in] – theta double Rotation angle in radians

  rotate_y(theta)

    Rotate the vec3d about the Y axis.

        import math
        #==== Test Vec3d ====//
        vec3d a()                                # Default Constructor
        PI = 3.14

        a.set_xyz( 1.0, 0.0, 0.0 )

        a.rotate_y( 0.5 * PI )

    Parameters:

      [in] – theta double Rotation angle in radians

  rotate_z(theta)

    Rotate the vec3d about the Z axis.

        import math
        #==== Test Vec3d ====//
        vec3d a()                                # Default Constructor
        PI = 3.14

        a.set_xyz( 1.0, 0.0, 0.0 )

        a.rotate_z( 0.5 * PI )

    Parameters:

      [in] – theta double Rotation angle in radians

  scale_x(scale)

    Scale the X coordinate of the vec3d

            #==== Test Vec3d ====//
        vec3d a()                                # Default Constructor

        #===== Test Scale ====//
        a.set_xyz( 2.0, 2.0, 2.0 )

        a.scale_x( 2.0 )

    Parameters:

      [in] – scale Scaling factor for the X value

  scale_y(scale)

    Scale the Y coordinate of the vec3d

            #==== Test Vec3d ====//
        vec3d a()                                # Default Constructor

        #===== Test Scale ====//
        a.set_xyz( 2.0, 2.0, 2.0 )

        a.scale_y( 2.0 )

    Parameters:

      [in] – scale Scaling factor for the Y value

  scale_z(scale)

    Scale the Z coordinate of the vec3d

            #==== Test Vec3d ====//
        vec3d a()                                # Default Constructor

        #===== Test Scale ====//
        a.set_xyz( 2.0, 2.0, 2.0 )

        a.scale_z( 2.0 )

    Parameters:

      [in] – scale Scaling factor for the Z value

  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(xx)

    Set the X coordinate (index 0) of the vec3d

            #==== Test Vec3d ====//
        vec3d a()                                # Default Constructor

        a.set_x( 2.0 )

    Parameters:

      [in] – xx New X value

    Return type:

      `vec3d`

    Returns:

      Updated vec3d

  set_xyz(xx, yy, zz)

    Set all three elements of the vec3d vector

            #==== Test Vec3d ====//
        vec3d a()                                # Default Constructor

        a.set_xyz( 2.0, 4.0, 6.0 )

    Parameters:

      - [in] – xx New X value

      - [in] – yy New Y value

      - [in] – zz New Z value

    Return type:

      `vec3d`

    Returns:

      Updated vec3d

  set_y(yy)

    Set the Y coordinate (index 1) of the vec3d

            #==== Test Vec3d ====//
        vec3d a()                                # Default Constructor

        a.set_y( 4.0 )

    Parameters:

      [in] – yy New Y value

    Return type:

      `vec3d`

    Returns:

      Updated vec3d

  set_z(zz)

    Set the z coordinate (index 2) of the vec3d

            #==== Test Vec3d ====//
        vec3d a()                                # Default Constructor

        a.set_z( 6.0 )

    Parameters:

      [in] – zz in double new z value

    Return type:

      `vec3d`

    Returns:

      vec3d result

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

    Get the X coordinate (index 0) of the vec3d

            vec3d a()                                # Default Constructor

        a.set_xyz( 2.0, 4.0, 6.0 )

        Print( "a.x() = ", False )
        Print( a.x() )

        Print( "a[0]= ", False )
        Print( a[0] )

    Return type:

      float

    Returns:

      X value

  y()

    Get the Y coordinate (index 1) of the vec3d

            vec3d a()                                # Default Constructor

        a.set_xyz( 2.0, 4.0, 6.0 )

        Print( "a.y() = ", False )
        Print( a.y() )

        Print( "a[1]= ", False )
        Print( a[1] )

    Return type:

      float

    Returns:

      Y value

  z()

    Get the Z coordinate (index 2) of the vec3d

            vec3d a()                                # Default Constructor

        a.set_xyz( 2.0, 4.0, 6.0 )

        Print( "a.z() = ", False )
        Print( a.z() )

        Print( "a[2]= ", False )
        Print( a[2] )

    Return type:

      float

    Returns:

      Z value