openvsp_as.h

Go to the documentation of this file.

class string
{
public:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
  // Methods
  string& operator=(const string&in);
  string& operator+=(const string&in);
  bool operator==(const string&in) const;
  int operator>(const string&in) const;
  string operator+(const string&in) const;
  uint length() const;
  void resize(uint);
  uint get_length() const;
  void set_length(uint);
  bool isEmpty() const;
  uint8& operator[](uint);
  const uint8& operator[](uint) const;
  string& operator=(double);
  string& operator+=(double);
  string operator+(double) const;
  string operator+(double) const;
  string& operator=(float);
  string& operator+=(float);
  string operator+(float) const;
  string operator+(float) const;
  string& operator=(int64);
  string& operator+=(int64);
  string operator+(int64) const;
  string operator+(int64) const;
  string& operator=(uint64);
  string& operator+=(uint64);
  string operator+(uint64) const;
  string operator+(uint64) const;
  string& operator=(bool);
  string& operator+=(bool);
  string operator+(bool) const;
  string operator+(bool) const;
  string substr(uint start = 0, int count = - 1) const;
  int findFirst(const string&in, uint start = 0) const;
  int findFirstOf(const string&in, uint start = 0) const;
  int findFirstNotOf(const string&in, uint start = 0) const;
  int findLast(const string&in, int start = - 1) const;
  int findLastOf(const string&in, int start = - 1) const;
  int findLastNotOf(const string&in, int start = - 1) const;
  void insert(uint pos, const string&in other);
  void erase(uint pos, int count = - 1);
  uint size() const;
  bool empty() const;
  int find(const string&in, uint start = 0) const;
  int rfind(const string&in, int start = - 1) const;
  string[]@ split(const string&in) const;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
};



template<typename T>
class array
{
public:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
  // Methods
  T& operator[](uint index);
  const T& operator[](uint index) const;
  T[]& operator=(const T[]&in);
  void insertAt(uint index, const T&in value);
  void insertAt(uint index, const T[]&inout arr);
  void insertLast(const T&in value);
  void removeAt(uint index);
  void removeLast();
  void removeRange(uint start, uint count);
  uint length() const;
  void reserve(uint length);
  void resize(uint length);
  void sortAsc();
  void sortAsc(uint startAt, uint count);
  void sortDesc();
  void sortDesc(uint startAt, uint count);
  void reverse();
  int find(const T&in value) const;
  int find(uint startAt, const T&in value) const;
  int findByRef(const T&in value) const;
  int findByRef(uint startAt, const T&in value) const;
  bool operator==(const T[]&in) const;
  bool isEmpty() const;
  uint get_length() const;
  void set_length(uint);
  uint size() const;
  bool empty() const;
  void push_back(const T&in);
  void pop_back();
  void insert(uint index, const T&in value);
  void insert(uint index, const T[]&inout arr);
  void erase(uint);
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
};



class file
{
public:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
  // Properties
  bool mostSignificantByteFirst;
  // Methods
  int open(const string&in, const string&in);
  int close();
  int getSize() const;
  bool isEndOfFile() const;
  string readString(uint);
  string readLine();
  int64 readInt(uint);
  uint64 readUInt(uint);
  float readFloat();
  double readDouble();
  int writeString(const string&in);
  int writeInt(int64, uint);
  int writeUInt(uint64, uint);
  int writeFloat(float);
  int writeDouble(double);
  int getPos() const;
  int setPos(int);
  int movePos(int);
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
};



class any
{
public:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
  // Methods
  any& operator=(any&in);
  void store(?&in);
  void store(const int64&in);
  void store(const double&in);
  bool retrieve(?&out);
  bool retrieve(int64&out);
  bool retrieve(double&out);
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
};



class vec3d
{
public:
  // Methods
  
  double& operator[](int) const;
  
  double x() const;
  
  double y() const;
  
  double z() const;
  
  vec3d& set_xyz(double x, double y, double z);
  
  vec3d& set_x(double x);
  
  vec3d& set_y(double y);
  
  vec3d& set_z(double z);
  
  void rotate_x(double cos_alpha, double sin_alpha);
  
  void rotate_y(double cos_alpha, double sin_alpha);
  
  void rotate_z(double cos_alpha, double sin_alpha);
  
  void scale_x(double scale);
  
  void scale_y(double scale);
  
  void scale_z(double scale);
  
  void offset_x(double offset);
  
  void offset_y(double offset);
  
  void offset_z(double offset);
  
  void rotate_z_zero_x(double cos_alpha, double sin_alpha);
  
  void rotate_z_zero_y(double cos_alpha, double sin_alpha);
  
  vec3d reflect_xy();
  
  vec3d reflect_xz();
  
  vec3d reflect_yz();
  
  vec3d operator+(const vec3d&in) const;
  
  vec3d operator-(const vec3d&in) const;
  
  vec3d operator*(double b) const;
  
  vec3d operator*(const vec3d&in) const;
  
  vec3d operator/(double b) const;
  
  double mag() const;
  
  void normalize();
};



class Matrix4d
{
public:
  // Methods
  
  void loadIdentity();
  
  void translatef(const double&in x, const double&in y, const double&in z);
  
  void rotateX(const double&in ang);
  
  void rotateY(const double&in ang);
  
  void rotateZ(const double&in ang);
  
  void rotate(const double&in ang, const vec3d&in axis);
  
  void scale(const double&in scale);
  
  vec3d xform(const vec3d&in v);
  
  vec3d getAngles();
  
  void loadXZRef();
  
  void loadXYRef();
  
  void loadYZRef();
  
  void affineInverse();
  
  void buildXForm(const vec3d&in pos, const vec3d&in rot, const vec3d&in cent_rot);
};



class ErrorObj
{
public:
  // Methods
  
  ERROR_CODE GetErrorCode();
  
  string GetErrorString();
};


enum ABS_REL_FLAG
{
  ABS = 0, 
  REL = 1 
};

enum AIRFOIL_EXPORT_TYPE
{
  SELIG_AF_EXPORT = 0, 
  BEZIER_AF_EXPORT = 1 
};

enum ANG_UNITS
{
  ANG_RAD = 0, 
  ANG_DEG = 1 
};

enum ATMOS_TYPE
{
  ATMOS_TYPE_US_STANDARD_1976 = 0, 
  ATMOS_TYPE_HERRINGTON_1966 = 1, 
  ATMOS_TYPE_MANUAL_P_R = 2, 
  ATMOS_TYPE_MANUAL_P_T = 3, 
  ATMOS_TYPE_MANUAL_R_T = 4, 
  ATMOS_TYPE_MANUAL_RE_L = 5 
};

enum ATTACH_ROT_TYPE
{
  ATTACH_ROT_NONE = 0, 
  ATTACH_ROT_COMP = 1, 
  ATTACH_ROT_UV = 2 
};

enum ATTACH_TRANS_TYPE
{
  ATTACH_TRANS_NONE = 0, 
  ATTACH_TRANS_COMP = 1, 
  ATTACH_TRANS_UV = 2 
};

enum BOR_MODE
{
  BOR_FLOWTHROUGH = 0, 
  BOR_UPPER = 1, 
  BOR_LOWER = 2, 
  BOR_NUM_MODES = 3 
};

enum CAMBER_INPUT_FLAG
{
  MAX_CAMB = 0, 
  DESIGN_CL = 1 
};

enum CAP_TYPE
{
  NO_END_CAP = 0, 
  FLAT_END_CAP = 1, 
  ROUND_END_CAP = 2, 
  EDGE_END_CAP = 3, 
  SHARP_END_CAP = 4, 
  NUM_END_CAP_OPTIONS = 5 
};

enum CFD_CONTROL_TYPE
{
  CFD_MIN_EDGE_LEN = 0, 
  CFD_MAX_EDGE_LEN = 1, 
  CFD_MAX_GAP = 2, 
  CFD_NUM_CIRCLE_SEGS = 3, 
  CFD_GROWTH_RATIO = 4, 
  CFD_LIMIT_GROWTH_FLAG = 5, 
  CFD_INTERSECT_SUBSURFACE_FLAG = 6, 
  CFD_HALF_MESH_FLAG = 7, 
  CFD_FAR_FIELD_FLAG = 8, 
  CFD_FAR_MAX_EDGE_LEN = 9, 
  CFD_FAR_MAX_GAP = 10, 
  CFD_FAR_NUM_CIRCLE_SEGS = 11, 
  CFD_FAR_SIZE_ABS_FLAG = 12, 
  CFD_FAR_LENGTH = 13, 
  CFD_FAR_WIDTH = 14, 
  CFD_FAR_HEIGHT = 15, 
  CFD_FAR_X_SCALE = 16, 
  CFD_FAR_Y_SCALE = 17, 
  CFD_FAR_Z_SCALE = 18, 
  CFD_FAR_LOC_MAN_FLAG = 19, 
  CFD_FAR_LOC_X = 20, 
  CFD_FAR_LOC_Y = 21, 
  CFD_FAR_LOC_Z = 22, 
  CFD_SRF_XYZ_FLAG = 23 
};

enum CFD_MESH_EXPORT_TYPE
{
  CFD_STL_FILE_NAME = 0, 
  CFD_POLY_FILE_NAME = 1, 
  CFD_TRI_FILE_NAME = 2, 
  CFD_OBJ_FILE_NAME = 3, 
  CFD_DAT_FILE_NAME = 4, 
  CFD_KEY_FILE_NAME = 5, 
  CFD_GMSH_FILE_NAME = 6, 
  CFD_SRF_FILE_NAME = 7, 
  CFD_TKEY_FILE_NAME = 8, 
  CFD_FACET_FILE_NAME = 9, 
  CFD_CURV_FILE_NAME = 10, 
  CFD_PLOT3D_FILE_NAME = 11, 
  CFD_NUM_FILE_NAMES = 12 
};

enum CFD_MESH_SOURCE_TYPE
{
  POINT_SOURCE = 0, 
  LINE_SOURCE = 1, 
  BOX_SOURCE = 2, 
  ULINE_SOURCE = 3, 
  WLINE_SOURCE = 4, 
  NUM_SOURCE_TYPES = 5 
};

enum CF_LAM_EQN
{
  CF_LAM_BLASIUS = 0, 
  CF_LAM_BLASIUS_W_HEAT = 1 
};

enum CF_TURB_EQN
{
  CF_TURB_EXPLICIT_FIT_SPALDING = 0, 
  CF_TURB_EXPLICIT_FIT_SPALDING_CHI = 1, 
  CF_TURB_EXPLICIT_FIT_SCHOENHERR = 2, 
  DO_NOT_USE_CF_TURB_IMPLICIT_KARMAN = 3, 
  CF_TURB_IMPLICIT_SCHOENHERR = 4, 
  CF_TURB_IMPLICIT_KARMAN_SCHOENHERR = 5, 
  CF_TURB_POWER_LAW_BLASIUS = 6, 
  CF_TURB_POWER_LAW_PRANDTL_LOW_RE = 7, 
  CF_TURB_POWER_LAW_PRANDTL_MEDIUM_RE = 8, 
  CF_TURB_POWER_LAW_PRANDTL_HIGH_RE = 9, 
  CF_TURB_SCHLICHTING_COMPRESSIBLE = 10, 
  DO_NOT_USE_CF_TURB_SCHLICHTING_INCOMPRESSIBLE = 11, 
  DO_NOT_USE_CF_TURB_SCHLICHTING_PRANDTL = 12, 
  DO_NOT_USE_CF_TURB_SCHULTZ_GRUNOW_HIGH_RE = 13, 
  CF_TURB_SCHULTZ_GRUNOW_SCHOENHERR = 14, 
  DO_NOT_USE_CF_TURB_WHITE_CHRISTOPH_COMPRESSIBLE = 15, 
  CF_TURB_ROUGHNESS_SCHLICHTING_AVG = 16, 
  DO_NOT_USE_CF_TURB_ROUGHNESS_SCHLICHTING_LOCAL = 17, 
  DO_NOT_USE_CF_TURB_ROUGHNESS_WHITE = 18, 
  CF_TURB_ROUGHNESS_SCHLICHTING_AVG_FLOW_CORRECTION = 19, 
  CF_TURB_HEATTRANSFER_WHITE_CHRISTOPH = 20 
};

enum COLLISION_ERRORS
{
  COLLISION_OK = 0, 
  COLLISION_INTERSECT_NO_SOLUTION = 1, 
  COLLISION_CLEAR_NO_SOLUTION = 2 
};

enum COMPUTATION_FILE_TYPE
{
  NO_FILE_TYPE = 0, 
  COMP_GEOM_TXT_TYPE = 1, 
  COMP_GEOM_CSV_TYPE = 2, 
  DRAG_BUILD_TSV_TYPE = 4, 
  SLICE_TXT_TYPE = 8, 
  MASS_PROP_TXT_TYPE = 16, 
  DEGEN_GEOM_CSV_TYPE = 32, 
  DEGEN_GEOM_M_TYPE = 64, 
  CFD_STL_TYPE = 128, 
  CFD_POLY_TYPE = 256, 
  CFD_TRI_TYPE = 512, 
  CFD_OBJ_TYPE = 1024, 
  CFD_DAT_TYPE = 2048, 
  CFD_KEY_TYPE = 4096, 
  CFD_GMSH_TYPE = 8192, 
  CFD_SRF_TYPE = 16384, 
  CFD_TKEY_TYPE = 32768, 
  PROJ_AREA_CSV_TYPE = 65536, 
  WAVE_DRAG_TXT_TYPE = 131072, 
  VSPAERO_PANEL_TRI_TYPE = 262144, 
  DRAG_BUILD_CSV_TYPE = 524288, 
  CFD_FACET_TYPE = 1048576, 
  CFD_CURV_TYPE = 2097152, 
  CFD_PLOT3D_TYPE = 4194304 
};

enum DELIM_TYPE
{
  DELIM_COMMA = 0, 
  DELIM_USCORE = 1, 
  DELIM_SPACE = 2, 
  DELIM_NONE = 3, 
  DELIM_NUM_TYPES = 4 
};

enum DIMENSION_SET
{
  SET_3D = 0, 
  SET_2D = 1 
};

enum DIR_INDEX
{
  X_DIR = 0, 
  Y_DIR = 1, 
  Z_DIR = 2 
};

enum DISPLAY_TYPE
{
  DISPLAY_BEZIER = 0, 
  DISPLAY_DEGEN_SURF = 1, 
  DISPLAY_DEGEN_PLATE = 2, 
  DISPLAY_DEGEN_CAMBER = 3 
};

enum DRAW_TYPE
{
  GEOM_DRAW_WIRE = 0, 
  GEOM_DRAW_HIDDEN = 1, 
  GEOM_DRAW_SHADE = 2, 
  GEOM_DRAW_TEXTURE = 3, 
  GEOM_DRAW_NONE = 4 
};

enum ERROR_CODE
{
  VSP_OK = 0, 
  VSP_INVALID_PTR = 1, 
  VSP_INVALID_TYPE = 2, 
  VSP_CANT_FIND_TYPE = 3, 
  VSP_CANT_FIND_PARM = 4, 
  VSP_CANT_FIND_NAME = 5, 
  VSP_INVALID_GEOM_ID = 6, 
  VSP_FILE_DOES_NOT_EXIST = 7, 
  VSP_FILE_WRITE_FAILURE = 8, 
  VSP_WRONG_XSEC_TYPE = 10, 
  VSP_WRONG_FILE_TYPE = 11, 
  VSP_INDEX_OUT_RANGE = 12, 
  VSP_INVALID_XSEC_ID = 13, 
  VSP_INVALID_ID = 14, 
  VSP_CANT_SET_NOT_EQ_PARM = 15, 
  VSP_AMBIGUOUS_SUBSURF = 16, 
  VSP_INVALID_VARPRESET_SETNAME = 17, 
  VSP_INVALID_VARPRESET_GROUPNAME = 18, 
  VSP_CONFORMAL_PARENT_UNSUPPORTED = 19, 
  VSP_UNEXPECTED_RESET_REMAP_ID = 20, 
  VSP_INVALID_INPUT_VAL = 21, 
  VSP_INVALID_CF_EQN = 22 
};

enum EXCRES_TYPE
{
  EXCRESCENCE_COUNT = 0, 
  EXCRESCENCE_CD = 1, 
  EXCRESCENCE_PERCENT_GEOM = 2, 
  EXCRESCENCE_MARGIN = 3, 
  EXCRESCENCE_DRAGAREA = 4 
};

enum EXPORT_TYPE
{
  EXPORT_FELISA = 0, 
  EXPORT_XSEC = 1, 
  EXPORT_STL = 2, 
  EXPORT_AWAVE = 3, 
  EXPORT_NASCART = 4, 
  EXPORT_POVRAY = 5, 
  EXPORT_CART3D = 6, 
  EXPORT_VORXSEC = 7, 
  EXPORT_XSECGEOM = 8, 
  EXPORT_GMSH = 9, 
  EXPORT_X3D = 10, 
  EXPORT_STEP = 11, 
  EXPORT_PLOT3D = 12, 
  EXPORT_IGES = 13, 
  EXPORT_BEM = 14, 
  EXPORT_DXF = 15, 
  EXPORT_FACET = 16, 
  EXPORT_SVG = 17, 
  EXPORT_PMARC = 18, 
  EXPORT_OBJ = 19, 
  EXPORT_SELIG_AIRFOIL = 20, 
  EXPORT_BEZIER_AIRFOIL = 21, 
  EXPORT_IGES_STRUCTURE = 22, 
  EXPORT_STEP_STRUCTURE = 23 
};

enum FEA_CROSS_SECT_TYPE
{
  FEA_XSEC_GENERAL = 0, 
  FEA_XSEC_CIRC = 1, 
  FEA_XSEC_PIPE = 2, 
  FEA_XSEC_I = 3, 
  FEA_XSEC_RECT = 4, 
  FEA_XSEC_BOX = 5 
};

enum FEA_EXPORT_TYPE
{
  FEA_MASS_FILE_NAME = 0, 
  FEA_NASTRAN_FILE_NAME = 1, 
  FEA_NKEY_FILE_NAME = 2, 
  FEA_CALCULIX_FILE_NAME = 3, 
  FEA_STL_FILE_NAME = 4, 
  FEA_GMSH_FILE_NAME = 5, 
  FEA_SRF_FILE_NAME = 6, 
  FEA_CURV_FILE_NAME = 7, 
  FEA_PLOT3D_FILE_NAME = 8, 
  FEA_IGES_FILE_NAME = 9, 
  FEA_STEP_FILE_NAME = 10, 
  FEA_NUM_FILE_NAMES = 11 
};

enum FEA_PART_ELEMENT_TYPE
{
  FEA_SHELL = 0, 
  FEA_BEAM = 1, 
  FEA_SHELL_AND_BEAM = 2 
};

enum FEA_PART_TYPE
{
  FEA_SLICE = 0, 
  FEA_RIB = 1, 
  FEA_SPAR = 2, 
  FEA_FIX_POINT = 3, 
  FEA_DOME = 4, 
  FEA_RIB_ARRAY = 5, 
  FEA_SLICE_ARRAY = 6, 
  FEA_SKIN = 7, 
  FEA_NUM_TYPES = 8 
};

enum FEA_RIB_NORMAL
{
  NO_NORMAL = 0, 
  LE_NORMAL = 1, 
  TE_NORMAL = 2, 
  SPAR_NORMAL = 3 
};

enum FEA_SLICE_TYPE
{
  XY_BODY = 0, 
  YZ_BODY = 1, 
  XZ_BODY = 2, 
  XY_ABS = 3, 
  YZ_ABS = 4, 
  XZ_ABS = 5, 
  SPINE_NORMAL = 6 
};

enum FEA_UNIT_TYPE
{
  SI_UNIT = 0, 
  CGS_UNIT = 1, 
  MPA_UNIT = 2, 
  BFT_UNIT = 3, 
  BIN_UNIT = 4 
};

enum FF_B_EQN
{
  FF_B_MANUAL = 0, 
  FF_B_SCHEMENSKY_BODY = 1, 
  FF_B_SCHEMENSKY_NACELLE = 2, 
  FF_B_HOERNER_STREAMBODY = 3, 
  FF_B_TORENBEEK = 4, 
  FF_B_SHEVELL = 5, 
  FF_B_COVERT = 6, 
  FF_B_JENKINSON_FUSE = 7, 
  FF_B_JENKINSON_WING_NACELLE = 8, 
  FF_B_JENKINSON_AFT_FUSE_NACELLE = 9 
};

enum FF_W_EQN
{
  FF_W_MANUAL = 0, 
  FF_W_EDET_CONV = 1, 
  FF_W_EDET_ADV = 2, 
  FF_W_HOERNER = 3, 
  FF_W_COVERT = 4, 
  FF_W_WILLIAMS = 5, 
  FF_W_KROO = 6, 
  FF_W_TORENBEEK = 7, 
  FF_W_DATCOM = 8, 
  FF_W_SCHEMENSKY_6_SERIES_AF = 9, 
  FF_W_SCHEMENSKY_4_SERIES_AF = 10, 
  FF_W_JENKINSON_WING = 11, 
  FF_W_JENKINSON_TAIL = 12, 
  FF_W_SCHEMENSKY_SUPERCRITICAL_AF = 13 
};

enum FREESTREAM_PD_UNITS
{
  PD_UNITS_IMPERIAL = 0, 
  PD_UNITS_METRIC = 1 
};

enum GDEV
{
  GDEV_TAB = 0, 
  GDEV_SCROLL_TAB = 1, 
  GDEV_GROUP = 2, 
  GDEV_PARM_BUTTON = 3, 
  GDEV_INPUT = 4, 
  GDEV_OUTPUT = 5, 
  GDEV_SLIDER = 6, 
  GDEV_SLIDER_ADJ_RANGE = 7, 
  GDEV_CHECK_BUTTON = 8, 
  GDEV_RADIO_BUTTON = 10, 
  GDEV_TOGGLE_BUTTON = 11, 
  GDEV_TOGGLE_RADIO_GROUP = 12, 
  GDEV_TRIGGER_BUTTON = 13, 
  GDEV_COUNTER = 14, 
  GDEV_CHOICE = 15, 
  GDEV_ADD_CHOICE_ITEM = 16, 
  GDEV_SLIDER_INPUT = 17, 
  GDEV_SLIDER_ADJ_RANGE_INPUT = 18, 
  GDEV_SLIDER_ADJ_RANGE_TWO_INPUT = 19, 
  GDEV_FRACT_PARM_SLIDER = 20, 
  GDEV_STRING_INPUT = 21, 
  GDEV_INDEX_SELECTOR = 22, 
  GDEV_COLOR_PICKER = 23, 
  GDEV_YGAP = 24, 
  GDEV_DIVIDER_BOX = 25, 
  GDEV_BEGIN_SAME_LINE = 26, 
  GDEV_END_SAME_LINE = 27, 
  GDEV_FORCE_WIDTH = 28, 
  GDEV_SET_FORMAT = 29 
};

enum GENDER
{
  MALE = 0, 
  FEMALE = 1 
};

enum IMPORT_TYPE
{
  IMPORT_STL = 0, 
  IMPORT_NASCART = 1, 
  IMPORT_CART3D_TRI = 2, 
  IMPORT_XSEC_MESH = 3, 
  IMPORT_PTS = 4, 
  IMPORT_V2 = 5, 
  IMPORT_BEM = 6, 
  IMPORT_XSEC_WIRE = 7, 
  IMPORT_P3D_WIRE = 8 
};

enum INIT_EDIT_XSEC_TYPE
{
  EDIT_XSEC_CIRCLE = 0, 
  EDIT_XSEC_ELLIPSE = 1, 
  EDIT_XSEC_RECTANGLE = 2 
};

enum INTERSECT_EXPORT_TYPE
{
  INTERSECT_SRF_FILE_NAME = 0, 
  INTERSECT_CURV_FILE_NAME = 1, 
  INTERSECT_PLOT3D_FILE_NAME = 2, 
  INTERSECT_IGES_FILE_NAME = 3, 
  INTERSECT_STEP_FILE_NAME = 4, 
  INTERSECT_NUM_FILE_NAMES = 5 
};

enum LEN_UNITS
{
  LEN_MM = 0, 
  LEN_CM = 1, 
  LEN_M = 2, 
  LEN_IN = 3, 
  LEN_FT = 4, 
  LEN_YD = 5, 
  LEN_UNITLESS = 6 
};

enum MASS_UNIT
{
  MASS_UNIT_G = 0, 
  MASS_UNIT_KG = 1, 
  MASS_UNIT_TONNE = 2, 
  MASS_UNIT_LBM = 3, 
  MASS_UNIT_SLUG = 4, 
  MASS_LBFSEC2IN = 5 
};

enum PARM_TYPE
{
  PARM_DOUBLE_TYPE = 0, 
  PARM_INT_TYPE = 1, 
  PARM_BOOL_TYPE = 2, 
  PARM_FRACTION_TYPE = 3, 
  PARM_LIMITED_INT_TYPE = 4, 
  PARM_NOTEQ_TYPE = 5 
};

enum PATCH_TYPE
{
  PATCH_NONE = 0, 
  PATCH_POINT = 1, 
  PATCH_LINE = 2, 
  PATCH_COPY = 3, 
  PATCH_HALFWAY = 4, 
  PATCH_NUM_TYPES = 5 
};

enum PCURV_TYPE
{
  LINEAR = 0, 
  PCHIP = 1, 
  CEDIT = 2, 
  APPROX_CEDIT = 3, 
  NUM_PCURV_TYPE = 4 
};

enum PRES_UNITS
{
  PRES_UNIT_PSF = 0, 
  PRES_UNIT_PSI = 1, 
  PRES_UNIT_BA = 2, 
  PRES_UNIT_PA = 3, 
  PRES_UNIT_KPA = 4, 
  PRES_UNIT_MPA = 5, 
  PRES_UNIT_INCHHG = 6, 
  PRES_UNIT_MMHG = 7, 
  PRES_UNIT_MMH20 = 8, 
  PRES_UNIT_MB = 9, 
  PRES_UNIT_ATM = 10 
};

enum PROJ_BNDY_TYPE
{
  NO_BOUNDARY = 0, 
  SET_BOUNDARY = 1, 
  GEOM_BOUNDARY = 2, 
  NUM_PROJ_BNDY_OPTIONS = 3 
};

enum PROJ_DIR_TYPE
{
  X_PROJ = 0, 
  Y_PROJ = 1, 
  Z_PROJ = 2, 
  GEOM_PROJ = 3, 
  VEC_PROJ = 4, 
  NUM_PROJ_DIR_OPTIONS = 5 
};

enum PROJ_TGT_TYPE
{
  SET_TARGET = 0, 
  GEOM_TARGET = 1, 
  NUM_PROJ_TGT_OPTIONS = 2 
};

enum PROP_MODE
{
  PROP_BLADES = 0, 
  PROP_BOTH = 1, 
  PROP_DISK = 2 
};

enum PROP_PCURVE
{
  PROP_CHORD = 0, 
  PROP_TWIST = 1, 
  PROP_RAKE = 2, 
  PROP_SKEW = 3, 
  PROP_SWEEP = 4, 
  PROP_THICK = 5, 
  PROP_CLI = 6, 
  PROP_AXIAL = 7, 
  PROP_TANGENTIAL = 8, 
  NUM_PROP_PCURVE = 9 
};

enum REF_WING_TYPE
{
  MANUAL_REF = 0, 
  COMPONENT_REF = 1, 
  NUM_REF_TYPES = 2 
};

enum RES_DATA_TYPE
{
  INVALID_TYPE = -1, 
  INT_DATA = 0, 
  DOUBLE_DATA = 1, 
  STRING_DATA = 2, 
  VEC3D_DATA = 3, 
  DOUBLE_MATRIX_DATA = 4 
};

enum RES_GEOM_TYPE
{
  MESH_INDEXED_TRI = 0, 
  MESH_SLICE_TRI = 1, 
  GEOM_XSECS = 2, 
  MESH_INDEX_AND_SLICE_TRI = 3 
};

enum RHO_UNITS
{
  RHO_UNIT_SLUG_FT3 = 0, 
  RHO_UNIT_G_CM3 = 1, 
  RHO_UNIT_KG_M3 = 2, 
  RHO_UNIT_TONNE_MM3 = 3, 
  RHO_UNIT_LBF_FT3 = 4, 
  RHO_UNIT_LBFSEC2_IN4 = 5 
};

enum SET_TYPE
{
  SET_ALL = 0, 
  SET_SHOWN = 1, 
  SET_NOT_SHOWN = 2, 
  SET_FIRST_USER = 3 
};

enum STEP_REPRESENTATION
{
  STEP_SHELL = 0, 
  STEP_BREP = 1 
};

enum SUBSURF_INCLUDE
{
  SS_INC_TREAT_AS_PARENT = 0, 
  SS_INC_SEPARATE_TREATMENT = 1, 
  SS_INC_ZERO_DRAG = 2 
};

enum SUBSURF_INOUT
{
  INSIDE = 0, 
  OUTSIDE = 1, 
  NONE = 2 
};

enum SUBSURF_LINE_TYPE
{
  CONST_U = 0, 
  CONST_W = 1 
};

enum SUBSURF_TYPE
{
  SS_LINE = 0, 
  SS_RECTANGLE = 1, 
  SS_ELLIPSE = 2, 
  SS_CONTROL = 3, 
  SS_LINE_ARRAY = 4, 
  SS_NUM_TYPES = 5 
};

enum SYM_FLAG
{
  SYM_XY = 1, 
  SYM_XZ = 2, 
  SYM_YZ = 4, 
  SYM_ROT_X = 8, 
  SYM_ROT_Y = 16, 
  SYM_ROT_Z = 32, 
  SYM_PLANAR_TYPES = 3, 
  SYM_NUM_TYPES = 6 
};

enum SYM_XSEC_TYPE
{
  SYM_NONE = 0, 
  SYM_RL = 1 
};

enum TEMP_UNITS
{
  TEMP_UNIT_K = 0, 
  TEMP_UNIT_C = 1, 
  TEMP_UNIT_F = 2, 
  TEMP_UNIT_R = 3 
};

enum VEL_UNITS
{
  V_UNIT_FT_S = 0, 
  V_UNIT_M_S = 1, 
  V_UNIT_MPH = 2, 
  V_UNIT_KM_HR = 3, 
  V_UNIT_KEAS = 4, 
  V_UNIT_KTAS = 5, 
  V_UNIT_MACH = 6 
};

enum VIEW_NUM
{
  VIEW_1 = 0, 
  VIEW_2HOR = 1, 
  VIEW_2VER = 2, 
  VIEW_4 = 3 
};

enum VIEW_ROT
{
  ROT_0 = 0, 
  ROT_90 = 1, 
  ROT_180 = 2, 
  ROT_270 = 3 
};

enum VIEW_TYPE
{
  VIEW_LEFT = 0, 
  VIEW_RIGHT = 1, 
  VIEW_TOP = 2, 
  VIEW_BOTTOM = 3, 
  VIEW_FRONT = 4, 
  VIEW_REAR = 5, 
  VIEW_NONE = 6 
};

enum VSPAERO_ANALYSIS_METHOD
{
  VORTEX_LATTICE = 0, 
  PANEL = 1 
};

enum VSPAERO_NOISE_TYPE
{
  NOISE_FLYBY = 0, 
  NOISE_FOOTPRINT = 1, 
  NOISE_STEADY = 2 
};

enum VSPAERO_NOISE_UNIT
{
  NOISE_SI = 0, 
  NOISE_ENGLISH = 1 
};

enum VSPAERO_PRECONDITION
{
  PRECON_MATRIX = 0, 
  PRECON_JACOBI = 1, 
  PRECON_SSOR = 2 
};

enum VSPAERO_STABILITY_TYPE
{
  STABILITY_OFF = 0, 
  STABILITY_DEFAULT = 1, 
  STABILITY_P_ANALYSIS = 2, 
  STABILITY_Q_ANALYSIS = 3, 
  STABILITY_R_ANALYSIS = 4 
};

enum VSP_SURF_CFD_TYPE
{
  CFD_NORMAL = 0, 
  CFD_NEGATIVE = 1, 
  CFD_TRANSPARENT = 2, 
  CFD_STRUCTURE = 3, 
  CFD_STIFFENER = 4, 
  CFD_NUM_TYPES = 5 
};

enum VSP_SURF_TYPE
{
  NORMAL_SURF = 0, 
  WING_SURF = 1, 
  DISK_SURF = 2, 
  PROP_SURF = 3, 
  NUM_SURF_TYPES = 4 
};

enum WING_BLEND
{
  BLEND_FREE = 0, 
  BLEND_ANGLES = 1, 
  BLEND_MATCH_IN_LE_TRAP = 2, 
  BLEND_MATCH_IN_TE_TRAP = 3, 
  BLEND_MATCH_OUT_LE_TRAP = 4, 
  BLEND_MATCH_OUT_TE_TRAP = 5, 
  BLEND_MATCH_IN_ANGLES = 6, 
  BLEND_MATCH_LE_ANGLES = 7, 
  BLEND_NUM_TYPES = 8 
};

enum WING_DRIVERS
{
  AR_WSECT_DRIVER = 0, 
  SPAN_WSECT_DRIVER = 1, 
  AREA_WSECT_DRIVER = 2, 
  TAPER_WSECT_DRIVER = 3, 
  AVEC_WSECT_DRIVER = 4, 
  ROOTC_WSECT_DRIVER = 5, 
  TIPC_WSECT_DRIVER = 6, 
  SECSWEEP_WSECT_DRIVER = 7, 
  NUM_WSECT_DRIVER = 8, 
  SWEEP_WSECT_DRIVER = 8, 
  SWEEPLOC_WSECT_DRIVER = 9, 
  SECSWEEPLOC_WSECT_DRIVER = 10 
};

enum XDDM_QUANTITY_TYPE
{
  XDDM_VAR = 0, 
  XDDM_CONST = 1 
};

enum XSEC_CLOSE_TYPE
{
  CLOSE_NONE = 0, 
  CLOSE_SKEWLOW = 1, 
  CLOSE_SKEWUP = 2, 
  CLOSE_SKEWBOTH = 3, 
  CLOSE_EXTRAP = 4, 
  CLOSE_NUM_TYPES = 5 
};

enum XSEC_CRV_TYPE
{
  XS_UNDEFINED = -1, 
  XS_POINT = 0, 
  XS_CIRCLE = 1, 
  XS_ELLIPSE = 2, 
  XS_SUPER_ELLIPSE = 3, 
  XS_ROUNDED_RECTANGLE = 4, 
  XS_GENERAL_FUSE = 5, 
  XS_FILE_FUSE = 6, 
  XS_FOUR_SERIES = 7, 
  XS_SIX_SERIES = 8, 
  XS_BICONVEX = 9, 
  XS_WEDGE = 10, 
  XS_EDIT_CURVE = 11, 
  XS_FILE_AIRFOIL = 12, 
  XS_CST_AIRFOIL = 13, 
  XS_VKT_AIRFOIL = 14, 
  XS_FOUR_DIGIT_MOD = 15, 
  XS_FIVE_DIGIT = 16, 
  XS_FIVE_DIGIT_MOD = 17, 
  XS_ONE_SIX_SERIES = 18, 
  XS_NUM_TYPES = 19 
};

enum XSEC_SIDES_TYPE
{
  XSEC_BOTH_SIDES = 0, 
  XSEC_LEFT_SIDE = 1, 
  XSEC_RIGHT_SIDE = 2 
};

enum XSEC_TRIM_TYPE
{
  TRIM_NONE = 0, 
  TRIM_X = 1, 
  TRIM_THICK = 2, 
  TRIM_NUM_TYPES = 3 
};

enum XSEC_TYPE
{
  XSEC_FUSE = 0, 
  XSEC_STACK = 1, 
  XSEC_WING = 2, 
  XSEC_CUSTOM = 3, 
  XSEC_PROP = 4, 
  XSEC_NUM_TYPES = 5 
};

enum XSEC_WIDTH_SHIFT
{
  XS_SHIFT_LE = 0, 
  XS_SHIFT_MID = 1, 
  XS_SHIFT_TE = 2 
};

string formatInt(int64 val, const string&in options = "", uint width = 0);
string formatUInt(uint64 val, const string&in options = "", uint width = 0);
string formatFloat(double val, const string&in options = "", uint width = 0, uint precision = 0);
int64 parseInt(const string&in, uint base = 10, uint&out byteCount = 0);
uint64 parseUInt(const string&in, uint base = 10, uint&out byteCount = 0);
double parseFloat(const string&in, uint&out byteCount = 0);
string join(const string[]&in, const string&in);
float fpFromIEEE(uint);
uint fpToIEEE(float);
double fpFromIEEE(uint64);
uint64 fpToIEEE(double);
bool closeTo(float, float, float = 0.00001f);
bool closeTo(double, double, double = 0.0000000001);
float cos(float);
float sin(float);
float tan(float);
float acos(float);
float asin(float);
float atan(float);
float atan2(float, float);
float cosh(float);
float sinh(float);
float tanh(float);
float log(float);
float log10(float);
float pow(float, float);
float sqrt(float);
float ceil(float);
float abs(float);
float floor(float);
float fraction(float);

double dist(const vec3d&in a, const vec3d&in b);

double dist_squared(const vec3d&in a, const vec3d&in b);

double dot(const vec3d&in a, const vec3d&in b);

vec3d cross(const vec3d&in a, const vec3d&in b);

double angle(const vec3d&in a, const vec3d&in b);

double signed_angle(const vec3d&in a, const vec3d&in b, const vec3d&in ref);

double cos_angle(const vec3d&in a, const vec3d&in b);

vec3d RotateArbAxis(const vec3d&in p, double theta, const vec3d&in axis);

string AddParm(int type, const string&in name, const string&in group);

string GetCurrCustomGeom();

string GetCustomParm(int index);

int AddGui(int type, const string&in label = string ( ), const string&in parm_name = string ( ), const string&in group_name = string ( ), double range = 10.0);

void UpdateGui(int gui_id, const string&in parm_id);

string AddXSecSurf();

void RemoveXSecSurf(const string&in xsec_id);

void ClearXSecSurfs();

void SkinXSecSurf(bool closed_flag = false);

void CloneSurf(int index, Matrix4d&in mat);

void TransformSurf(int index, Matrix4d&in mat);

void SetVspSurfType(int type, int surf_index = - 1);

void SetVspSurfCfdType(int type, int surf_index = - 1);

void SetCustomXSecLoc(const string&in xsec_id, const vec3d&in loc);

vec3d GetCustomXSecLoc(const string&in xsec_id);

void SetCustomXSecRot(const string&in xsec_id, const vec3d&in rot);

vec3d GetCustomXSecRot(const string&in xsec_id);

bool CheckClearTriggerEvent(int gui_id);

void SetupCustomDefaultSource(int type, int surf_index, double l1, double r1, double u1, double w1, double l2 = 0, double r2 = 0, double u2 = 0, double w2 = 0);

void ClearAllCustomDefaultSources();

void SetCustomCenter(double x, double y, double z);

string AppendXSec(const string&in xsec_surf_id, int type);

string AppendCustomXSec(const string&in xsec_surf_id, int type);

void CutCustomXSec(const string&in xsec_surf_id, int index);

void CopyCustomXSec(const string&in xsec_surf_id, int index);

void PasteCustomXSec(const string&in xsec_surf_id, int index);

string InsertCustomXSec(const string&in xsec_surf_id, int type, int index);

void AddInput(const string&in parm_id, const string&in var_name);

void AddOutput(const string&in parm_id, const string&in var_name);

void SetVar(const string&in var_name, double val);

double GetVar(const string&in var_name);

bool GetErrorLastCallFlag();

int GetNumTotalErrors();

ErrorObj PopLastError();

ErrorObj GetLastError();

void SilenceErrors();

void PrintOnErrors();

void ScreenGrab(const string&in file_name, int w, int h, bool transparentBG);

void SetViewAxis(bool vaxis);

void SetShowBorders(bool brdr);

void SetGeomDrawType(const string&in geom_id, int type);

void SetGeomDisplayType(const string&in geom_id, int type);

void SetBackground(double r, double g, double b);

void Update();

void VSPExit(int error_code);

void ClearVSPModel();

string GetVSPFileName();

void ReadVSPFile(const string&in file_name);

void WriteVSPFile(const string&in file_name, int set);

void SetVSP3FileName(const string&in file_name);

void InsertVSPFile(const string&in file_name, const string&in parent);

void ExportFile(const string&in file_name, int write_set_index, int file_type);

string ImportFile(const string&in file_name, int file_type, const string&in parent);

void ReadApplyDESFile(const string&in file_name);

void WriteDESFile(const string&in file_name);

void ReadApplyXDDMFile(const string&in file_name);

void WriteXDDMFile(const string&in file_name);

int GetNumDesignVars();

void AddDesignVar(const string&in parm_id, int type);

void DeleteAllDesignVars();

string GetDesignVar(int index);

int GetDesignVarType(int index);

string ComputeMassProps(int set, int num_slices);

string ComputeCompGeom(int set, bool half_mesh, int file_export_types);

string ComputePlaneSlice(int set, int num_slices, const vec3d&in norm, bool auto_bnd, double start_bnd = 0, double end_bnd = 0);

void ComputeDegenGeom(int set, int file_type);

void SetComputationFileName(int file_type, const string&in file_name);

void ComputeCFDMesh(int set, int file_type);

void SetCFDMeshVal(int type, double val);

void SetCFDWakeFlag(const string&in geom_id, bool flag);

void DeleteAllCFDSources();

void AddDefaultSources();

void AddCFDSource(int type, const string&in 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);

int GetNumAnalysis();

string[]@ ListAnalysis();

string[]@ GetAnalysisInputNames(const string&in analysis);

string ExecAnalysis(const string&in analysis);

int GetNumAnalysisInputData(const string&in analysis, const string&in name);

int GetAnalysisInputType(const string&in analysis, const string&in name);

int[]@ GetIntAnalysisInput(const string&in analysis, const string&in name, int index = 0);

double[]@ GetDoubleAnalysisInput(const string&in analysis, const string&in name, int index = 0);

string[]@ GetStringAnalysisInput(const string&in analysis, const string&in name, int index = 0);

vec3d[]@ GetVec3dAnalysisInput(const string&in analysis, const string&in name, int index = 0);

void PrintAnalysisInputs(const string&in analysis);

void SetAnalysisInputDefaults(const string&in analysis);

void SetIntAnalysisInput(const string&in analysis, const string&in name, int[]@ indata_arr, int index = 0);

void SetDoubleAnalysisInput(const string&in analysis, const string&in name, double[]@ indata_arr, int index = 0);

void SetStringAnalysisInput(const string&in analysis, const string&in name, string[]@ indata_arr, int index = 0);

void SetVec3dAnalysisInput(const string&in analysis, const string&in name, vec3d[]@ indata_arr, int index = 0);

int GetNumResults(const string&in name);

string GetResultsName(const string&in results_id);

string FindResultsID(const string&in name, int index = 0);

string FindLatestResultsID(const string&in name);

int GetNumData(const string&in results_id, const string&in data_name);

int GetResultsType(const string&in results_id, const string&in data_name);

string[]@ GetAllResultsNames();

string[]@ GetAllDataNames(const string&in results_id);

int[]@ GetIntResults(const string&in id, const string&in name, int index = 0);

double[]@ GetDoubleResults(const string&in id, const string&in name, int index = 0);

double[]@[]@ GetDoubleMatResults(const string&in id, const string&in name, int index = 0);

string[]@ GetStringResults(const string&in id, const string&in name, int index = 0);

vec3d[]@ GetVec3dResults(const string&in id, const string&in name, int index = 0);

string CreateGeomResults(const string&in geom_id, const string&in name);

void DeleteAllResults();

void DeleteResult(const string&in id);

void WriteResultsCSVFile(const string&in id, const string&in file_name);

void PrintResults(const string&in id);

void WriteTestResults();

string[]@ GetGeomTypes();

string AddGeom(const string&in type, const string&in parent = string ( ));

void UpdateGeom(const string&in geom_id);

void DeleteGeom(const string&in geom_id);

void DeleteGeomVec(string[]@ del_arr);

void CutGeomToClipboard(const string&in geom_id);

void CopyGeomToClipboard(const string&in geom_id);

string[]@ PasteGeomClipboard(const string&in parent_id = "");

string[]@ FindGeoms();

string[]@ FindGeomsWithName(const string&in name);

string FindGeom(const string&in name, int index);

void SetGeomName(const string&in geom_id, const string&in name);

string GetGeomName(const string&in geom_id);

string[]@ GetGeomParmIDs(const string&in geom_id);

int GetGeomVSPSurfCfdType(const string&in geom_id, int main_surf_ind = 0);

int GetGeomVSPSurfType(const string&in geom_id, int main_surf_ind = 0);

string GetGeomTypeName(const string&in geom_id);

int GetNumMainSurfs(const string&in geom_id);

int GetTotalNumSurfs(const string&in geom_id);

vec3d GetGeomBBoxMax(const string&in geom_id, int main_surf_ind = 0, bool ref_frame_is_absolute = true);

vec3d GetGeomBBoxMin(const string&in geom_id, int main_surf_ind = 0, bool ref_frame_is_absolute = true);

string GetGeomParent(const string&in geom_id);

string[]@ GetGeomChildren(const string&in geom_id);

string AddSubSurf(const string&in geom_id, int type, int surfindex = 0);

void DeleteSubSurf(const string&in geom_id, const string&in sub_id);

void DeleteSubSurf(const string&in sub_id);

string GetSubSurf(const string&in geom_id, int index);

string[]@ GetSubSurf(const string&in geom_id, const string&in name);

void SetSubSurfName(const string&in geom_id, const string&in sub_id, const string&in name);

void SetSubSurfName(const string&in sub_id, const string&in name);

string GetSubSurfName(const string&in geom_id, const string&in sub_id);

string GetSubSurfName(const string&in sub_id);

int GetSubSurfIndex(const string&in sub_id);

string[]@ GetSubSurfIDVec(const string&in geom_id);

string[]@ GetAllSubSurfIDs();

int GetNumSubSurf(const string&in geom_id);

int GetSubSurfType(const string&in sub_id);

string[]@ GetSubSurfParmIDs(const string&in sub_id);

void AutoGroupVSPAEROControlSurfaces();

int GetNumControlSurfaceGroups();

int CreateVSPAEROControlSurfaceGroup();

void AddAllToVSPAEROControlSurfaceGroup(int CSGroupIndex);

void RemoveAllFromVSPAEROControlSurfaceGroup(int CSGroupIndex);

string[]@ GetActiveCSNameVec(int CSGroupIndex);

string[]@ GetCompleteCSNameVec();

string[]@ GetAvailableCSNameVec(int CSGroupIndex);

void SetVSPAEROControlGroupName(const string&in name, int CSGroupIndex);

string GetVSPAEROControlGroupName(int CSGroupIndex);

void AddSelectedToCSGroup(int[]@ selected, int CSGroupIndex);

void RemoveSelectedFromCSGroup(int[]@ selected, int CSGroupIndex);

string GetVSPAERORefWingID();

string SetVSPAERORefWingID(const string&in geom_id);

string FindActuatorDisk(int disk_index);

int GetNumActuatorDisks();

string FindUnsteadyGroup(int group_index);

string GetUnsteadyGroupName(int group_index);

string[]@ GetUnsteadyGroupCompIDs(int group_index);

int[]@ GetUnsteadyGroupSurfIndexes(int group_index);

int GetNumUnsteadyGroups();

void SetDriverGroup(const string&in geom_id, int section_index, int driver_0, int driver_1, int driver_2);

int GetNumXSecSurfs(const string&in geom_id);

string GetXSecSurf(const string&in geom_id, int index);

int GetNumXSec(const string&in xsec_surf_id);

string GetXSec(const string&in xsec_surf_id, int xsec_index);

void ChangeXSecShape(const string&in xsec_surf_id, int xsec_index, int type);

void SetXSecSurfGlobalXForm(const string&in xsec_surf_id, const Matrix4d&in mat);

Matrix4d GetXSecSurfGlobalXForm(const string&in xsec_surf_id);

void CutXSec(const string&in geom_id, int index);

void CopyXSec(const string&in geom_id, int index);

void PasteXSec(const string&in geom_id, int index);

void InsertXSec(const string&in geom_id, int index, int type);

int GetXSecShape(const string&in xsec_id);

double GetXSecWidth(const string&in xsec_id);

double GetXSecHeight(const string&in xsec_id);

void SetXSecWidth(const string&in xsec_id, double w);

void SetXSecHeight(const string&in xsec_id, double h);

void SetXSecWidthHeight(const string&in xsec_id, double w, double h);

string[]@ GetXSecParmIDs(const string&in xsec_id);

string GetXSecParm(const string&in xsec_id, const string&in name);

vec3d[]@ ReadFileXSec(const string&in xsec_id, const string&in file_name);

void SetXSecPnts(const string&in xsec_id, vec3d[]@ pnt_arr);

vec3d ComputeXSecPnt(const string&in xsec_id, double fract);

vec3d ComputeXSecTan(const string&in xsec_id, double fract);

void ResetXSecSkinParms(const string&in xsec_id);

void SetXSecContinuity(const string&in xsec_id, int cx);

void SetXSecTanAngles(const string&in xsec_id, int side, double top, double right = - 1.0e12, double bottom = - 1.0e12, double left = - 1.0e12);

void SetXSecTanSlews(const string&in xsec_id, int side, double top, double right = - 1.0e12, double bottom = - 1.0e12, double left = - 1.0e12);

void SetXSecTanStrengths(const string&in xsec_id, int side, double top, double right = - 1.0e12, double bottom = - 1.0e12, double left = - 1.0e12);

void SetXSecCurvatures(const string&in xsec_id, int side, double top, double right = - 1.0e12, double bottom = - 1.0e12, double left = - 1.0e12);

void ReadFileAirfoil(const string&in xsec_id, const string&in file_name);

void SetAirfoilPnts(const string&in xsec_id, vec3d[]@ up_pnt_vec, vec3d[]@ low_pnt_vec);

vec3d[]@ GetHersheyBarLiftDist(const int&in npts, const double&in alpha, const double&in Vinf, const double&in span, bool full_span_flag = false);

vec3d[]@ GetHersheyBarDragDist(const int&in npts, const double&in alpha, const double&in Vinf, const double&in span, bool full_span_flag = false);

vec3d[]@ GetVKTAirfoilPnts(const int&in npts, const double&in alpha, const double&in epsilon, const double&in kappa, const double&in tau);

double[]@ GetVKTAirfoilCpDist(const double&in alpha, const double&in epsilon, const double&in kappa, const double&in tau, vec3d[]@ xydata);

vec3d[]@ GetEllipsoidSurfPnts(const vec3d&in center, const vec3d&in abc_rad, int u_npts = 20, int w_npts = 20);

vec3d[]@ GetFeatureLinePnts(const string&in geom_id);

double[]@ GetEllipsoidCpDist(vec3d[]@ surf_pnt_arr, const vec3d&in abc_rad, const vec3d&in V_inf);

vec3d[]@ GetAirfoilUpperPnts(const string&in xsec_id);

vec3d[]@ GetAirfoilLowerPnts(const string&in xsec_id);

double[]@ GetUpperCSTCoefs(const string&in xsec_id);

double[]@ GetLowerCSTCoefs(const string&in xsec_id);

int GetUpperCSTDegree(const string&in xsec_id);

int GetLowerCSTDegree(const string&in xsec_id);

void SetUpperCST(const string&in xsec_id, int deg, double[]@ coeff_arr);

void SetLowerCST(const string&in xsec_id, int deg, double[]@ coeff_arr);

void PromoteCSTUpper(const string&in xsec_id);

void PromoteCSTLower(const string&in xsec_id);

void DemoteCSTUpper(const string&in xsec_id);

void DemoteCSTLower(const string&in xsec_id);

void FitAfCST(const string&in xsec_surf_id, int xsec_index, int deg);

void WriteBezierAirfoil(const string&in file_name, const string&in geom_id, const double&in foilsurf_u);

void WriteSeligAirfoil(const string&in file_name, const string&in geom_id, const double&in foilsurf_u);

vec3d[]@ GetAirfoilCoordinates(const string&in geom_id, const double&in foilsurf_u);

void EditXSecInitShape(const string&in xsec_id);

void EditXSecConvertTo(const string&in xsec_id, const int&in newtype);

double[]@ GetEditXSecUVec(const string&in xsec_id);

vec3d[]@ GetEditXSecCtrlVec(const string&in xsec_id, const bool non_dimensional = true);

void SetEditXSecPnts(const string&in xsec_id, double[]@ u_vec, vec3d[]@ control_pts);

void EditXSecDelPnt(const string&in xsec_id, const int&in indx);

int EditXSecSplit01(const string&in xsec_id, const double&in u);

void MoveEditXSecPnt(const string&in xsec_id, const int&in indx, const vec3d&in new_pnt);

void ConvertXSecToEdit(const string&in geom_id, const int&in indx = 0);

void ChangeBORXSecShape(const string&in geom_id, int type);

int GetBORXSecShape(const string&in geom_id);

int GetNumSets();

void SetSetName(int index, const string&in name);

string GetSetName(int index);

string[]@ GetGeomSetAtIndex(int index);

string[]@ GetGeomSet(const string&in name);

int GetSetIndex(const string&in name);

bool GetSetFlag(const string&in geom_id, int set_index);

void SetSetFlag(const string&in geom_id, int set_index, bool flag);

void CopyPasteSet(int copyIndex, int pasteIndex);

void ScaleSet(int set_index, double scale);

void RotateSet(int set_index, double x_rot_deg, double y_rot_deg, double z_rot_deg);

void TranslateSet(int set_index, const vec3d&in translation_vec);

void TransformSet(int set_index, const vec3d&in translation_vec, double x_rot_deg, double y_rot_deg, double z_rot_deg, double scale, bool scale_translations_flag);

bool ValidParm(const string&in id);

double SetParmVal(const string&in parm_id, double val);

double SetParmValLimits(const string&in parm_id, double val, double lower_limit, double upper_limit);

double SetParmValUpdate(const string&in parm_id, double val);

double SetParmVal(const string&in geom_id, const string&in name, const string&in group, double val);

double SetParmValUpdate(const string&in geom_id, const string&in parm_name, const string&in parm_group_name, double val);

double GetParmVal(const string&in parm_id);

double GetParmVal(const string&in geom_id, const string&in name, const string&in group);

int GetIntParmVal(const string&in parm_id);

bool GetBoolParmVal(const string&in parm_id);

void SetParmUpperLimit(const string&in parm_id, double val);

double GetParmUpperLimit(const string&in parm_id);

void SetParmLowerLimit(const string&in parm_id, double val);

double GetParmLowerLimit(const string&in parm_id);

int GetParmType(const string&in parm_id);

string GetParmName(const string&in parm_id);

string GetParmGroupName(const string&in parm_id);

string GetParmDisplayGroupName(const string&in parm_id);

string GetParmContainer(const string&in parm_id);

void SetParmDescript(const string&in parm_id, const string&in desc);

string FindParm(const string&in parm_container_id, const string&in parm_name, const string&in group_name);

string GetParm(const string&in geom_id, const string&in name, const string&in group);

string[]@ FindContainers();

string[]@ FindContainersWithName(const string&in name);

string FindContainer(const string&in name, int index);

string GetContainerName(const string&in parm_container_id);

string[]@ FindContainerGroupNames(const string&in parm_container_id);

string[]@ FindContainerParmIDs(const string&in parm_container_id);

double ComputeMinClearanceDistance(const string&in geom_id, int set);

double SnapParm(const string&in parm_id, double target_min_dist, bool inc_flag, int set);

void AddVarPresetGroup(const string&in group_name);

void AddVarPresetSetting(const string&in setting_name);

void AddVarPresetParm(const string&in parm_ID);

void AddVarPresetParm(const string&in parm_ID, const string&in group_name);

void EditVarPresetParm(const string&in parm_ID, double parm_val);

void EditVarPresetParm(const string&in parm_ID, double parm_val, const string&in group_name, const string&in setting_name);

void DeleteVarPresetParm(const string&in parm_ID);

void DeleteVarPresetParm(const string&in parm_ID, const string&in group_name);

void SwitchVarPreset(const string&in group_name, const string&in setting_name);

bool DeleteVarPresetSet(const string&in group_name, const string&in setting_name);

string GetCurrentGroupName();

string GetCurrentSettingName();

string[]@ GetVarPresetGroupNames();

string[]@ GetVarPresetSettingNamesWName(const string&in group_name);

string[]@ GetVarPresetSettingNamesWIndex(int group_index);

double[]@ GetVarPresetParmVals();

double[]@ GetVarPresetParmValsWNames(const string&in group_name, const string&in setting_name);

string[]@ GetVarPresetParmIDs();

string[]@ GetVarPresetParmIDsWName(const string&in group_name);

void SetPCurve(const string&in geom_id, const int&in pcurveid, double[]@ tvec, double[]@ valvec, const int&in newtype);

void PCurveConvertTo(const string&in geom_id, const int&in pcurveid, const int&in newtype);

int PCurveGetType(const string&in geom_id, const int&in pcurveid);

double[]@ PCurveGetTVec(const string&in geom_id, const int&in pcurveid);

double[]@ PCurveGetValVec(const string&in geom_id, const int&in pcurveid);

void PCurveDeletePt(const string&in geom_id, const int&in pcurveid, const int&in indx);

int PCurveSplit(const string&in geom_id, const int&in pcurveid, const double&in tsplit);

void AddExcrescence(const string&in excresName, const int&in excresType, const double&in excresVal);

void DeleteExcrescence(const int&in excresName);

void UpdateParasiteDrag();

void WriteAtmosphereCSVFile(const string&in file_name, const int&in atmos_type);

void CalcAtmosphere(const double&in alt, const double&in delta_temp, const int&in atmos_type, double&out temp, double&out pres, double&out pres_ratio, double&out rho_ratio);

void WriteBodyFFCSVFile(const string&in file_name);

void WriteWingFFCSVFile(const string&in file_name);

void WriteCfEqnCSVFile(const string&in file_name);

void WritePartialCfMethodCSVFile(const string&in file_name);

vec3d CompPnt01(const string&in geom_id, const int&in surf_indx, const double&in u, const double&in w);

vec3d CompNorm01(const string&in geom_id, const int&in surf_indx, const double&in u, const double&in w);

vec3d CompTanU01(const string&in geom_id, const int&in surf_indx, const double&in u, const double&in w);

vec3d CompTanW01(const string&in geom_id, const int&in surf_indx, const double&in u, const double&in w);

void CompCurvature01(const string&in geom_id, const int&in surf_indx, const double&in u, const double&in w, double&out k1, double&out k2, double&out ka, double&out kg);

double ProjPnt01(const string&in geom_id, const int&in surf_indx, const vec3d&in pt, double&out u, double&out w);

double ProjPnt01I(const string&in geom_id, const vec3d&in pt, int&out surf_indx, double&out u, double&out w);

double ProjPnt01Guess(const string&in geom_id, const int&in surf_indx, const vec3d&in pt, const double&in u0, const double&in w0, double&out u, double&out w);

void GetUWTess01(const string&in geom_id, int&in surf_indx, double[]@ us, double[]@ ws);

vec3d[]@ CompVecPnt01(const string&in geom_id, const int&in surf_indx, double[]@ us, double[]@ ws);

vec3d[]@ CompVecNorm01(const string&in geom_id, const int&in surf_indx, double[]@ us, double[]@ ws);

void CompVecCurvature01(const string&in geom_id, const int&in surf_indx, double[]@ us, double[]@ ws, double[]@ k1s, double[]@ k2s, double[]@ kas, double[]@ kgs);

void ProjVecPnt01(const string&in geom_id, int&in surf_indx, vec3d[]@ pts, double[]@ us, double[]@ ws, double[]@ ds);

void ProjVecPnt01Guess(const string&in geom_id, int&in surf_indx, vec3d[]@ pts, double[]@ u0s, double[]@ w0s, double[]@ us, double[]@ ws, double[]@ ds);

string AddRuler(const string&in startgeomid, int startsurfindx, double startu, double startw, const string&in endgeomid, int endsurfindx, double endu, double endw, const string&in name);

string[]@ GetAllRulers();

void DelRuler(const string&in id);

void DeleteAllRulers();

string AddProbe(const string&in geomid, int surfindx, double u, double w, const string&in name);

string[]@ GetAllProbes();

void DelProbe(const string&in id);

void DeleteAllProbes();

int AddFeaStruct(const string&in geom_id, bool init_skin = true, int surfindex = 0);

void DeleteFeaStruct(const string&in geom_id, int fea_struct_ind);

string GetFeaStructID(const string&in geom_id, int fea_struct_ind);

int GetFeaStructIndex(const string&in struct_id);

string GetFeaStructParentGeomID(const string&in struct_id);

string GetFeaStructName(const string&in geom_id, int fea_struct_ind);

void SetFeaStructName(const string&in geom_id, int fea_struct_ind, const string&in name);

string[]@ GetFeaStructIDVec();

void SetFeaPartName(const string&in part_id, const string&in name);

void SetFeaMeshVal(const string&in geom_id, int fea_struct_ind, int type, double val);

void SetFeaMeshFileName(const string&in geom_id, int fea_struct_id, int file_type, const string&in file_name);

void ComputeFeaMesh(const string&in geom_id, int fea_struct_ind, int file_type);

void ComputeFeaMesh(const string&in struct_id, int file_type);

string AddFeaPart(const string&in geom_id, int fea_struct_ind, int type);

void DeleteFeaPart(const string&in geom_id, int fea_struct_ind, const string&in part_id);

string GetFeaPartID(const string&in fea_struct_id, int fea_part_index);

string GetFeaPartName(const string&in part_id);

int GetFeaPartType(const string&in part_id);

int GetFeaSubSurfIndex(const string&in ss_id);

int NumFeaStructures();

int NumFeaParts(const string&in fea_struct_id);

int NumFeaSubSurfs(const string&in fea_struct_id);

string[]@ GetFeaPartIDVec(const string&in fea_struct_id);

string[]@ GetFeaSubSurfIDVec(const string&in fea_struct_id);

void SetFeaPartPerpendicularSparID(const string&in part_id, const string&in perpendicular_spar_id);

string GetFeaPartPerpendicularSparID(const string&in part_id);

string AddFeaSubSurf(const string&in geom_id, int fea_struct_ind, int type);

void DeleteFeaSubSurf(const string&in geom_id, int fea_struct_ind, const string&in ss_id);

string AddFeaMaterial();

string AddFeaProperty(int property_type = 0);

void Print(const string&in data, bool new_line = true);

void Print(const vec3d&in data, bool new_line = true);

void Print(double data, bool new_line = true);

void Print(int data, bool new_line = true);

double Min(double x, double y);

double Max(double x, double y);

double Rad2Deg(double r);

double Deg2Rad(double d);

string GetVSPVersion();

string GetVSPExePath();

void VSPCheckSetup();

void VSPRenew();

vec3d[]@ GetProxyVec3dArray();