/// <summary>
/// Extrude the model entities `dimTags' by translation along (`dx', `dy',
/// `dz'). Return extruded entities in `outDimTags'. If `numElements' is not
/// empty, also extrude the mesh: the entries in `numElements' give the number
/// of elements in each layer. If `height' is not empty, it provides the
/// (cumulative) height of the different layers, normalized to 1. If `dx' ==
/// `dy' == `dz' == 0, the entities are extruded along their normal.
/// </summary>
public static void Extrude(ValueTuple <int, int>[] dimTags, double dx, double dy, double dz, out ValueTuple <int, int>[] outDimTags, int[] numElements = default, double[] heights = default, bool recombine = false)
{
var dimarray = dimTags.ToIntArray();
unsafe
{
int *ptrss;
long outcount = 0;
if (numElements == default)
{
numElements = new int[0];
}
if (heights == default)
{
heights = new double[0];
}
Gmsh_Warp.GmshModelGeoExtrude(dimarray, dimarray.LongLength, dx, dy, dz, &ptrss, ref outcount, numElements, numElements.LongLength, heights, heights.LongLength, Convert.ToInt32(recombine), ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
var outDimTagsint = UnsafeHelp.ToIntArray(ptrss, outcount);
outDimTags = outDimTagsint.ToIntPair();
}
}
/// <summary>
/// Extrude the model entities `dimTags' by rotation of `angle' radians around
/// the axis of revolution defined by the point (`x', `y', `z') and the
/// direction (`ax', `ay', `az'). The angle should be strictly smaller than
/// Pi. Return extruded entities in `outDimTags'. If `numElements' is not
/// empty, also extrude the mesh: the entries in `numElements' give the number
/// of elements in each layer. If `height' is not empty, it provides the
/// (cumulative) height of the different layers, normalized to 1.
/// </summary>
public static void Revolve(ValueTuple <int, int>[] dimTags, double x, double y, double z, double ax, double ay, double az, double angle, out ValueTuple <int, int>[] outDimTags, int[] numElements = default, double[] heights = default, bool recombine = false)
{
var dimarray = dimTags.ToIntArray();
unsafe
{
int *ptrss;
long outcount = 0;
if (numElements == default)
{
numElements = new int[0];
}
if (heights == default)
{
heights = new double[0];
}
Gmsh_Warp.GmshModelGeoRevolve(dimarray, dimarray.LongLength, x, y, z, ax, ay, az, angle, &ptrss, ref outcount, numElements, numElements.LongLength, heights, heights.LongLength, Convert.ToInt32(recombine), ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
var outDimTagsint = new int[outcount];
Marshal.Copy(new IntPtr(ptrss), outDimTagsint, 0, outDimTagsint.Length);
outDimTags = outDimTagsint.ToIntPair();
}
}
/// <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);
}
}
/// <summary>
/// Set one or more parameters in the ONELAB database, encoded in `format'.
/// </summary>
public static void Set(string data, string format = "json")
{
Gmsh_Warp.GmshOnelabSet(data, format, ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Write a file. The export format is determined by the file extension.
/// </summary>
public static void Write(string fileName)
{
Gmsh_Warp.GmshWrite(fileName, ref _staticreff);
CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Synchronize the built-in CAD representation with the current Gmsh model.
/// This can be called at any time, but since it involves a non trivial amount
/// of processing, the number of synchronization points should normally be
/// minimized.
/// </summary>
public static void Synchronize()
{
Gmsh_Warp.GmshModelGeoSynchronize(ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Remove all duplicate entities (different entities at the same geometrical
/// location).
/// </summary>
public static void RemoveAllDuplicates()
{
Gmsh_Warp.GmshModelGeoRemoveAllDuplicates(ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Set a recombination meshing constraint on the model entity of dimension
/// `dim' and tag `tag'. Currently only entities of dimension 2 (to
/// recombine triangles into quadrangles) are supported.
/// </summary>
public static void SetRecombine(int dim, int tag, double angle = 45)
{
Gmsh_Warp.GmshModelGeoMeshSetRecombine(dim, tag, angle, ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Set a reverse meshing constraint on the model entity of dimension `dim'
/// and tag `tag'. If `val' is true, the mesh orientation will be reversed
/// with respect to the natural mesh orientation (i.e. the orientation
/// consistent with the orientation of the geometry). If `val' is false, the
/// mesh is left as-is.
/// </summary>
public static void SetReverse(int dim, int tag, bool val = true)
{
Gmsh_Warp.GmshModelGeoMeshSetReverse(dim, tag, Convert.ToInt32(val), ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Write the view to a file `fileName'. The export format is determined by the
/// file extension. Append to the file if `append' is set.
/// </summary>
public static void Write(int tag, string fileName, bool append = true)
{
Gmsh_Warp.GmshViewWrite(tag, fileName, Convert.ToInt32(append), ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Combine elements (if `what' == "elements") or steps (if `what' == "steps")
/// of all views (`how' == "all"), all visible views (`how' == "visible") or all
/// views having the same name (`how' == "name"). Remove original views if
/// `remove' is set.
/// </summary>
public static void Combine(string what, string how, bool remove = true, bool copyOptions = true)
{
Gmsh_Warp.GmshViewCombine(what, how, Convert.ToInt32(remove), Convert.ToInt32(copyOptions), ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Copy the options from the view with tag `refTag' to the view with tag `tag'.
/// </summary>
public static void CopyOptions(int refTag, int tag)
{
Gmsh_Warp.GmshViewCopyOptions(refTag, tag, ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Add a post-processing view as an `alias' of the reference view with tag
/// `refTag'. If `copyOptions' is set, copy the options of the reference view.
/// 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 void AddAlias(int refTag, bool copyOptions = false, int tag = -1)
{
Gmsh_Warp.GmshViewAddAlias(refTag, Convert.ToInt32(copyOptions), tag, ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Add list-based post-processing data to the view with tag `tag'. List-based
/// datasets are independent from any model and any mesh. `dataType' identifies
/// the data by concatenating the field type ("S" for scalar, "V" for vector,
/// "T" for tensor) and the element type ("P" for point, "L" for line, "T" for
/// triangle, "S" for tetrahedron, "I" for prism, "H" for hexaHedron, "Y" for
/// pyramid). For example `dataType' should be "ST" for a scalar field on
/// triangles. `numEle' gives the number of elements in the data. `data'
/// contains the data for the `numEle' elements, concatenated, with node
/// coordinates followed by values per node, repeated for each step: [e1x1, ...,
/// e1xn, e1y1, ..., e1yn, e1z1, ..., e1zn, e1v1..., e1vN, e2x1, ...].
/// </summary>
public static void AddListData(int tag, string dataType, int numEle, double[] data)
{
Gmsh_Warp.GmshViewAddListData(tag, dataType, numEle, data, data.LongLength, ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Set the value of the number parameter `name' in the ONELAB database. Create
/// the parameter if it does not exist; update the value if the parameter
/// exists.
/// </summary>
public static void SetNumber(string name, double[] value)
{
Gmsh_Warp.GmshOnelabSetNumber(name, value, value.LongLength, ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Set the numerical list option `option' to value `value' for field `tag'.
/// </summary>
public static void SetNumbers(int tag, string option, double[] value)
{
Gmsh_Warp.GmshModelMeshFieldSetNumbers(tag, option, value, value.LongLength, ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Set the field `tag' as a boundary layer size field.
/// </summary>
public static void SetAsBoundaryLayer(int tag)
{
Gmsh_Warp.GmshModelMeshFieldSetAsBoundaryLayer(tag, ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Get the index of the view with tag `tag' in the list of currently loaded
/// views. This dynamic index (it can change when views are removed) is used to
/// access view options.
/// </summary>
public static void GetIndex(int tag)
{
Gmsh_Warp.GmshViewGetIndex(tag, ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Set a transfinite meshing constraint on the curve `tag', with `numNodes'
/// nodes distributed according to `meshType' and `coef'. Currently
/// supported types are "Progression" (geometrical progression with power
/// `coef') and "Bump" (refinement toward both extremities of the curve).
/// </summary>
public static void SetTransfiniteCurve(int tag, int nPoints, string meshType = "Progression", double coef = 1)
{
Gmsh_Warp.GmshModelGeoMeshSetTransfiniteCurve(tag, nPoints, meshType, coef, ref Gmsh._staticreff);
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 AddHomogeneousModelData(int tag, int step, string modelName, string dataType, long[] tags, double[] data, double time = 0, int numComponents = -1, int partition = 0)
{
Gmsh_Warp.GmshViewAddHomogeneousModelData(tag, step, modelName, dataType, tags, tags.LongLength, data, data.LongLength, time, numComponents, partition, ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Set a smoothing meshing constraint on the model entity of dimension
/// `dim' and tag `tag'. `val' iterations of a Laplace smoother are applied.
/// </summary>
public static void SetSmoothing(int dim, int tag, int val)
{
Gmsh_Warp.GmshModelGeoMeshSetSmoothing(dim, tag, val, ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Wait at most `time' seconds for user interface events and return. If `time'
/// < 0, wait indefinitely. First automatically create the user interface if it
/// has not yet been initialized. Can only be called in the main thread.
/// </summary>
public static void Wait(double time = -1)
{
Gmsh_Warp.GmshFltkWait(time, ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Awake the main user interface thread and process pending events, and
/// optionally perform an action (currently the only `action' allowed is
/// "update").
/// </summary>
public static void Awake(string action = "")
{
Gmsh_Warp.GmshFltkAwake(action, ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Run the event loop of the graphical user interface, i.e. repeatedly call
/// `wait()'. First automatically create the user interface if it has not yet
/// been initialized. Can only be called in the main thread.
/// </summary>
public static void Run()
{
Gmsh_Warp.GmshFltkRun(ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Set the maximum tag `maxTag' for entities of dimension `dim' in the built-
/// in CAD representation.
/// </summary>
public static void SetMaxTag(int dim, int maxTag)
{
Gmsh_Warp.GmshModelGeoSetMaxTag(dim, maxTag, ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Remove the field with tag `tag'.
/// </summary>
public static void Remove(int tag)
{
Gmsh_Warp.GmshModelMeshFieldRemove(tag, ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
#pragma warning disable CS0465
/// <summary>
/// Finalize Gmsh. This must be called when you are done using the Gmsh API.
/// </summary>
public static void Finalize()
#pragma warning restore CS0465 // 引入 "Finalize" 方法可能会妨碍析构函数调用
{
Gmsh_Warp.GmshFinalize(ref _staticreff);
CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Set the string option `option' to value `value' for field `tag'.
/// </summary>
public static void SetString(int tag, string option, string value)
{
Gmsh_Warp.GmshModelMeshFieldSetString(tag, option, value, ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Clear all loaded models and post-processing data, and add a new empty model.
/// </summary>
public static void Clear()
{
Gmsh_Warp.GmshClear(ref _staticreff);
CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
/// <summary>
/// Run a ONELAB client. If `name' is provided, create a new ONELAB client with
/// name `name' and executes `command'. If not, try to run a client that might
/// be linked to the processed input files.
/// </summary>
public static void Run(string name, string command = "")
{
Gmsh_Warp.GmshOnelabRun(name, command, ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
