/// <summary> /// Add a physical group of dimension `dim', grouping the model entities with /// tags `tags'. Return the tag of the physical group, equal to `tag' if `tag' /// is positive, or a new tag if `tag' < 0. /// </summary> public static int AddPhysicalGroup(int dim, int[] tags, int tag = -1) { var index = Gmsh_Warp.GmshModelAddPhysicalGroup(dim, tags, tags.LongLength, tag, ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); return(index); }
/// <summary> /// Get the geometrical dimension of the current model. /// </summary> public static int GetDimension() { var index = Gmsh_Warp.GmshModelGetDimension(ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); return(index); }
/// <summary> /// Return CPU time. /// </summary> public static double GetCpuTime() { var time = Gmsh_Warp.GmshLoggerGetCpuTime(ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); return(time); }
/// <summary> /// Add a new mesh size field of type `fieldType'. If `tag' is positive, /// assign the tag explicitly; otherwise a new tag is assigned /// automatically. Return the field tag. /// </summary> public static int Add(string fieldType, int tag = -1) { var index = Gmsh_Warp.GmshModelMeshFieldAdd(fieldType, tag, ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); return(index); }
/// <summary> /// Add a cubic b-spline curve with `pointTags' control points. If `tag' is /// positive, set the tag explicitly; otherwise a new tag is selected /// automatically. Creates a periodic curve if the first and last points are /// the same. Return the tag of the b-spline curve. /// </summary> public static int AddBSpline(int[] pointTags, int tag = -1) { var index = Gmsh_Warp.GmshModelGeoAddBSpline(pointTags, pointTags.LongLength, tag, ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); return(index); }
/// <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> /// Check if the parametric coordinates provided in `parametricCoord' correspond /// to points inside the entitiy of dimension `dim' and tag `tag', and return /// the number of points inside. This feature is only available for a subset of /// curves and surfaces, depending on the underyling geometrical representation. /// </summary> public static int IsInside(int dim, int tag, double[] parametricCoord) { var index = Gmsh_Warp.GmshModelIsInside(dim, tag, parametricCoord, parametricCoord.LongLength, ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); return(index); }
/// <summary> /// In a partitioned model, get the parent of the entity of dimension `dim' and /// tag `tag', i.e. from which the entity is a part of, if any. `parentDim' and /// `parentTag' are set to -1 if the entity has no parent. /// </summary> public static void GetParent(int dim, int tag, out int parentDim, out int parentTag) { parentDim = default; parentTag = default; Gmsh_Warp.GmshModelGetParent(dim, tag, ref parentDim, ref parentTag, ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); }
/// <summary> /// Set a mesh size constraint on the model entities `dimTags'. Currently /// only entities of dimension 0 (points) are handled. /// </summary> public static void SetSize(ValueTuple <int, int>[] dimTags, double size) { var list = dimTags.ToIntArray(); Gmsh_Warp.GmshModelGeoMeshSetSize(list, list.LongLength, size, ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); }
/// <summary> /// Get the maximum tag of entities of dimension `dim' in the built-in CAD /// representation. /// </summary> public static int GetMaxTag(int dim) { var index = Gmsh_Warp.GmshModelGeoGetMaxTag(dim, ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); return(index); }
/// <summary> /// Add a straight line segment between the two points with tags `startTag' /// and `endTag'. If `tag' is positive, set the tag explicitly; otherwise a /// new tag is selected automatically. Return the tag of the line. /// </summary> public static int AddLine(int startTag, int endTag, int tag = -1) { var index = Gmsh_Warp.GmshModelGeoAddLine(startTag, endTag, tag, ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); return(index); }
public static void Dilate(ValueTuple <int, int>[] dimTags, double x, double y, double z, double a, double b, double c) { var list = dimTags.ToIntArray(); Gmsh_Warp.GmshModelGeoDilate(list, list.LongLength, x, y, z, a, b, c, ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); }
/// <summary> /// Add a geometrical point in the built-in CAD representation, at coordinates /// (`x', `y', `z'). If `meshSize' is > 0, add a meshing constraint at that /// point. If `tag' is positive, set the tag explicitly; otherwise a new tag /// is selected automatically. Return the tag of the point. (Note that the /// point will be added in the current model only after `synchronize' is /// called. This behavior holds for all the entities added in the geo module.) /// </summary> public static int AddPoint(double x, double y, double z, double meshsize = 0, int tag = -1) { var index = Gmsh_Warp.GmshModelGeoAddPoint(x, y, z, meshsize, tag, ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); return(index); }
/// <summary> /// Translate the model entities `dimTags' along (`dx', `dy', `dz'). /// </summary> public static void Translate(ValueTuple <int, int>[] dimTags, double dx, double dy, double dz) { var list = dimTags.ToIntArray(); Gmsh_Warp.GmshModelGeoTranslate(list, list.LongLength, dx, dy, dz, ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); }
/// <summary> /// Set the color of the model entities `dimTags' to the RGBA value (`r', `g', /// `b', `a'), where `r', `g', `b' and `a' should be integers between 0 and 255. /// Apply the color setting recursively if `recursive' is true. /// </summary> public static void SetColor(ValueTuple <int, int>[] dimTags, int r, int g, int b, int a = 255, bool recursive = false) { var dimarray = dimTags.ToIntArray(); Gmsh_Warp.GmshModelSetColor(dimarray, dimarray.LongLength, r, g, b, a, Convert.ToInt32(recursive), ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); }
/// <summary> /// Add a surface loop (a closed shell) formed by `surfaceTags'. If `tag' is /// positive, set the tag explicitly; otherwise a new tag is selected /// automatically. Return the tag of the shell. /// </summary> public static int AddSurfaceLoop(int[] surfaceTags, int tag = -1) { var index = Gmsh_Warp.GmshModelGeoAddSurfaceLoop(surfaceTags, surfaceTags.LongLength, tag, ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); return(index); }
/// <summary> /// Remove the physical groups `dimTags' of the current model. If `dimTags' is /// empty, remove all groups. /// </summary> public static void RemovePhysicalGroups(ValueTuple <int, int>[] dimTags) { var dimTags_array = dimTags.ToIntArray(); Gmsh_Warp.GmshModelRemovePhysicalGroups(dimTags_array, dimTags_array.LongLength, ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); }
/// <summary> /// Add a b-spline with control points sampling the curves in `curveTags'. The /// density of sampling points on each curve is governed by `numIntervals'. If /// `tag' is positive, set the tag explicitly; otherwise a new tag is selected /// automatically. Return the tag of the b-spline. /// </summary> public static int AddCompoundBSpline(int[] curveTags, int numIntervals = 20, int tag = -1) { var index = Gmsh_Warp.GmshModelGeoAddCompoundBSpline(curveTags, curveTags.LongLength, numIntervals, tag, ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); return(index); }
/// <summary> /// Check if the user interface is available (e.g. to detect if it has been /// closed). /// </summary> public static int IsAvailable() { var index = Gmsh_Warp.GmshFltkIsAvailable(ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); return(index); }
/// <summary> /// Add an ellipse arc (strictly smaller than Pi) between the two points /// `startTag' and `endTag', with center `centerTag' and major axis point /// `majorTag'. If `tag' is positive, set the tag explicitly; otherwise a new /// tag is selected automatically. If (`nx', `ny', `nz') != (0, 0, 0), /// explicitly set the plane of the circle arc. Return the tag of the ellipse /// arc. /// </summary> public static int AddEllipseArc(int startTag, int centerTag, int majorTag, int endTag, int tag = -1, double nx = 0, double ny = 0, double nz = 0) { var index = Gmsh_Warp.GmshModelGeoAddEllipseArc(startTag, centerTag, majorTag, endTag, tag, nx, ny, nz, ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); return(index); }
/// <summary> /// Remove the entities `dimTags'. If `recursive' is true, remove all the /// entities on their boundaries, down to dimension 0. /// </summary> public static void Remove(ValueTuple <int, int>[] dimTags, bool recursive = false) { var dimarray = dimTags.ToIntArray(); Gmsh_Warp.GmshModelGeoRemove(dimarray, dimarray.LongLength, Convert.ToInt32(recursive), ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); }
/// <summary> // Add a new post-processing view, with name `name'. If `tag' is positive use // it (and remove the view with that tag if it already exists), otherwise // associate a new tag. Return the view tag. /// </summary> public static int Add(string name, int tag = -1) { var index = Gmsh_Warp.GmshViewAdd(name, tag, ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); return(index); }
/// <summary> /// Mirror the model entities `dimTag', with respect to the plane of equation /// `a' * x + `b' * y + `c' * z + `d' = 0. (This is a synonym for `mirror', /// which will be deprecated in a future release.) /// </summary> public static void Symmetrize(ValueTuple <int, int>[] dimTags, double a, double b, double c, double d) { var list = dimTags.ToIntArray(); Gmsh_Warp.GmshModelGeoSymmetrize(list, list.LongLength, a, b, c, d, ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); }
/// <summary> /// Add a surface filling the curve loops in `wireTags'. Currently only a /// single curve loop is supported; this curve loop should be composed by 3 or /// 4 curves only. If `tag' is positive, set the tag explicitly; otherwise a /// new tag is selected automatically. Return the tag of the surface. /// </summary> public static int AddSurfaceFilling(int[] wireTags, int tag = -1, int sphereCenterTag = -1) { var index = Gmsh_Warp.GmshModelGeoAddSurfaceFilling(wireTags, wireTags.LongLength, tag, sphereCenterTag, ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); return(index); }
public void Dispose() { if (!_finalize) { Gmsh.Finalize(); _finalize = true; } }
/// <summary> /// Get the `value' of a numerical option. `name' is of the form /// "category.option" or "category[num].option". Available categories and /// options are listed in the Gmsh reference manual. /// </summary> public static double GetNumber(string name) { var value = 0.0; Gmsh_Warp.GmshOptionGetNumber(name, ref value, ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); return(value); }
/// <summary> /// Get the visibility of the model entity of dimension `dim' and tag `tag'. /// </summary> public static int GetVisibility(int dim, int tag) { int value = 0; Gmsh_Warp.GmshModelGetVisibility(dim, tag, ref value, ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); return(value); }
/// <summary> /// Add model-based post-processing data to the view with tag `tag'. `modelName' /// identifies the model the data is attached to. `dataType' specifies the type /// of data, currently either "NodeData", "ElementData" or "ElementNodeData". /// `step' specifies the identifier (>= 0) of the data in a sequence. `tags' /// gives the tags of the nodes or elements in the mesh to which the data is /// associated. `data' is a vector of the same length as `tags': each entry is /// the vector of double precision numbers representing the data associated with /// the corresponding tag. The optional `time' argument associate a time value /// with the data. `numComponents' gives the number of data components (1 for /// scalar data, 3 for vector data, etc.) per entity; if negative, it is /// automatically inferred (when possible) from the input data. `partition' /// allows to specify data in several sub-sets. /// </summary> public static void AddModelData(int tag, int step, string modelName, string dataType, long[] tags, double[][] data, double time = 0, int numComponents = -1, int partition = 0) { unsafe { var ptr = Marshal.UnsafeAddrOfPinnedArrayElement(data, 0); Gmsh_Warp.GmshViewAddModelData(tag, step, modelName, dataType, tags, tags.LongLength, (double **)ptr.ToPointer(), data.Select(d => d.LongLength).ToArray(), data.LongLength, time, numComponents, partition, ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); } }
/// <summary> /// Set a transfinite meshing constraint on the surface `tag'. `cornerTags' /// can be used to specify the (6 or 8) corners of the transfinite /// interpolation explicitly. /// </summary> public static void SetTransfiniteVolume(int tag, int[] cornerTags = default) { if (cornerTags == default) { cornerTags = new int[0]; } Gmsh_Warp.GmshModelGeoMeshSetTransfiniteVolume(tag, cornerTags, cornerTags.LongLength, ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); }
/// <summary> /// Add a discrete model entity (defined by a mesh) of dimension `dim' in the /// current model. Return the tag of the new discrete entity, equal to `tag' if /// `tag' is positive, or a new tag if `tag' < 0. `boundary' specifies the tags /// of the entities on the boundary of the discrete entity, if any. Specifying /// `boundary' allows Gmsh to construct the topology of the overall model. /// </summary> public static void AddDiscreteEntity(int dim, int tag, int[] boundary = default) { if (boundary == default) { boundary = new int[0]; } Gmsh_Warp.GmshModelAddDiscreteEntity(dim, tag, boundary, boundary.LongLength, ref Gmsh._staticreff); Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle); }