/// <summary>
/// Select elements in the user interface.
/// </summary>
public static int SelectViews(out int[] viewTags)
{
unsafe
{
int *viewTags_ptr;
long viewTags_n = 0;
var index = Gmsh_Warp.GmshFltkSelectViews(&viewTags_ptr, ref viewTags_n, ref Gmsh._staticreff);
viewTags = UnsafeHelp.ToIntArray(viewTags_ptr, viewTags_n);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
return(index);
}
}
/// <summary>
/// Split the model curve of tag `tag' on the control points `pointTags'.
/// Return the tags `curveTags' of the newly created curves.
/// </summary>
public static int[] SplitCurve(int tag, int[] pointTags)
{
unsafe
{
int *pointTags_ptr;
long pointTags_n = 0;
Gmsh_Warp.GmshModelGeoSplitCurve(tag, pointTags, pointTags.LongLength, &pointTags_ptr, ref pointTags_n, ref Gmsh._staticreff);
var curveTags = UnsafeHelp.ToIntArray(pointTags_ptr, pointTags_n);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
return(curveTags);
}
}
/// <summary>
/// Get all the entities in the current model. If `dim' is >= 0, return only the
/// entities of the specified dimension (e.g. points if `dim' == 0). The
/// entities are returned as a vector of (dim, tag) integer pairs.
/// </summary>
public static ValueTuple <int, int>[] GetEntities(int dim = -1)
{
unsafe
{
int *dimTags_ptr;
long dimTags_n = 0;
Gmsh_Warp.GmshModelGetEntities(&dimTags_ptr, ref dimTags_n, dim, ref Gmsh._staticreff);
var array = UnsafeHelp.ToIntArray(dimTags_ptr, dimTags_n);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
return(array.ToIntPair());
}
}
/// <summary>
/// Select entities in the user interface. If `dim' is >= 0, return only the
/// entities of the specified dimension (e.g. points if `dim' == 0).
/// </summary>
public static int SelectEntities(out ValueTuple <int, int>[] dimTags, int dim = -1)
{
unsafe
{
int *dimTags_ptr;
long dimTags_n = 0;
var index = Gmsh_Warp.GmshFltkSelectEntities(&dimTags_ptr, ref dimTags_n, dim, ref Gmsh._staticreff);
dimTags = UnsafeHelp.ToIntArray(dimTags_ptr, dimTags_n).ToIntPair();
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
return(index);
}
}
/// <summary>
/// In a partitioned model, return the tags of the partition(s) to which the
/// entity belongs.
/// </summary>
public static int[] GetPartitions(int dim, int tag)
{
unsafe
{
int *partitions_ptr;
long partitions_n = default;
Gmsh_Warp.GmshModelGetPartitions(dim, tag, &partitions_ptr, ref partitions_n, ref Gmsh._staticreff);
var partitions = UnsafeHelp.ToIntArray(partitions_ptr, partitions_n);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
return(partitions);
}
}
/// <summary>
/// Get the model entities in the bounding box defined by the two points
/// (`xmin', `ymin', `zmin') and (`xmax', `ymax', `zmax'). If `dim' is >= 0,
/// return only the entities of the specified dimension (e.g. points if `dim' ==
/// 0).
/// </summary>
public static ValueTuple <int, int>[] GetEntitiesInBoundingBox(double xmin, double ymin, double zmin, double xmax, double ymax, double zmax, int dim = -1)
{
unsafe
{
int *tags_ptr;
long tags_n = 0;
Gmsh_Warp.GmshModelGetEntitiesInBoundingBox(xmin, ymin, zmin, xmax, ymax, zmax, &tags_ptr, ref tags_n, dim, ref Gmsh._staticreff);
var pairs = UnsafeHelp.ToIntArray(tags_ptr, tags_n);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
return(pairs.ToIntPair());
}
}
/// <summary>
/// Get the tags of the physical groups (if any) to which the model entity of
/// dimension `dim' and tag `tag' belongs.
/// </summary>
public static int[] GetPhysicalGroupsForEntity(int dim, int tag)
{
unsafe
{
int *physicalTagsptr;
long physicalTags_n = default;
Gmsh_Warp.GmshModelGetPhysicalGroupsForEntity(dim, tag, &physicalTagsptr, ref physicalTags_n, ref Gmsh._staticreff);
var physicalTags = UnsafeHelp.ToIntArray(physicalTagsptr, physicalTags_n);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
return(physicalTags);
}
}
/// <summary>
/// Copy the entities `dimTags'; the new entities are returned in
/// `outDimTags'.
/// </summary>
public static void Copy(ValueTuple <int, int>[] dimTags, out ValueTuple <int, int>[] outDimTags)
{
long outcount = 0;
var list = dimTags.ToIntArray();
unsafe
{
int *ptrss;
Gmsh_Warp.GmshModelGeoCopy(list, list.LongLength, &ptrss, ref outcount, ref Gmsh._staticreff);
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
var outDimTagsint = UnsafeHelp.ToIntArray(ptrss, outcount);
outDimTags = outDimTagsint.ToIntPair();
}
}
/// <summary>
/// Get the boundary of the model entities `dimTags'. Return in `outDimTags' the
/// boundary of the individual entities (if `combined' is false) or the boundary
/// of the combined geometrical shape formed by all input entities (if
/// `combined' is true). Return tags multiplied by the sign of the boundary
/// entity if `oriented' is true. Apply the boundary operator recursively down
/// to dimension 0 (i.e. to points) if `recursive' is true.
/// </summary>
public static ValueTuple <int, int>[] GetBoundary(ValueTuple <int, int>[] dimTags, bool combined = true, bool oriented = true, bool recursive = false)
{
unsafe
{
int *outDimTagsptr;
long outdimTags_n = 0;
var dimarray = dimTags.ToIntArray();
Gmsh_Warp.GmshModelGetBoundary(dimarray, dimarray.LongLength, &outDimTagsptr, ref outdimTags_n, Convert.ToInt32(combined), Convert.ToInt32(oriented), Convert.ToInt32(recursive), ref Gmsh._staticreff);
var array = UnsafeHelp.ToIntArray(outDimTagsptr, outdimTags_n);
var outDimTags = array.ToIntPair();
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
return(outDimTags);
}
}
/// <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>
/// Extrude the model entities `dimTags' by a combined translation and
/// rotation of `angle' radians, along (`dx', `dy', `dz') and 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 Twist(ValueTuple <int, int>[] dimTags, double x, double y, double z, double dx, double dy, double dz, 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.GmshModelGeoTwist(dimarray, dimarray.LongLength, x, y, z, dx, dy, dz, ax, ay, az, angle, &ptrss, ref outcount, numElements, numElements.LongLength, heights, heights.LongLength, Convert.ToInt32(recombine), ref Gmsh._staticreff);
var array = UnsafeHelp.ToIntArray(ptrss, outcount);
outDimTags = array.ToIntPair();
Gmsh.CheckException(MethodBase.GetCurrentMethod().MethodHandle);
}
}
