/// <summary>
/// Read the mesh from the provided mesh file
/// </summary>
public static MeshFile ReadMesh(string filename)
{
if (!File.Exists(filename))
{
throw new FileNotFoundException("File not found", filename);
}
var file = new MeshFile();
file.Read(filename);
return(file);
}
/// <summary>
/// Convert a <see cref="SMeshData"/> class into a <see cref="MeshFile"/> class.
/// </summary>
public static MeshFile ToMeshFile(this SMeshData meshData)
{
return(MeshFile.Create(
meshData.ZUnit,
meshData.Projection,
meshData.NodeIds,
meshData.X,
meshData.Y, meshData.Z,
meshData.Code,
meshData.ElementIds,
meshData.ElementType,
meshData.ElementTable.ToOneBased()));
}
/// <summary>
/// Convert a <see cref="MeshData"/> class into a <see cref="MeshFile"/> class.
/// </summary>
public static MeshFile ToMeshFile(this MeshData meshData)
{
int numberOfNodes = meshData.Nodes.Count;
int[] nodeId = new int[numberOfNodes];
double[] x = new double[numberOfNodes];
double[] y = new double[numberOfNodes];
double[] z = new double[numberOfNodes];
int[] code = new int[numberOfNodes];
for (int i = 0; i < numberOfNodes; i++)
{
MeshNode node = meshData.Nodes[i];
nodeId[i] = node.Id;
x[i] = node.X;
y[i] = node.Y;
z[i] = node.Z;
code[i] = node.Code;
}
int numberOfElements = meshData.Elements.Count;
int[] elmtId = new int[numberOfElements];
int[][] elmtTable = new int[numberOfElements][];
for (int i = 0; i < numberOfElements; i++)
{
MeshElement elmt = meshData.Elements[i];
elmtId[i] = elmt.Id;
int[] elmtNodes = new int[elmt.Nodes.Count];
elmtTable[i] = elmtNodes;
for (int j = 0; j < elmt.Nodes.Count; j++)
{
elmtNodes[j] = elmt.Nodes[j].Index + 1;
}
}
MeshFileBuilder builder = new MeshFileBuilder();
builder.SetProjection(meshData.Projection);
builder.SetZUnit(meshData.ZUnit);
builder.SetNodeIds(nodeId);
builder.SetNodes(x, y, z, code);
builder.SetElementIds(elmtId);
builder.SetElements(elmtTable);
MeshFile meshFile = builder.CreateMesh();
return(meshFile);
}
internal static MeshFile Create(MeshUnit zUnit, string wktString, int[] nodeIds, double[] x, double[] y, double[] z, int[] nodeCode, int[] elmtIds, int[] elmtTypes, int[][] connectivity)
{
MeshFile res = new MeshFile();
res._zUnit = zUnit;
res._wktString = wktString;
res._nodeIds = nodeIds;
res._x = x;
res._y = y;
res._z = z;
res._code = nodeCode;
res._elementIds = elmtIds;
res._elementType = elmtTypes;
res._connectivity = connectivity;
for (int i = 0; i < connectivity.Length; i++)
{
if (connectivity[i].Length == 4)
{
res._hasQuads = true;
break;
}
}
return(res);
}
/// <summary>
/// Create and return a new <see cref="MeshFile"/> object
/// </summary>
public MeshFile CreateMesh()
{
Validate(true);
// Creating default eumQuantity in meters
_zUnit = MeshUnit.Meter;
// Creating default node id's, if empty
if (_nodeIds == null)
{
// Setting node ids 1,2,3,...
_nodeIds = new int[_x.Length];
for (int i = 0; i < _x.Length; i++)
{
_nodeIds[i] = i + 1;
}
}
// Creating default element id's, if empty
if (_elementIds == null)
{
// Setting element ids 1,2,3,...
_elementIds = new int[_connectivity.Length];
for (int i = 0; i < _connectivity.Length; i++)
{
_elementIds[i] = i + 1;
}
}
// Creating additional element information
int[] elementType = new int[_connectivity.Length];
int[] nodesPerElmt = new int[_connectivity.Length];
int nodeElmtCount = 0; // total number of nodes listed in the connectivity table
for (int i = 0; i < elementType.Length; i++)
{
int elmtTypeNumber;
int[] elmt = _connectivity[i];
switch (elmt.Length)
{
case 3:
elmtTypeNumber = 21;
break;
case 4:
elmtTypeNumber = 25;
break;
case 6:
elmtTypeNumber = 32;
break;
case 8:
elmtTypeNumber = 33;
break;
default:
// this should have been caught in the validate phase, but just in case:
throw new Exception("Element with invalid number of nodes encountered");
}
elementType[i] = elmtTypeNumber;
nodesPerElmt[i] = elmt.Length;
nodeElmtCount += elmt.Length;
}
int[] connectivityArray = new int[nodeElmtCount];
int k = 0;
for (int i = 0; i < elementType.Length; i++)
{
int[] elmt = _connectivity[i];
for (int j = 0; j < elmt.Length; j++)
{
connectivityArray[k++] = elmt[j];
}
}
MeshFile res = MeshFile.Create(_zUnit, _projection, _nodeIds, _x, _y, _z, _code, _elementIds, elementType, _connectivity);
return(res);
}
/// <summary>
/// Convert a <see cref="MeshFile"/> class into a <see cref="SMeshData"/> class.
/// </summary>
public static SMeshData ToSMeshData(this MeshFile file)
{
return(new SMeshData(file.Projection, file.NodeIds, file.X, file.Y, file.Z, file.Code, file.ElementIds, file.ElementType, file.ElementTable.ToZeroBased(), file.ZUnit));
}
/// <summary>
/// Convert a <see cref="MeshFile"/> class into a <see cref="MeshData"/> class.
/// </summary>
public static MeshData ToMeshData(this MeshFile file)
{
return(MeshData.CreateMesh(file.Projection, file.NodeIds, file.X, file.Y, file.Z, file.Code, file.ElementIds, file.ElementType, file.ElementTable, file.ZUnit));
}
