plot enhancements

Author: istefanis

math/numericalAnalysis/numericalAnalysisService.js

@@ -206,19 +206,22 @@ export const findComplexRootsOfPolynomial = function (termsArray) {
 };
 
 //
-// Laplace inversion
+// Laplace-transform inversion
 //
 
 /**
- * Using an implementation of the Talbot numerical method for Laplace inversion,
- * after taking as input the s-domain Laplace transform function F(s),
+ * Using an implementation of the Talbot numerical method for Laplace-transform inversion,
+ * after taking as input the s-domain function F(s),
  * compute the t-domain function value f(t) at time t
  *
  * It uses the 'Complex' library
  */
-export const TalbotMethod = function (F, t, N) {
+export const talbotMethodForLaplaceTransformInversion = function (F, t, N) {
   if (t <= 0) {
-    console.error("TalbotMethod()", "t must be positive");
+    console.error(
+      "talbotMethodForLaplaceTransformInversion()",
+      "t must be positive"
+    );
     return;
   }
 

view/plots/nyquistPlot.js

@@ -45,6 +45,9 @@ export default class NyquistPlot {
 
   #nyquistObserver;
 
+  //plot colors
+  #curveSegmentColor1 = "#4682b4";
+  #curveSegmentColor2 = "#aaaaaa";
   constructor(
     plotContainerDomElement,
     numeratorTermsArray,
@@ -156,8 +159,6 @@ export default class NyquistPlot {
   }
 
   createNyquistPlot() {
-    const arrowsNumber = 100;
-
     let plotBoundRect = this.#nyquistPlotDomElement.getBoundingClientRect();
     let plotWidth = plotBoundRect.width;
     let plotHeight = plotBoundRect.height;
@@ -171,6 +172,9 @@ export default class NyquistPlot {
     // const minImag = Math.min(...imags);
     // const maxImag = Math.max(...imags);
 
+    const arrowsNumber = 100;
+    const maxAllowedDistanceOfConsecutivePoints = 50;
+
     //set limits for coordinates of plotted points
     const xMax = 10 ** 4;
     const yMax = 10 ** 4;
@@ -198,31 +202,41 @@ export default class NyquistPlot {
         //     )(scope.x);
         //   },
         // },
-        {
-          points: this.#curvePoints
-            .filter((x) => x[0] > 0 && x[1] < xMax && x[2] < yMax)
-            .map((x) => [x[1], x[2]]),
-          // color: "red",
-          fnType: "points",
-          graphType: "polyline",
-        },
-        {
-          points: this.#curvePoints
-            .filter((x) => x[0] < 0 && x[1] > -xMax && x[2] > -yMax)
-            .map((x) => [x[1], x[2]]),
-          fnType: "points",
-          graphType: "polyline",
-          color: "gray",
-        },
         // {
         //   graphType: "polyline",
-        //   color: "gray",
         //   fn: (scope) => {
         //     return linearInterpolationOfCurvePoints(
         //       this.#curvePoints.filter((x) => x[0] < 0).map((x) => [x[1], x[2]])
         //     )(scope.x);
         //   },
+        //   color: this.#curveSegmentColor2,
         // },
+        ...divideNyquistCurveIntoSegments(
+          this.#curvePoints
+            .filter((x) => x[0] > 0 && x[1] < xMax && x[2] < yMax)
+            .map((x) => [x[1], x[2]]),
+          maxAllowedDistanceOfConsecutivePoints
+        ).map((curvePointsSegment) => {
+          return {
+            points: curvePointsSegment,
+            fnType: "points",
+            graphType: "polyline",
+            color: this.#curveSegmentColor1,
+          };
+        }),
+        ...divideNyquistCurveIntoSegments(
+          this.#curvePoints
+            .filter((x) => x[0] < 0 && x[1] > -xMax && x[2] > -yMax)
+            .map((x) => [x[1], x[2]]),
+          maxAllowedDistanceOfConsecutivePoints
+        ).map((curvePointsSegment) => {
+          return {
+            points: curvePointsSegment,
+            fnType: "points",
+            graphType: "polyline",
+            color: this.#curveSegmentColor2,
+          };
+        }),
         {
           points: this.#zeros,
           fnType: "points",
@@ -409,7 +423,7 @@ const computeNyquistRealAndImagWFunctions = function (
   );
 
   //
-  // define magnitude & phase functions
+  // define real & imag functions
   //
   const numReal = functionFromPolynomialTermsArray(
     polynomialEvaluatedWithWiRealTermsArray(numeratorTermsArray)
@@ -467,3 +481,41 @@ const computeStability = function (numeratorTermsArray, denominatorTermsArray) {
   }
   return stability;
 };
+
+/**
+ * Divide a Nyquist plot curve into multiple segments, in case
+ * connections between two consecutive points of paths tending into inf
+ * are expected to be made
+ *
+ * @returns an array of curve segments
+ * (with each curve segment as an array of points)
+ */
+const divideNyquistCurveIntoSegments = (
+  curvePoints,
+  maxAllowedDistanceOfConsecutivePoints
+) => {
+  const allSegments = [];
+  let currentSegment = [];
+
+  for (let p of curvePoints) {
+    if (currentSegment.length === 0) {
+      currentSegment.push(p);
+    } else {
+      const lastP = currentSegment.slice(-1)[0];
+
+      if (
+        (lastP[0] * p[0] < 0 || lastP[1] * p[1] < 0) &&
+        Math.sqrt((lastP[0] - p[0]) ** 2 + (lastP[1] - p[1]) ** 2) >
+          maxAllowedDistanceOfConsecutivePoints
+      ) {
+        //segment end
+        allSegments.push([...currentSegment]);
+        currentSegment = [];
+      }
+      currentSegment.push(p);
+    }
+  }
+  allSegments.push([...currentSegment]);
+
+  return allSegments;
+};

view/plots/timeDomainPlot.js

@@ -8,8 +8,8 @@
 
 import { tfEvaluatedWithComplexNumber } from "../../math/complexAnalysis/complexAnalysisService.js";
 import {
-  TalbotMethod,
   linearInterpolationOfCurvePoints,
+  talbotMethodForLaplaceTransformInversion,
 } from "../../math/numericalAnalysis/numericalAnalysisService.js";
 import { areAllTfTermsNumbers } from "../../util/commons.js";
 import { logMessages } from "../../util/loggingService.js";
@@ -105,7 +105,7 @@ export default class TimeDomainPlot {
 
     for (let t = this.#tMin; t <= this.#tMax; t += step) {
       //new values
-      newFunctionValue = TalbotMethod(
+      newFunctionValue = talbotMethodForLaplaceTransformInversion(
         tfEvaluatedWithComplexNumber(
           this.#numeratorTermsArray,
           this.#denominatorTermsArray