/// <summary> /// Evaluate the principal curvatures of the surface with tag `tag' at the /// parametric coordinates `parametricCoord', as well as their respective /// directions. `parametricCoord' are given by pair of u and v coordinates, /// concatenated: [p1u, p1v, p2u, ...]. /// </summary> public static void GetPrincipalCurvatures(int dim, double[] parametricCoord, out double[] curvatureMax, out double[] curvatureMin, out double[] directionMax, out double[] directionMin) { unsafe { double *curvatureMax_ptr; long curvatureMax_n = 0; double *curvatureMin_ptr; long curvatureMin_n = 0; double *directionMax_ptr; long directionMax_n = 0; double *directionMin_ptr; long directionMin_n = 0; Gmsh_Warp.GmshModelGetPrincipalCurvatures(dim, parametricCoord, parametricCoord.LongLength, &curvatureMax_ptr, ref curvatureMax_n, &curvatureMin_ptr, ref curvatureMin_n, &directionMax_ptr, ref directionMax_n, &directionMin_ptr, ref directionMin_n, ref Gmsh._staticreff); curvatureMax = UnsafeHelp.ToDoubleArray(curvatureMax_ptr, curvatureMax_n); curvatureMin = UnsafeHelp.ToDoubleArray(curvatureMin_ptr, curvatureMin_n); directionMax = UnsafeHelp.ToDoubleArray(directionMax_ptr, directionMax_n); directionMin = UnsafeHelp.ToDoubleArray(directionMin_ptr, directionMin_n); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); } }
/// <summary> /// Get the value of the number parameter `name' from the ONELAB database. /// Return an empty vector if the parameter does not exist. /// </summary> public static double[] GetNumber(string name) { unsafe { double *value_ptr; long value_n = 0; Gmsh_Warp.GmshOnelabGetNumber(name, &value_ptr, ref value_n, ref Gmsh._staticreff); var value = UnsafeHelp.ToDoubleArray(value_ptr, value_n); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); return(value); } }
/// <summary> /// Reparametrize the boundary entity (point or curve, i.e. with `dim' == 0 or /// `dim' == 1) of tag `tag' on the surface `surfaceTag'. If `dim' == 1, /// reparametrize all the points corresponding to the parametric coordinates /// `parametricCoord'. Multiple matches in case of periodic surfaces can be /// selected with `which'. This feature is only available for a subset of /// entities, depending on the underyling geometrical representation. /// </summary> public static void ReparametrizeOnSurface(int dim, int tag, double[] parametricCoord, int surfaceTag, out double[] surfaceParametricCoord, int which = 0) { unsafe { double *surfaceParametricCoord_ptr; long surfaceParametricCoord_n = 0; Gmsh_Warp.GmshModelReparametrizeOnSurface(dim, tag, parametricCoord, parametricCoord.LongLength, surfaceTag, &surfaceParametricCoord_ptr, ref surfaceParametricCoord_n, which, ref Gmsh._staticreff); surfaceParametricCoord = UnsafeHelp.ToDoubleArray(surfaceParametricCoord_ptr, surfaceParametricCoord_n); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); } }
/// <summary> /// Get the parametric coordinates `parametricCoord' for the points `coord' on /// the entity of dimension `dim' and tag `tag'. `coord' are given as triplets /// of x, y, z coordinates, concatenated: [p1x, p1y, p1z, p2x, ...]. /// `parametricCoord' returns the parametric coordinates t on the curve (if /// `dim' = 1) or pairs of u and v coordinates concatenated on the surface (if /// `dim' = 2), i.e. [p1t, p2t, ...] or [p1u, p1v, p2u, ...]. /// </summary> public static double[] GetParametrization(int dim, int tag, double[] coord) { unsafe { double *ptr; long outcount = 0; Gmsh_Warp.GmshModelGetParametrization(dim, tag, coord, coord.LongLength, &ptr, ref outcount, ref Gmsh._staticreff); var parametricCoord = UnsafeHelp.ToDoubleArray(ptr, outcount); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); return(parametricCoord); } }
/// <summary> /// Get the normal to the surface with tag `tag' at the parametric coordinates /// `parametricCoord'. `parametricCoord' are given by pairs of u and v /// coordinates, concatenated: [p1u, p1v, p2u, ...]. `normals' are returned as /// triplets of x, y, z components, concatenated: [n1x, n1y, n1z, n2x, ...]. /// </summary> public static double[] GetNormal(int tag, double[] parametricCoord) { unsafe { double *ptr; long outcount = 0; Gmsh_Warp.GmshModelGetNormal(tag, parametricCoord, parametricCoord.LongLength, &ptr, ref outcount, ref Gmsh._staticreff); var normals = UnsafeHelp.ToDoubleArray(ptr, outcount); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); return(normals); } }
/// <summary> /// Get the points `closestCoord' on the entity of dimension `dim' and tag `tag' /// to the points `coord', by orthogonal projection. `coord' and `closestCoord' /// are given as triplets of x, y, z coordinates, concatenated: [p1x, p1y, p1z, /// p2x, ...]. `parametricCoord' returns the parametric coordinates t on the /// curve (if `dim' = 1) or pairs of u and v coordinates concatenated on the /// surface (if `dim' = 2), i.e. [p1t, p2t, ...] or [p1u, p1v, p2u, ...]. /// </summary> public static void GetClosestPoint(int dim, int tag, double[] coord, out double[] closestCoord, out double[] parametricCoord) { unsafe { double *closestCoord_ptr; long closestCoord_n = 0; double *parametricCoord_ptr; long parametricCoord_n = 0; Gmsh_Warp.GmshModelGetClosestPoint(dim, tag, coord, coord.LongLength, &closestCoord_ptr, ref closestCoord_n, ¶metricCoord_ptr, ref parametricCoord_n, ref Gmsh._staticreff); closestCoord = UnsafeHelp.ToDoubleArray(closestCoord_ptr, closestCoord_n); parametricCoord = UnsafeHelp.ToDoubleArray(parametricCoord_ptr, parametricCoord_n); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); } }
/// <summary> /// Get the `min' and `max' bounds of the parametric coordinates for the entity /// of dimension `dim' and tag `tag'. /// </summary> public static void GetParametrizationBounds(int dim, int tag, out double[] min, out double[] max) { unsafe { double *min_ptr; long min_n = 0; double *max_ptr; long max_n = 0; Gmsh_Warp.GmshModelGetParametrizationBounds(dim, tag, &min_ptr, ref min_n, &max_ptr, ref max_n, ref Gmsh._staticreff); min = UnsafeHelp.ToDoubleArray(min_ptr, min_n); max = UnsafeHelp.ToDoubleArray(max_ptr, max_n); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); } }
/// <summary> /// Get list-based post-processing data strings (2D strings if `dim' = 2, 3D /// strings if `dim' = 3) from the view with tag `tag'. Return the coordinates /// in `coord', the strings in `data' and the styles in `style'. /// </summary> public static void GetListDataStrings(int tag, int dim, out double[] coord, out string[] data, out string[] style) { unsafe { double *coord_ptr; long coord_n = 0; byte ** data_ptr; long data_n = 0; byte ** style_ptr; long style_n = 0; Gmsh_Warp.GmshViewGetListDataStrings(tag, dim, &coord_ptr, ref coord_n, &data_ptr, ref data_n, &style_ptr, ref style_n, ref Gmsh._staticreff); coord = UnsafeHelp.ToDoubleArray(coord_ptr, coord_n); data = UnsafeHelp.ToString(data_ptr, data_n); style = UnsafeHelp.ToString(style_ptr, style_n); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); } }
/// <summary> /// Add homogeneous model-based post-processing data to the view with tag `tag'. /// The arguments have the same meaning as in `addModelData', except that `data' /// is supposed to be homogeneous and is thus flattened in a single vector. For /// data types that can lead to different data sizes per tag (like /// "ElementNodeData"), the data should be padded. /// </summary> public static void GetListData(int tag, out string[] dataType, out int[] numElements, out double[][] data) { unsafe { byte ** dataType_ptr; long dataType_n = 0; int * numElements_ptr; long numElements_n = 0; double **data_ptr; long * data_n_ptr; long data_nn = 0; Gmsh_Warp.GmshViewGetListData(tag, &dataType_ptr, ref dataType_n, &numElements_ptr, ref numElements_n, &data_ptr, &data_n_ptr, ref data_nn, ref Gmsh._staticreff); dataType = UnsafeHelp.ToString(dataType_ptr, dataType_n); numElements = UnsafeHelp.ToIntArray(numElements_ptr, numElements_n); data = UnsafeHelp.ToDoubleArray(data_ptr, data_n_ptr, data_nn); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); } }
/// <summary> /// Add homogeneous model-based post-processing data to the view with tag `tag'. /// The arguments have the same meaning as in `addModelData', except that `data' /// is supposed to be homogeneous and is thus flattened in a single vector. For /// data types that can lead to different data sizes per tag (like /// "ElementNodeData"), the data should be padded. /// </summary> public static void GetModelData(int tag, int step, out string dataType, out long[] tags, out double[][] data, out double time, out int numComponents) { unsafe { byte * dataType_ptr; long * tags_ptr; long tags_n = 0; double **data_ptr; long * data_n_ptr; long data_nn = 0; time = 0; numComponents = 0; Gmsh_Warp.GmshViewGetModelData(tag, step, &dataType_ptr, &tags_ptr, ref tags_n, &data_ptr, &data_n_ptr, ref data_nn, ref time, ref numComponents, ref Gmsh._staticreff); dataType = UnsafeHelp.ToString(dataType_ptr); tags = UnsafeHelp.ToLongArray(tags_ptr, tags_n); data = UnsafeHelp.ToDoubleArray(data_ptr, data_n_ptr, data_nn); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); } }
/// <summary> /// Probe the view `tag' for its `value' at point (`x', `y', `z'). Return only /// the value at step `step' is `step' is positive. Return only values with /// `numComp' if `numComp' is positive. Return the gradient of the `value' if /// `gradient' is set. Probes with a geometrical tolerance (in the reference /// unit cube) of `tolerance' if `tolerance' is not zero. Return the result from /// the element described by its coordinates if `xElementCoord', `yElementCoord' /// and `zElementCoord' are provided. /// </summary> public static double[] Probe(int tag, double x, double y, double z, int step = -1, int numComp = -1, bool gradient = false, double tolerance = 0, double[] xElemCoord = default, double[] yElemCoord = default, double[] zElemCoord = default) { unsafe { double *value_ptr; long value_n = 0; if (xElemCoord == default) { xElemCoord = new double[0]; } if (yElemCoord == default) { yElemCoord = new double[0]; } if (zElemCoord == default) { zElemCoord = new double[0]; } Gmsh_Warp.GmshViewProbe(tag, x, y, z, &value_ptr, ref value_n, step, numComp, Convert.ToInt32(gradient), tolerance, xElemCoord, xElemCoord.LongLength, yElemCoord, yElemCoord.LongLength, zElemCoord, zElemCoord.LongLength, ref Gmsh._staticreff); var value = UnsafeHelp.ToDoubleArray(value_ptr, value_n); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); return(value); } }