public void InterpolateNodeTest()
{
string triMesh = UnitTestHelper.TestDataDir + "odense_rough.mesh";
string quadMesh = UnitTestHelper.TestDataDir + "odense_rough_quads.mesh";
// Source mesh
MeshFile sourcemeshFile = MeshFile.ReadMesh(triMesh);
SMeshData sourcemesh = sourcemeshFile.ToSMeshData();
sourcemesh.BuildDerivedData();
// Target mesh
MeshFile targetMeshFile = MeshFile.ReadMesh(quadMesh);
SMeshData targetmesh = targetMeshFile.ToSMeshData();
targetmesh.BuildDerivedData();
MeshInterpolator2D interpolator = new MeshInterpolator2D(sourcemesh, MeshValueType.Nodes);
interpolator.SetTarget(targetmesh, MeshValueType.Nodes);
double[] target = new double[targetmesh.NumberOfNodes];
interpolator.InterpolateNodeToTarget(sourcemesh.Z, target);
Assert.False(target.Any(vv => vv == interpolator.DeleteValue));
targetMeshFile.Z = target;
targetMeshFile.Write(UnitTestHelper.TestDataDir + "test_odense_rough_quads-fromTri.mesh");
}
public void InterpolateToXYExample(bool nodeInterp)
{
// Source mesh
string triMesh = UnitTestHelper.TestDataDir + "small.mesh";
MeshFile meshFile = MeshFile.ReadMesh(triMesh);
SMeshData mesh = meshFile.ToSMeshData();
// Build derived data, required for the interpolation routines
mesh.BuildDerivedData();
// Create element center Z values array
double[] elmtZ = new double[meshFile.NumberOfElements];
Array.Copy(mesh.ElementZCenter, elmtZ, mesh.NumberOfElements);
// Make a strong peak at element 5 - in the center of the mesh
elmtZ[4] = -6;
// Set up so source can be both element values and node values
MeshValueType sourceType = MeshValueType.Elements | MeshValueType.Nodes;
// Mesh interpolator
MeshInterpolator2D interpolator = new MeshInterpolator2D(mesh, sourceType);
if (nodeInterp)
{
// Simpler interpolation type
interpolator.ElementValueInterpolationType = MeshInterpolator2D.ElmtValueInterpolationType.NodeValues;
}
// Interpolate elmtZ to nodeZ
double[] nodeZInterp = new double[mesh.NumberOfNodes];
interpolator.SetupElmtToNodeInterpolation();
interpolator.NodeInterpolator.Interpolate(elmtZ, nodeZInterp);
// Interpolation of values one-by-one, no storing of interpolation weights
Assert.AreEqual(-5.999, interpolator.InterpolateElmtToXY(0.7833, 0.531, elmtZ, nodeZInterp), 1e-3);
Assert.AreEqual(-3.543, interpolator.InterpolateNodeToXY(0.7833, 0.531, nodeZInterp), 1e-3);
// Add targets, to store interpolation weights
interpolator.SetTargetSize(mesh.NumberOfElements + 1);
interpolator.AddTarget(0.7833, 0.531); // Target at (almost) center of element 5
for (int i = 0; i < mesh.NumberOfElements; i++)
{
interpolator.AddTarget(mesh.ElementXCenter[i], mesh.ElementYCenter[i]);
}
// Array to interpolate values to
double[] targetValues = new double[mesh.NumberOfElements + 1];
// Interpolate to all target points
interpolator.InterpolateElmtToTarget(elmtZ, targetValues);
if (!nodeInterp)
{
// When element+node values are used, close to peak value of 6
Assert.AreEqual(-5.999, targetValues[0], 1e-3);
Assert.AreEqual(-3.8225, targetValues[1], 1e-3);
for (int i = 0; i < mesh.NumberOfElements; i++)
{
Assert.AreEqual(elmtZ[i], targetValues[i + 1]);
}
}
else // Using only node interpolation, the value is cut off
{
Assert.AreEqual(-3.543, targetValues[0], 1e-3);
Assert.AreEqual(-3.649, targetValues[1], 1e-3);
}
// Interpolating in node Z values, matching to box center value of element.
interpolator.InterpolateNodeToTarget(mesh.Z, targetValues);
Assert.AreEqual(-4.376, targetValues[0], 1e-3);
Assert.AreEqual(-4.376, mesh.ElementZCenter[4], 1e-3);
}
/// <summary>
/// Interpolate values from <paramref name="sourceFilename"/> to mesh
/// defined by <paramref name="targetMeshFilename"/>, and store it in
/// <paramref name="targetFilename"/>
/// </summary>
/// <param name="sourceFilename">Source data for interpolation</param>
/// <param name="targetMeshFilename">Target mesh to interpolate to. Can be a mesh or dfsu file</param>
/// <param name="targetFilename">File to store interpolated data to</param>
public static void Interpolate(string sourceFilename, string targetMeshFilename, string targetFilename)
{
System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
watch.Start();
DfsuFile sourceDfsu = DfsFileFactory.DfsuFileOpen(sourceFilename);
DfsuBuilder builder = DfsuBuilder.Create(DfsuFileType.Dfsu2D);
DfsuBuildGeometry(targetMeshFilename, builder);
builder.SetTimeInfo(sourceDfsu.StartDateTime, sourceDfsu.TimeStepInSeconds);
// Add dynamic items, copying from source
foreach (IDfsSimpleDynamicItemInfo itemInfo in sourceDfsu.ItemInfo)
{
builder.AddDynamicItem(itemInfo.Name, itemInfo.Quantity);
}
DfsuFile targetDfsu = builder.CreateFile(targetFilename);
watch.Stop();
Console.Out.WriteLine("Create File : " + watch.Elapsed.TotalSeconds);
watch.Reset();
watch.Start();
SMeshData sourceMesh = Create(sourceDfsu);
SMeshData targetMesh = Create(targetDfsu);
sourceMesh.BuildDerivedData();
watch.Stop();
Console.Out.WriteLine("Build mesh : " + watch.Elapsed.TotalSeconds);
watch.Reset();
watch.Start();
MeshInterpolator2D interpolator = new MeshInterpolator2D(sourceMesh, MeshValueType.Elements)
{
DeleteValue = sourceDfsu.DeleteValueFloat,
DeleteValueFloat = sourceDfsu.DeleteValueFloat,
//AllowExtrapolation = true,
};
interpolator.SetTarget(targetMesh, MeshValueType.Elements);
watch.Stop();
Console.Out.WriteLine("Interpolator: " + watch.Elapsed.TotalSeconds);
watch.Reset();
watch.Start();
// Temporary, interpolated target-data
float[] targetData = new float[targetDfsu.NumberOfElements];
// Add data for all item-timesteps, copying from source, interpolating
IDfsItemData <float> sourceData;
while (null != (sourceData = sourceDfsu.ReadItemTimeStepNext() as IDfsItemData <float>))
{
interpolator.InterpolateElmtToTarget(sourceData.Data, targetData);
targetDfsu.WriteItemTimeStepNext(sourceData.Time, targetData);
}
watch.Stop();
Console.Out.WriteLine("Interpolate : " + watch.Elapsed.TotalSeconds);
watch.Reset();
sourceDfsu.Close();
targetDfsu.Close();
}
/// <summary>
/// Create a difference file between <paramref name="referenceFilename"/>
/// and <paramref name="compareFilename"/>, and store it in
/// <paramref name="diffFilename"/>.
/// The compare-file data is interpolated to the reference-file mesh, if
/// meshes does not match.
/// </summary>
/// <param name="referenceFilename">Reference data for comparison</param>
/// <param name="compareFilename">Comparison data</param>
/// <param name="diffFilename">File to store difference data to</param>
/// <param name="deleteValueDiff">If set to true, comparing delete value to non-delete value will return the non-delete value</param>
public static void DfsuDiff(string referenceFilename, string compareFilename, string diffFilename, bool deleteValueDiff = true)
{
System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
watch.Start();
// Open reference file and comparison file
DfsuFile refdfsu = DfsFileFactory.DfsuFileOpen(referenceFilename);
DfsuFile comdfsu = DfsFileFactory.DfsuFileOpen(compareFilename);
float refDeleteValueFloat = refdfsu.DeleteValueFloat;
float comDeleteValueFloat = comdfsu.DeleteValueFloat;
// Create diff file, matching reference file.
DfsuBuilder builder = DfsuBuilder.Create(DfsuFileType.Dfsu2D);
// Setup header and geometry, copy from source file
builder.SetNodes(refdfsu.X, refdfsu.Y, refdfsu.Z, refdfsu.Code);
builder.SetElements(refdfsu.ElementTable);
builder.SetProjection(refdfsu.Projection);
builder.SetZUnit(refdfsu.ZUnit);
builder.SetTimeInfo(refdfsu.StartDateTime, refdfsu.TimeStepInSeconds);
// Add dynamic items, copying from source
foreach (IDfsSimpleDynamicItemInfo itemInfo in refdfsu.ItemInfo)
{
builder.AddDynamicItem(itemInfo.Name, itemInfo.Quantity);
}
DfsuFile diffDfsu = builder.CreateFile(diffFilename);
watch.Stop();
Console.Out.WriteLine("Create File : " + watch.Elapsed.TotalSeconds);
watch.Reset();
watch.Start();
// Build up mesh structures for interpolation
SMeshData refMesh = SCreate(refdfsu);
SMeshData comMesh = SCreate(comdfsu);
watch.Stop();
Console.Out.WriteLine("Create mesh : " + watch.Elapsed.TotalSeconds);
watch.Reset();
watch.Start();
bool meshEquals = refMesh.EqualsGeometry(comMesh);
if (!meshEquals)
{
comMesh.BuildDerivedData();
}
watch.Stop();
Console.Out.WriteLine("Build Deriv : " + watch.Elapsed.TotalSeconds);
watch.Reset();
MeshInterpolator2D interpolator = null;
float[] targetData = null;
// Do not interpolate if meshes equals
if (!meshEquals)
{
watch.Start();
// Build up interpolatin structures
interpolator = new MeshInterpolator2D(comMesh, MeshValueType.Elements)
{
DeleteValue = comdfsu.DeleteValueFloat,
DeleteValueFloat = comdfsu.DeleteValueFloat,
//AllowExtrapolation = true,
};
interpolator.SetTarget(refMesh, MeshValueType.Elements);
// Temporary, interpolated compare-data
targetData = new float[diffDfsu.NumberOfElements];
watch.Stop();
Console.Out.WriteLine("Interpolator: " + watch.Elapsed.TotalSeconds);
watch.Reset();
}
watch.Start();
// Loop over all time steps
IDfsItemData <float> refData;
IDfsItemData <float> comData;
while (null != (refData = refdfsu.ReadItemTimeStepNext() as IDfsItemData <float>) &&
null != (comData = comdfsu.ReadItemTimeStepNext() as IDfsItemData <float>))
{
if (interpolator != null)
{
interpolator.InterpolateElmtToTarget(comData.Data, targetData);
}
else
{
targetData = comData.Data;
}
for (int i = 0; i < targetData.Length; i++)
{
// ReSharper disable CompareOfFloatsByEqualityOperator
if (refData.Data[i] != refDeleteValueFloat &&
targetData[i] != comDeleteValueFloat)
{
targetData[i] = refData.Data[i] - targetData[i];
}
else if (refData.Data[i] == refDeleteValueFloat &&
targetData[i] == comDeleteValueFloat)
{
targetData[i] = refDeleteValueFloat;
}
else if (deleteValueDiff)
{
if (refData.Data[i] != refDeleteValueFloat)
{
targetData[i] = refData.Data[i];
}
else // (targetData[i] != comDeleteValueFloat)
{
targetData[i] = -targetData[i];
}
}
else
{
targetData[i] = refDeleteValueFloat;
}
// ReSharper restore CompareOfFloatsByEqualityOperator
}
diffDfsu.WriteItemTimeStepNext(refData.Time, targetData);
}
watch.Stop();
Console.Out.WriteLine("Interpolate : " + watch.Elapsed.TotalSeconds);
watch.Reset();
refdfsu.Close();
comdfsu.Close();
diffDfsu.Close();
}
