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(); }