# 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.AcceptGeomScale(std: :string const & geom_id)

openvsp.vsp.AddAdvLink(std: :string const & name)

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

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

openvsp.vsp.AddAllToVSPAEROControlSurfaceGroup(int CSGroupIndex)

openvsp.vsp.AddAttributeBool(std: :string const & collID, std: :string const & attributeName, bool value) → std::string

openvsp.vsp.AddAttributeDouble(std: :string const & collID, std: :string const & attributeName, double value) → std::string

openvsp.vsp.AddAttributeDoubleMatrix(std: :string const & collID, std: :string const & attributeName, DoubleVecVec value) → std::string

openvsp.vsp.AddAttributeGroup(std: :string const & collID, std: :string const & attributeName) → std::string

openvsp.vsp.AddAttributeInt(std: :string const & collID, std: :string const & attributeName, int value) → std::string

openvsp.vsp.AddAttributeIntMatrix(std: :string const & collID, std: :string const & attributeName, IntVecVec value) → std::string

openvsp.vsp.AddAttributeParm(std: :string const & collID, std: :string const & attributeName, std: :string const & parmID) → std::string

openvsp.vsp.AddAttributeString(std: :string const & collID, std: :string const & attributeName, std: :string const & value) → std::string

openvsp.vsp.AddAttributeVec3d(std: :string const & collID, std: :string const & attributeName, Vec3dVec value) → std::string

openvsp.vsp.AddBackground3D() → std::string

openvsp.vsp.AddCFDSource(int type, std: :string const & geom_id, int surf_index, double l1, double r1, double u1, double w1, double l2=0, double r2=0, double u2=0, double w2=0)
openvsp.vsp.AddCFDSource(int type, std: :string const & geom_id, int surf_index, double l1, double r1, double u1, double w1, double l2=0, double r2=0, double u2=0)
openvsp.vsp.AddCFDSource(int type, std: :string const & geom_id, int surf_index, double l1, double r1, double u1, double w1, double l2=0, double r2=0)
openvsp.vsp.AddCFDSource(int type, std: :string const & geom_id, int surf_index, double l1, double r1, double u1, double w1, double l2=0)
openvsp.vsp.AddCFDSource(int type, std: :string const & geom_id, int surf_index, double l1, double r1, double u1, double w1)

openvsp.vsp.AddCpSlice(int cut_type, double location) → std::string

openvsp.vsp.AddDefaultSources()

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

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

openvsp.vsp.AddFeaAssembly() → std::string

openvsp.vsp.AddFeaAssemblyConnection(std: :string const & assembly_id, std: :string const & start_fix_pt_id, std: :string const & start_struct_id, int start_index, std: :string const & end_fix_pt_id, std: :string const & end_struct_id, int end_index)

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

openvsp.vsp.AddFeaLayer(std: :string const & material_id) → std::string

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

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

openvsp.vsp.AddFeaPolySparPt(std: :string const & pspar_id) → std::string

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

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

openvsp.vsp.AddFeaStructureToAssembly(std: :string const & assembly_id, std: :string const & struct_id)

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

openvsp.vsp.AddFeaTrimPart(std: :string const & trim_id, std: :string const & part_id)

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

openvsp.vsp.AddGeometryAnalysis() → std::string

openvsp.vsp.AddGeometryAnalysisAzEl(std: :string const & geom_analysis_id, double azimuth, double elevation)

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

openvsp.vsp.AddParmLink(std: :string const & parm_a_id, std: :string const & parm_b_id) → std::string

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

openvsp.vsp.AddProtractor(std: :string const & startgeomid, int startsurfindx, double startu, double startw, std: :string const & midgeomid, int midsurfindx, double midu, double midw, std: :string const & endgeomid, int endsurfindx, double endu, double endw, std: :string const & name) → std::string

openvsp.vsp.AddRSTProbe(std: :string const & geomid, int surfindx, double r, double s, double t, std: :string const & name) → std::string

openvsp.vsp.AddRoutingPt(std: :string const & routing_id, std: :string const & geom_id, int surf_index) → std::string

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

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

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

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

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

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

openvsp.vsp.AddVarPresetSetting(std: :string const & group_id, std: :string const & setting_name) → std::string

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

openvsp.vsp.AdjustAllCFDSourceLen(double mult)

openvsp.vsp.AdjustAllCFDSourceRad(double mult)

openvsp.vsp.ApplyModeSettings(std: :string const & mid)

openvsp.vsp.ApplyVarPresetSetting(std: :string const & group_id, std: :string const & setting_id)

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

openvsp.vsp.AttachGeomTexture(std: :string const & geom_id, std: :string const & file_name) → std::string

openvsp.vsp.AutoGroupVSPAEROControlSurfaces()

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

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

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

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

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

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

openvsp.vsp.BuildAdvLinkScript(int index) → bool

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

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

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

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

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

openvsp.vsp.ClearSkinning(std: :string const & geom_id, int index=-1)
openvsp.vsp.ClearSkinning(std: :string const & geom_id)

openvsp.vsp.ClearVSPModel()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

openvsp.vsp.ComputeFeaAssemblyMesh(std: :string const & assembly_id)

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

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

openvsp.vsp.ComputeMinClearanceDistance(std: :string const & geom_id, int set, bool useMode=False, std: :string const & modeID) → double
openvsp.vsp.ComputeMinClearanceDistance(std: :string const & geom_id, int set, bool useMode=False) → double
openvsp.vsp.ComputeMinClearanceDistance(std: :string const & geom_id, int set) → double
openvsp.vsp.ComputeMinClearanceDistance(std: :string const & geom_id) → double

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

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

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

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

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

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

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

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

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

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

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

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

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

openvsp.vsp.CopyAttribute(std: :string const & attrID) → int

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

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

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

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

openvsp.vsp.CreateAndAddBogie(std: :string const & gear_id) → std::string

openvsp.vsp.CreateAndAddMode(std: :string const & name, int normal_set, int degen_set) → std::string

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

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

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

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

openvsp.vsp.CreateVSPAEROControlSurfaceGroup() → int

openvsp.vsp.CutAttribute(std: :string const & attrID)

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

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

openvsp.vsp.DelAdvLink(int index)

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

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

openvsp.vsp.DelAllAdvLinkInputs(int index)

openvsp.vsp.DelAllAdvLinkOutputs(int index)

openvsp.vsp.DelAllAdvLinks()

openvsp.vsp.DelAllBackground3Ds()

openvsp.vsp.DelAllBogies(std: :string const & gear_id)

openvsp.vsp.DelAllFeaPolySparPt(std: :string const & pspar_id)

openvsp.vsp.DelAllModes()

openvsp.vsp.DelAllParmLinks()

openvsp.vsp.DelAllRoutingPt(std: :string const & routing_id)

openvsp.vsp.DelBackground3D(std: :string const & id)

openvsp.vsp.DelBogie(std: :string const & gear_id, std: :string const & bogie_id)

openvsp.vsp.DelCpSlice(int slice_index)

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

openvsp.vsp.DelFeaPolySparPt(std: :string const & pspar_id, int index)

openvsp.vsp.DelMode(std: :string const & mid)

openvsp.vsp.DelParmLink(std: :string const & link_id)

openvsp.vsp.DelProbe(std: :string const & id)

openvsp.vsp.DelProtractor(std: :string const & id)

openvsp.vsp.DelRSTProbe(std: :string const & id)

openvsp.vsp.DelRoutingPt(std: :string const & routing_id, int index)

openvsp.vsp.DelRuler(std: :string const & id)

openvsp.vsp.DeleteAllCFDSources()

openvsp.vsp.DeleteAllCpSlices()

openvsp.vsp.DeleteAllDesignVars()

openvsp.vsp.DeleteAllExcrescences()

openvsp.vsp.DeleteAllGeometryAnalyses()

openvsp.vsp.DeleteAllGeometryAnalysisAzEl(std: :string const & geom_analysis_id)

openvsp.vsp.DeleteAllProbes()

openvsp.vsp.DeleteAllProtractors()

openvsp.vsp.DeleteAllRSTProbes()

openvsp.vsp.DeleteAllResults()

openvsp.vsp.DeleteAllRulers()

openvsp.vsp.DeleteAllUserParm()

openvsp.vsp.DeleteAllVarPresetGroups()

openvsp.vsp.DeleteAllVarPresetSettings(std: :string const & group_id)

openvsp.vsp.DeleteAttribute(std: :string const & attrID)

openvsp.vsp.DeleteCFDSource(std: :string const & geom_id, int source_index)

openvsp.vsp.DeleteExcrescence(int const & index)

openvsp.vsp.DeleteFeaAssembly(std: :string const & assembly_id)

openvsp.vsp.DeleteFeaAssemblyConnection(std: :string const & assembly_id, int connection_index)

openvsp.vsp.DeleteFeaLayer(std: :string const & material_id, std: :string const & layer_id)

openvsp.vsp.DeleteFeaMaterial(std: :string const & id)

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

openvsp.vsp.DeleteFeaProperty(std: :string const & id)

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

openvsp.vsp.DeleteFeaStructureFromAssembly(std: :string const & assembly_id, std: :string const & struct_id)

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

openvsp.vsp.DeleteFeaTrimPart(std: :string const & trim_id, int index)

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

openvsp.vsp.DeleteGeomVec(StringVector del_vec)

openvsp.vsp.DeleteGeometryAnalysis(std: :string const & id)

openvsp.vsp.DeleteGeometryAnalysisAzEl(std: :string const & geom_analysis_id, int index)

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

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

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

openvsp.vsp.DeleteVSPAEROControlSurfaceGroup(int CSGroupIndex)

openvsp.vsp.DeleteVarPresetGroup(std: :string const & group_id)

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

openvsp.vsp.DeleteVarPresetSetting(std: :string const & group_id, std: :string const & setting_id)

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

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

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

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

openvsp.vsp.DisableStopGUIMenuItem()

class openvsp.vsp.DoubleVecVec(*args)

  Bases: `object`

  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)

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)

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

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

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

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

openvsp.vsp.EnableStopGUIMenuItem()

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

  Bases: `object`

  Proxy of C++ vsp::ErrorMgrSingleton class.

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

openvsp.vsp.ErrorMgrSingleton_getInstance() → ErrorMgrSingleton

class openvsp.vsp.ErrorObj(*args)

  Bases: `object`

  Proxy of C++ vsp::ErrorObj class.

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

    ErrorObj_m_ErrorCode_get(ErrorObj self) -> vsp::ERROR_CODE

  property m_ErrorString

    ErrorObj_m_ErrorString_get(ErrorObj self) -> string const &

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

openvsp.vsp.ExportFile(std: :string const & file_name, int thick_set, int file_type, int subsFlag=1, int thin_set, bool useMode=False, std: :string const & modeID) → std::string
openvsp.vsp.ExportFile(std: :string const & file_name, int thick_set, int file_type, int subsFlag=1, int thin_set, bool useMode=False) → std::string
openvsp.vsp.ExportFile(std: :string const & file_name, int thick_set, int file_type, int subsFlag=1, int thin_set) → std::string
openvsp.vsp.ExportFile(std: :string const & file_name, int thick_set, int file_type, int subsFlag=1) → std::string
openvsp.vsp.ExportFile(std: :string const & file_name, int thick_set, int file_type) → std::string

openvsp.vsp.ExportParasiteDragToCSV(std: :string const & file_name) → std::string

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

openvsp.vsp.FindAllAttributes() → StringVector

openvsp.vsp.FindAttributeByName(std: :string const & search_str, int index) → std::string

openvsp.vsp.FindAttributeInCollection(std: :string const & obj_id, std: :string const & search_str, int index) → std::string

openvsp.vsp.FindAttributeNamesInCollection(std: :string const & collID) → StringVector

openvsp.vsp.FindAttributedObjects() → StringVector

openvsp.vsp.FindAttributesByName(std: :string const & search_str) → StringVector

openvsp.vsp.FindAttributesInCollection(std: :string const & collID) → StringVector

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

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

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

openvsp.vsp.FindContainers() → StringVector

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

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

openvsp.vsp.FindGeoms() → StringVector

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

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

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

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

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

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

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

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

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

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

openvsp.vsp.FitAllViews()

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

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

openvsp.vsp.FitPlane(Vec3dVec pts, vec3d cen, vec3d norm)

openvsp.vsp.GetActiveCSNameVec(int CSGroupIndex) → StringVector

openvsp.vsp.GetActiveGeometryAnalysis() → std::string

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

openvsp.vsp.GetAdvLinkInputNames(int index) → StringVector

openvsp.vsp.GetAdvLinkInputParms(int index) → StringVector

openvsp.vsp.GetAdvLinkName(int index) → std::string

openvsp.vsp.GetAdvLinkNames() → StringVector

openvsp.vsp.GetAdvLinkOutputNames(int index) → StringVector

openvsp.vsp.GetAdvLinkOutputParms(int index) → StringVector

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

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

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

openvsp.vsp.GetAllBackground3DAbsolutePaths() → StringVector

openvsp.vsp.GetAllBackground3DRelativePaths() → StringVector

openvsp.vsp.GetAllBackground3Ds() → StringVector

openvsp.vsp.GetAllBogies(std: :string const & gear_id) → StringVector

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

openvsp.vsp.GetAllFeaPolySparPtIDVec(std: :string const & pspar_id) → StringVector

openvsp.vsp.GetAllGeometryAnalysesIDVec() → StringVector

openvsp.vsp.GetAllModes() → StringVector

openvsp.vsp.GetAllProbes() → StringVector

openvsp.vsp.GetAllProtractors() → StringVector

openvsp.vsp.GetAllRSTProbes() → StringVector

openvsp.vsp.GetAllResultsNames() → StringVector

openvsp.vsp.GetAllRoutingPtCoords(std: :string const & routing_id, int symm_index) → Vec3dVec

openvsp.vsp.GetAllRoutingPtIds(std: :string const & routing_id) → StringVector

openvsp.vsp.GetAllRulers() → StringVector

openvsp.vsp.GetAllSubSurfIDs() → StringVector

openvsp.vsp.GetAllUserParms() → StringVector

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

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

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

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

openvsp.vsp.GetAndResetUpdateCount() → int

openvsp.vsp.GetAttributeBoolVal(std: :string const & attrID) → IntVector

openvsp.vsp.GetAttributeDoc(std: :string const & attrID) → std::string

openvsp.vsp.GetAttributeDoubleMatrixVal(std: :string const & attrID) → DoubleVecVec

openvsp.vsp.GetAttributeDoubleVal(std: :string const & attrID) → DoubleVector

openvsp.vsp.GetAttributeID(std: :string const & collID, std: :string const & attributeName, int index) → std::string

openvsp.vsp.GetAttributeIntMatrixVal(std: :string const & attrID) → IntVecVec

openvsp.vsp.GetAttributeIntVal(std: :string const & attrID) → IntVector

openvsp.vsp.GetAttributeName(std: :string const & attrID) → std::string

openvsp.vsp.GetAttributeParmID(std: :string const & attrID) → StringVector

openvsp.vsp.GetAttributeParmName(std: :string const & attrID) → StringVector

openvsp.vsp.GetAttributeParmVal(std: :string const & attrID) → DoubleVector

openvsp.vsp.GetAttributeStringVal(std: :string const & attrID) → StringVector

openvsp.vsp.GetAttributeType(std: :string const & attrID) → int

openvsp.vsp.GetAttributeTypeName(std: :string const & attrID) → std::string

openvsp.vsp.GetAttributeVec3dVal(std: :string const & attrID) → Vec3dVec

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

openvsp.vsp.GetAvailableCSNameVec(int CSGroupIndex) → StringVector

openvsp.vsp.GetBBoxSet(int set) → bool

openvsp.vsp.GetBEMPropID() → std::string

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

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

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

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

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

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

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

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

openvsp.vsp.GetBackground3DAbsolutePath(std: :string const & id) → std::string

openvsp.vsp.GetBackground3DRelativePath(std: :string const & id) → std::string

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

openvsp.vsp.GetCFDMeshVal(int type) → double

openvsp.vsp.GetCFDSourceID(std: :string const & geom_id, int source_index) → std::string

openvsp.vsp.GetCFDSourceName(std: :string const & geom_id, int source_index) → std::string

openvsp.vsp.GetCFDSourceType(std: :string const & geom_id, int source_index) → int

openvsp.vsp.GetCFDWakeFlag(std: :string const & geom_id) → bool

openvsp.vsp.GetChildCollection(std: :string const & attachID) → std::string

openvsp.vsp.GetCompleteCSNameVec() → StringVector

openvsp.vsp.GetComputationFileName(int file_type) → std::string

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

openvsp.vsp.GetCpSliceID(int slice_index) → std::string

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

openvsp.vsp.GetDesignVarType(int index) → int

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

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

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

openvsp.vsp.GetDriverGroup(std: :string const & geom_id, int section_index) → IntVector

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

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

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

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

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

openvsp.vsp.GetFeaAssemblyFileName(std: :string const & assembly_id, int file_type) → std::string

openvsp.vsp.GetFeaAssemblyIDVec() → StringVector

openvsp.vsp.GetFeaAssemblyName(std: :string const & assembly_id) → std::string

openvsp.vsp.GetFeaAssemblyStructureIDVec(std: :string const & assembly_id) → StringVector

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

openvsp.vsp.GetFeaLayerIDVec(std: :string const & material_id) → StringVector

openvsp.vsp.GetFeaMaterialIDVec() → StringVector

openvsp.vsp.GetFeaMeshFileName(std: :string const & geom_id, int fea_struct_ind, int file_type) → std::string

openvsp.vsp.GetFeaMeshStructIndex() → int

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

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

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

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

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

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

openvsp.vsp.GetFeaPolySparNumPt(std: :string const & pspar_id) → int

openvsp.vsp.GetFeaPolySparPtID(std: :string const & pspar_id, int index) → std::string

openvsp.vsp.GetFeaPolySparPtName(std: :string const & pspar_id, int index) → std::string

openvsp.vsp.GetFeaPropertyIDVec() → StringVector

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

openvsp.vsp.GetFeaStructIDVec() → StringVector

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

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

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

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

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

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

openvsp.vsp.GetFeaTrimPartIDVec(std: :string const & trim_id) → StringVector

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

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

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

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

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

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

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

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

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

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

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

openvsp.vsp.GetGeomSetAtIndex(int index) → StringVector

openvsp.vsp.GetGeomSetCollection(int const & index) → std::string

openvsp.vsp.GetGeomTextureFileName(std: :string const & geom_id, std: :string const & texture_id) → std::string

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

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

openvsp.vsp.GetGeomTypes() → StringVector

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

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

openvsp.vsp.GetGeomWireColor(std: :string const & geom_id) → vec3d

openvsp.vsp.GetGeometryAnalysisAzimuthParm(std: :string const & geom_analysis_id, int index) → std::string

openvsp.vsp.GetGeometryAnalysisElevationParm(std: :string const & geom_analysis_id, int index) → std::string

openvsp.vsp.GetGroupName(std: :string const & group_id) → std::string

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

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

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

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

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

openvsp.vsp.GetIntersectSubSurfGeomID(std: :string const & sub_id) → std::string

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

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

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

openvsp.vsp.GetMainRoutingPtCoord(std: :string const & pt_id) → vec3d

openvsp.vsp.GetMaterialNames() → StringVector

openvsp.vsp.GetModeName(std: :string const & mid) → std::string

openvsp.vsp.GetNumActuatorDisks() → int

openvsp.vsp.GetNumAnalysis() → int

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

openvsp.vsp.GetNumBackground3Ds() → int

openvsp.vsp.GetNumBogies(std: :string const & gear_id) → int

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

openvsp.vsp.GetNumControlSurfaceGroups() → int

openvsp.vsp.GetNumCpSlices() → int

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

openvsp.vsp.GetNumDesignVars() → int

openvsp.vsp.GetNumExcrescences() → int

openvsp.vsp.GetNumGeometryAnalysisAzEl(std: :string const & geom_analysis_id) → int

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

openvsp.vsp.GetNumModes() → int

openvsp.vsp.GetNumParmLinks() → int

openvsp.vsp.GetNumPredefinedUserParms() → int

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

openvsp.vsp.GetNumRoutingPts(std: :string const & routing_id) → int

openvsp.vsp.GetNumSets() → int

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

openvsp.vsp.GetNumUnsteadyGroups() → int

openvsp.vsp.GetNumUnsteadyRotorGroups() → int

openvsp.vsp.GetNumUserParms() → int

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

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

openvsp.vsp.GetObjectName(std: :string const & attachID) → std::string

openvsp.vsp.GetObjectParent(std: :string const & id) → std::string

openvsp.vsp.GetObjectType(std: :string const & attachID) → int

openvsp.vsp.GetObjectTypeName(std: :string const & attachID) → std::string

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

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

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

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

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

openvsp.vsp.GetParmLinkAParm(std: :string const & link_id) → std::string

openvsp.vsp.GetParmLinkBParm(std: :string const & link_id) → std::string

openvsp.vsp.GetParmLinkID(int index) → std::string

openvsp.vsp.GetParmLinkLowerLimitFlag(std: :string const & link_id) → bool

openvsp.vsp.GetParmLinkOffsetFlag(std: :string const & link_id) → bool

openvsp.vsp.GetParmLinkScaleFlag(std: :string const & link_id) → bool

openvsp.vsp.GetParmLinkUpperLimitFlag(std: :string const & link_id) → bool

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

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

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

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

openvsp.vsp.GetParmVal(std: :string const & parm_id) → double
openvsp.vsp.GetParmVal(std: :string const & geom_id, std: :string const & name, std: :string const & group) → double

openvsp.vsp.GetPtCloudPnts(std: :string const & geom_id) → Vec3dVec

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

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

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

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

openvsp.vsp.GetRoutingCurve(std: :string const & routing_id, int symm_index) → Vec3dVec

openvsp.vsp.GetRoutingPtCoord(std: :string const & routing_id, int index, int symm_index) → vec3d

openvsp.vsp.GetRoutingPtID(std: :string const & routing_id, int index) → std::string

openvsp.vsp.GetRoutingPtParentID(std: :string const & pt_id) → std::string

openvsp.vsp.GetScaleIndependentBBoxSet(int set) → bool

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

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

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

openvsp.vsp.GetSettingName(std: :string const & setting_id) → std::string

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

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

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

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

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

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

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

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

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

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

openvsp.vsp.GetUnsteadyGroupCompIDs(int group_index) → StringVector

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

openvsp.vsp.GetUnsteadyGroupSurfIndexes(int group_index) → IntVector

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

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

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

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

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

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

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

openvsp.vsp.GetVSPAERORefWingID() → std::string

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

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

openvsp.vsp.GetVSPHelpPath() → std::string

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

openvsp.vsp.GetVSPVersionChange() → int

openvsp.vsp.GetVSPVersionMajor() → int

openvsp.vsp.GetVSPVersionMinor() → int

openvsp.vsp.GetVarPresetGroups() → StringVector

openvsp.vsp.GetVarPresetParmIDs(std: :string const & group_id) → StringVector

openvsp.vsp.GetVarPresetParmVal(std: :string const & group_id, std: :string const & setting_id, std: :string const & parm_id) → double

openvsp.vsp.GetVarPresetParmVals(std: :string const & setting_id) → DoubleVector

openvsp.vsp.GetVarPresetSettings(std: :string const & group_id) → StringVector

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

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

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

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

openvsp.vsp.GetXSecAlias(std: :string const & id) → std::string

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

openvsp.vsp.GetXSecCurvatures(std: :string const & xsec_id, int side) → DoubleVector

openvsp.vsp.GetXSecCurveAlias(std: :string const & id) → std::string

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

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

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

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

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

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

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

openvsp.vsp.GetXSecTanAngles(std: :string const & xsec_id, int side) → DoubleVector

openvsp.vsp.GetXSecTanSlews(std: :string const & xsec_id, int side) → DoubleVector

openvsp.vsp.GetXSecTanStrengths(std: :string const & xsec_id, int side) → DoubleVector

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

openvsp.vsp.HideAllBackground3Ds()

openvsp.vsp.HideAllProbes()

openvsp.vsp.HideAllProtractors()

openvsp.vsp.HideAllRSTProbes()

openvsp.vsp.HideAllRulers()

openvsp.vsp.HideScreen(int s)

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

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

openvsp.vsp.InitGUI()

openvsp.vsp.InitStackPreset(std: :string const & geom_id, int preset)

openvsp.vsp.InsertFeaPolySparPt(std: :string const & pspar_id, int index) → std::string

openvsp.vsp.InsertRoutingPt(std: :string const & routing_id, int index, std: :string const & geom_id, int surf_index) → std::string

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

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

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

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

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)

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

openvsp.vsp.IntersectSubSurf(std: :string const & sub_id)

openvsp.vsp.IsEventLoopRunning() → bool

openvsp.vsp.IsFacade()

  Returns True if the facade API is in use.

      is_facade = IsFacade()

openvsp.vsp.IsGUIBuild() → bool

openvsp.vsp.IsGUIRunning()

  Returns True if the GUI event loop is running.

      is_gui_active = IsGUIRunning()

openvsp.vsp.LimitedIntersectSurfaces(StringVector geomvec, std: :vector< std::vector< vec3d, std: :allocator< vec3d > >, std: :allocator< std::vector< vec3d, std: :allocator< vec3d > > > > & ptchains, std: :vector< std::vector< vec3d, std: :allocator< vec3d > >, std: :allocator< std::vector< vec3d, std: :allocator< vec3d > > > > & uwchains)

openvsp.vsp.LinkAllComp(std: :string const & parm_a_id, std: :string const & parm_b_id) → bool

openvsp.vsp.LinkAllGroup(std: :string const & parm_a_id, std: :string const & parm_b_id) → bool

openvsp.vsp.ListAnalysis() → StringVector

openvsp.vsp.Lock()

openvsp.vsp.MakeMeshGeom(std: :string const & ga_id) → std::string

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`

  Proxy of C++ Matrix4d class.

  affineInverse(Matrix4d self)
  buildXForm(Matrix4d self, vec3d pos, vec3d rot, vec3d cent_rot)
  const_data(Matrix4d self) → double const *
  data(Matrix4d self) → double *
  flipx(Matrix4d self)
  getAngles(Matrix4d self) → vec3d
  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(Matrix4d self)
  loadXYRef(Matrix4d self)
  loadXZRef(Matrix4d self)
  loadYZRef(Matrix4d self)
  matMult(Matrix4d self, double const * m)
  matMult(Matrix4d self, Matrix4d m)
  mirrory(Matrix4d self)
  mult(Matrix4d self, double const [4] arg2, double [4] out)
  postMult(Matrix4d self, double const * m)
  postMult(Matrix4d self, Matrix4d m)
  rotate(Matrix4d self, double const & angle, vec3d axis)
  rotateX(Matrix4d self, double const & ang)
  rotateY(Matrix4d self, double const & ang)
  rotateZ(Matrix4d self, double const & ang)
  rotatealongX(Matrix4d self, vec3d dir1)
  scale(Matrix4d self, double const & scale)
  scalex(Matrix4d self, double const & scalex)
  scaley(Matrix4d self, double const & scaley)
  scalez(Matrix4d self, double const & scalez)
  setBasis(Matrix4d self, vec3d xdir, vec3d ydir, vec3d zdir)
  static setIdentity(double * m)
  toQuat(Matrix4d self, double & qw, double & qx, double & qy, double & qz, double & tx, double & ty, double & tz)
  translatef(Matrix4d self, double const & x, double const & y, double const & z)
  translatev(Matrix4d self, vec3d v)
  xform(Matrix4d self, vec3d arg2) → vec3d
  xformmat(Matrix4d self, std: :vector< std::vector< vec3d, std: :allocator< vec3d > >, std: :allocator< std::vector< vec3d, std: :allocator< vec3d > > > > & arg2)
  xformnorm(Matrix4d self, vec3d arg2) → vec3d
  xformnormmat(Matrix4d self, std: :vector< std::vector< vec3d, std: :allocator< vec3d > >, std: :allocator< std::vector< vec3d, std: :allocator< vec3d > > > > & arg2)
  xformnormvec(Matrix4d self, Vec3dVec arg2)
  xformvec(Matrix4d self, Vec3dVec arg2)
  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)

openvsp.vsp.Matrix4d_setIdentity(double * m)

openvsp.vsp.ModeAddGroupSetting(std: :string const & mid, std: :string const & gid, std: :string const & sid)

openvsp.vsp.ModeGetAllGroups(std: :string const & mid) → StringVector

openvsp.vsp.ModeGetAllSettings(std: :string const & mid) → StringVector

openvsp.vsp.ModeGetGroup(std: :string const & mid, int indx) → std::string

openvsp.vsp.ModeGetSetting(std: :string const & mid, int indx) → std::string

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

openvsp.vsp.MoveFeaPolySparPt(std: :string const & pspar_id, int index, int reorder_type) → int

openvsp.vsp.MoveRoutingPt(std: :string const & routing_id, int index, int reorder_type) → int

openvsp.vsp.NoShowSet(int set_index)

openvsp.vsp.NumFeaAssemblies() → int

openvsp.vsp.NumFeaAssemblyConnections(std: :string const & assembly_id) → int

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

openvsp.vsp.NumFeaLayers(std: :string const & material_id) → int

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

openvsp.vsp.NumFeaStructures() → int

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

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

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

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

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

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

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

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

openvsp.vsp.PasteAttribute(std: :string const & coll_id) → StringVector

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

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

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

openvsp.vsp.PointInPolygon(vec2d R, std: :vector< vec2d, std: :allocator< vec2d > > const & pnts) → bool

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

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

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

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

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

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

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

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

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

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

openvsp.vsp.ProjectPtCloudPts(std: :string const & geom_id, std: :string const & target_geom_id, int surf_index, int dir_index)

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

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

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

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

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

openvsp.vsp.ReadAdvLinkCodeFile(int index, std: :string const & file_name)

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

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

openvsp.vsp.ReadAuxiliaryGeomCCEFile(std: :string const & geom_id, std: :string const & file_name)

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

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

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

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

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

openvsp.vsp.RegisterCFDMeshAnalyses()

openvsp.vsp.RemoveAllFromVSPAEROControlSurfaceGroup(int CSGroupIndex)

openvsp.vsp.RemoveAllGroupSettings(std: :string const & mid)

openvsp.vsp.RemoveGeomTexture(std: :string const & geom_id, std: :string const & texture_id)

openvsp.vsp.RemoveGroupSetting(std: :string const & mid, int indx)

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

openvsp.vsp.ReorderAdvLinkInput(int index, std: :string const & var_name, int reorder_type)

openvsp.vsp.ReorderAdvLinkOutput(int index, std: :string const & var_name, int reorder_type)

openvsp.vsp.ReorderFeaLayer(std: :string const & material_id, std: :string const & layer_id, int reorder_type)

openvsp.vsp.ReorderFeaPart(std: :string const & geom_id, int fea_struct_ind, std: :string const & part_id, int reorder_type)

openvsp.vsp.ReorderGeom(std: :string const & geom_id, int reorder_type)

openvsp.vsp.ReorderSubSurf(std: :string const & geom_id, std: :string const & sub_id, int reorder_type)

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

openvsp.vsp.ResetGeomScale(std: :string const & geom_id)

openvsp.vsp.ResetPropellerThickness(std: :string const & geom_id)

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

openvsp.vsp.ResetViews()

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

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

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

openvsp.vsp.SaveVarPresetParmVals(std: :string const & group_id, std: :string const & setting_id)

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

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

openvsp.vsp.SearchReplaceAdvLinkCode(int index, std: :string const & arg2, std: :string const & to)

openvsp.vsp.SetActiveGeometryAnalysis(std: :string const & id)

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

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

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

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

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

openvsp.vsp.SetAllViews(int view)

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

openvsp.vsp.SetAttributeBool(std: :string const & attrID, bool value)

openvsp.vsp.SetAttributeDoc(std: :string const & attrID, std: :string const & doc)

openvsp.vsp.SetAttributeDouble(std: :string const & attrID, double value)

openvsp.vsp.SetAttributeDoubleMatrix(std: :string const & attrID, DoubleVecVec value)

openvsp.vsp.SetAttributeInt(std: :string const & attrID, int value)

openvsp.vsp.SetAttributeIntMatrix(std: :string const & attrID, IntVecVec value)

openvsp.vsp.SetAttributeName(std: :string const & attrID, std: :string const & name)

openvsp.vsp.SetAttributeParmID(std: :string const & attrID, std: :string const & value)

openvsp.vsp.SetAttributeString(std: :string const & attrID, std: :string const & value)

openvsp.vsp.SetAttributeVec3d(std: :string const & attrID, Vec3dVec value)

openvsp.vsp.SetAuxiliaryGeomContactPtID(std: :string const & geom_id, int index, std: :string const & bogie_id)

openvsp.vsp.SetBEMPropID(std: :string const & prop_id)

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

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

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

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

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

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

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

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

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

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

openvsp.vsp.SetCFDSourceName(std: :string const & geom_id, int source_index, std: :string const & name)

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

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

openvsp.vsp.SetContainerName(std: :string const & parm_container_id, std: :string const & name)

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

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

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

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

openvsp.vsp.SetFeaAssemblyFileName(std: :string const & assembly_id, int file_type, std: :string const & file_name)

openvsp.vsp.SetFeaAssemblyName(std: :string const & assembly_id, std: :string const & name)

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

openvsp.vsp.SetFeaMeshStructIndex(int struct_index)

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

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

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

openvsp.vsp.SetFeaPolySparPtName(std: :string const & pspar_id, int index, std: :string const & name)

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

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

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

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

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

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

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

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

openvsp.vsp.SetGeomParent(std: :string const & geom_id, std: :string const & parent_id)

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

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

openvsp.vsp.SetGroupName(std: :string const & group_id, std: :string const & group_name)

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

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

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

openvsp.vsp.SetModeName(std: :string const & mid, std: :string const & name)

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

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

openvsp.vsp.SetParmLinkAParm(std: :string const & link_id, std: :string const & parm_id)

openvsp.vsp.SetParmLinkBParm(std: :string const & link_id, std: :string const & parm_id)

openvsp.vsp.SetParmLinkLowerLimitFlag(std: :string const & link_id, bool flag)

openvsp.vsp.SetParmLinkOffsetFlag(std: :string const & link_id, bool flag)

openvsp.vsp.SetParmLinkScaleFlag(std: :string const & link_id, bool flag)

openvsp.vsp.SetParmLinkUpperLimitFlag(std: :string const & link_id, bool flag)

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

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

openvsp.vsp.SetParmVal(std: :string const & parm_id, double val) → double
openvsp.vsp.SetParmVal(std: :string const & geom_id, std: :string const & name, std: :string const & group, double val) → double

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

openvsp.vsp.SetParmValUpdate(std: :string const & parm_id, double val) → double
openvsp.vsp.SetParmValUpdate(std: :string const & geom_id, std: :string const & parm_name, std: :string const & parm_group_name, double val) → double

openvsp.vsp.SetRoutingPtParentID(std: :string const & pt_id, std: :string const & parent_id)

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

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

openvsp.vsp.SetSettingName(std: :string const & setting_id, std: :string const & setting_name)

openvsp.vsp.SetShowBorders(bool brdr)

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

openvsp.vsp.SetSubSurfName(std: :string const & geom_id, std: :string const & sub_id, std: :string const & name)
openvsp.vsp.SetSubSurfName(std: :string const & sub_id, std: :string const & name)

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

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

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

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

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

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

openvsp.vsp.SetVarPresetParmVal(std: :string const & group_id, std: :string const & setting_id, std: :string const & parm_id, double parm_val)

openvsp.vsp.SetVarPresetParmVals(std: :string const & setting_id, DoubleVector parm_vals)

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

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

openvsp.vsp.SetViewAxis(bool vaxis)

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

openvsp.vsp.SetXSecAlias(std: :string const & id, std: :string const & alias)

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

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

openvsp.vsp.SetXSecCurveAlias(std: :string const & id, std: :string const & alias)

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

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

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

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

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

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

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

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

openvsp.vsp.ShowAllBackground3Ds()

openvsp.vsp.ShowAllProbes()

openvsp.vsp.ShowAllProtractors()

openvsp.vsp.ShowAllRSTProbes()

openvsp.vsp.ShowAllRulers()

openvsp.vsp.ShowOnlyMode(std: :string const & mid)

openvsp.vsp.ShowOnlySet(int set_index)

openvsp.vsp.ShowScreen(int s)

openvsp.vsp.ShowSet(int set_index)

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

openvsp.vsp.SortAdvLinkInputsCGP(int index)

openvsp.vsp.SortAdvLinkInputsVar(int index)

openvsp.vsp.SortAdvLinkOutputsCGP(int index)

openvsp.vsp.SortAdvLinkOutputsVar(int index)

openvsp.vsp.SortParmLinksByA()

openvsp.vsp.SortParmLinksByB()

openvsp.vsp.SplitWingXSec(std: :string const & wing_id, int section_index)

openvsp.vsp.StartGUI()

openvsp.vsp.StopGUI()

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)

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)

openvsp.vsp.SummarizeAttributes() → std::string

openvsp.vsp.SummarizeAttributesAsTree() → std::string

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
  decr(SwigPyIterator self) → SwigPyIterator
  distance(SwigPyIterator self, SwigPyIterator x) → ptrdiff_t
  equal(SwigPyIterator self, SwigPyIterator x) → bool
  incr(SwigPyIterator self, size_t n=1) → SwigPyIterator
  incr(SwigPyIterator self) → SwigPyIterator
  next(SwigPyIterator self) → PyObject *
  previous(SwigPyIterator self) → PyObject *
  value(SwigPyIterator self) → PyObject *

openvsp.vsp.ToCartesian(vec3d v) → vec3d

openvsp.vsp.ToSpherical(vec3d v) → vec3d

openvsp.vsp.ToSpherical2(vec3d v, vec3d vdet) → vec3d

openvsp.vsp.TransformSet(int set_index, vec3d translation_vec, double x_rot_deg, double y_rot_deg, double z_rot_deg, double scale, bool scale_translations_flag)

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

openvsp.vsp.Unlock()

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

openvsp.vsp.UpdateGUI()

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

openvsp.vsp.UpdateParasiteDrag()

openvsp.vsp.VSPCheckSetup()

openvsp.vsp.VSPCrash(int crash_type)

openvsp.vsp.VSPExit(int error_code)

openvsp.vsp.VSPRenew()

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

openvsp.vsp.ValidateAdvLinkParms(int index) → bool

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)

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

openvsp.vsp.WriteAdvLinkCodeFile(int index, std: :string const & file_name)

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

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

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

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

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

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

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

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

openvsp.vsp.WriteTestResults()

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

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

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

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
  transform(vec2d self, float [3][3] mat) → vec2d
  transform(vec2d self, double [3][3] mat) → vec2d
  property v

    vec2d_v_get(vec2d self) -> double [2]

  x(vec2d self) → double
  y(vec2d self) → double

class openvsp.vsp.vec3d(*args)

  Bases: `object`

  Proxy of C++ vec3d class.

  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(vec3d self) → double
  magsq(vec3d self) → double
  major_comp(vec3d self) → int
  minor_comp(vec3d self) → int
  normalize(vec3d self)
  offset_i(vec3d self, double offset, int idir)
  offset_x(vec3d self, double offset)
  offset_y(vec3d self, double offset)
  offset_z(vec3d self, double offset)
  reflect_xy(vec3d self) → vec3d
  reflect_xz(vec3d self) → vec3d
  reflect_yz(vec3d self) → vec3d
  rotate_x(vec3d self, double theta)
  rotate_y(vec3d self, double theta)
  rotate_z(vec3d self, double theta)
  scale_x(vec3d self, double scale)
  scale_y(vec3d self, double scale)
  scale_z(vec3d self, double scale)
  set_arr(vec3d self, double const [] a) → vec3d
  set_arr(vec3d self, float const [] a) → vec3d
  set_refx(vec3d self, vec3d a) → vec3d
  set_refy(vec3d self, vec3d a) → vec3d
  set_refz(vec3d self, vec3d a) → vec3d
  set_vec(vec3d self, DoubleVector a) → vec3d
  set_x(vec3d self, double xx) → vec3d
  set_xyz(vec3d self, double xx, double yy, double zz) → vec3d
  set_y(vec3d self, double yy) → vec3d
  set_z(vec3d self, double zz) → vec3d
  swap_xy(vec3d self) → vec3d
  swap_xz(vec3d self) → vec3d
  swap_yz(vec3d self) → vec3d
  property v

    vec3d_v_get(vec3d self) -> double [3]

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