From ea6d6a783f4821d7b9a856e0b0a13a4a065bbc0f Mon Sep 17 00:00:00 2001
From: tlnguyen2009 <tienlucnguyen2009@gmail.com>
Date: Wed, 22 Oct 2025 16:57:21 -0400
Subject: [PATCH 01/23] Fixed logic for calculating slope of slider

Fixed the logic error in calculating the slope of the linear function of the slider. Before the fix, the code was incorrectly using the slider's initial Y coordinate stored in the Joint object, instead of its Y coordinate from the previous frame.  The fix was to consistently use both prevJointPosition.x and prevJointPosition.y when calculating n.
---
 .../Edit/joint-edit-panel/joint-edit-panel.component.ts    | 1 +
 src/app/services/kinematic-solver.service.ts               | 7 +++----
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/app/components/SideNav/Edit/joint-edit-panel/joint-edit-panel.component.ts b/src/app/components/SideNav/Edit/joint-edit-panel/joint-edit-panel.component.ts
index e9e915b9..443b598a 100644
--- a/src/app/components/SideNav/Edit/joint-edit-panel/joint-edit-panel.component.ts
+++ b/src/app/components/SideNav/Edit/joint-edit-panel/joint-edit-panel.component.ts
@@ -178,6 +178,7 @@ export class jointEditPanelComponent implements OnInit, OnDestroy{
     if (this.pendingAngle == null) return;
 
     this.setJointAngle(this.pendingAngle);
+    this.getMechanism().notifyChange();
     this.pendingAngle = undefined;
   }
 
diff --git a/src/app/services/kinematic-solver.service.ts b/src/app/services/kinematic-solver.service.ts
index 548d0982..8c158a53 100644
--- a/src/app/services/kinematic-solver.service.ts
+++ b/src/app/services/kinematic-solver.service.ts
@@ -657,10 +657,9 @@ export class PositionSolverService {
     }
     const prevJointPosition: Coord =
       prevPositions[solveOrder.indexOf(solvePrerequisite.jointToSolve.id)];
-    const n =
-      solvePrerequisite.jointToSolve!.coords.y -
-      m *
-        prevPositions[solveOrder.indexOf(solvePrerequisite.jointToSolve.id)].x;
+
+    const n = prevJointPosition.y - m * prevJointPosition.x;
+    
     // get a, b, c values
     const a = 1 + Math.pow(m, 2);
     const b = -h * 2 + m * (n - k) * 2;

From 8a5bcd25ed202f1ae11b172bde7a43501b51d05f Mon Sep 17 00:00:00 2001
From: tlnguyen2009 <tienlucnguyen2009@gmail.com>
Date: Wed, 22 Oct 2025 17:15:31 -0400
Subject: [PATCH 02/23] Fixed the degree/radians option for slider angle input

Adding more logic to allow users to enter value in degrees/radians. The function will also check and display correct values when the users switch between degree and radians in Settings.
---
 .../joint-edit-panel.component.html           |  4 +-
 .../joint-edit-panel.component.ts             | 37 +++++++++++++++++--
 2 files changed, 35 insertions(+), 6 deletions(-)

diff --git a/src/app/components/SideNav/Edit/joint-edit-panel/joint-edit-panel.component.html b/src/app/components/SideNav/Edit/joint-edit-panel/joint-edit-panel.component.html
index 8cef8856..83a4d175 100644
--- a/src/app/components/SideNav/Edit/joint-edit-panel/joint-edit-panel.component.html
+++ b/src/app/components/SideNav/Edit/joint-edit-panel/joint-edit-panel.component.html
@@ -88,12 +88,12 @@
               <label style="margin-right: 5px;">Angle</label>
               <input
                 type="number"
-                [value]="pendingAngle ?? getJointAngle2()"
+                [value]="pendingAngle ?? getSliderJointAngle()"
                 (input)="pendingAngle = $any($event.target).valueAsNumber"
                 (keydown.enter)="confirmJointAngle()"
                 [disabled]="getJointLockState()"
               />
-              <span class="xy-unit">deg</span>
+              <span class="xy-unit">{{ angleSuffix }}</span>
             </div>
           </div>
         </div>
diff --git a/src/app/components/SideNav/Edit/joint-edit-panel/joint-edit-panel.component.ts b/src/app/components/SideNav/Edit/joint-edit-panel/joint-edit-panel.component.ts
index 443b598a..7f5d1393 100644
--- a/src/app/components/SideNav/Edit/joint-edit-panel/joint-edit-panel.component.ts
+++ b/src/app/components/SideNav/Edit/joint-edit-panel/joint-edit-panel.component.ts
@@ -175,9 +175,23 @@ export class jointEditPanelComponent implements OnInit, OnDestroy{
 
   // This is for angle of a Joint attached to Slider
   confirmJointAngle(): void {
-    if (this.pendingAngle == null) return;
+    let newAngle = this.pendingAngle;
+    
+    if (newAngle == null) return;
 
-    this.setJointAngle(this.pendingAngle);
+    if (this.angleSuffix === 'rad') { //need to convert the 'raw' into degrees if the current unit is 'rad', we have to convert it because the logic in backend only works with unit in degrees.
+      newAngle = newAngle * 180 / Math.PI;
+    }
+
+    const currJoint = this.getCurrentJoint();
+    const oldAngle = currJoint.angle; //get angle of current joint
+
+    if (Math.abs(oldAngle - newAngle) < 1e-6) { //return right away if the new and old angle are the same
+      this.pendingAngle = undefined;
+      return;
+    }
+
+    this.setJointAngle(newAngle); //setJointAngle already recorded undoRedoService 
     this.getMechanism().notifyChange();
     this.pendingAngle = undefined;
   }
@@ -507,8 +521,23 @@ export class jointEditPanelComponent implements OnInit, OnDestroy{
     return 0;
   }
 
-  getJointAngle2(): number {
-    return this.getCurrentJoint().angle;
+  getSliderJointAngle(): number {
+    let angleInDegrees = this.getCurrentJoint().angle; //angle in backend system always return in degrees
+    let angleInRadians = angleInDegrees * Math.PI / 180;
+
+    if (this.angleSuffix === 'º') {
+      if (angleInDegrees < 0) {  // Normalize the angle to be within [0, 360] degrees
+        angleInDegrees += 360;
+      }
+      return parseFloat(angleInDegrees.toFixed(3));
+    } else if(this.angleSuffix === 'rad') {
+      if (angleInRadians < 0) {
+        angleInRadians += 2 * (Math.PI); // Normalize to be within [0, 2pi]
+      }
+      return parseFloat(angleInRadians.toFixed(3));
+    }
+    
+    return 0;
   }
 
   getJointGround() {

From 3fe5be885382610fe22064d126e82e8deb878d19 Mon Sep 17 00:00:00 2001
From: tlnguyen2009 <tienlucnguyen2009@gmail.com>
Date: Fri, 24 Oct 2025 22:32:15 -0400
Subject: [PATCH 03/23] Fix wrong animation with mechanism when slider angle
 equals 90 degrees (vertical)

Before the fix, when the slider became vertical (angle = 90 degrees), the slider didn't move, and the coupler link was strangely animated by stretching out and in. After the fix, everything became normal as it should be. The issue was in the old code, which mistakenly used the old point coordinates instead of the current ones. In other words, when the crank moves an angle theta to a new position, we should use this new position to draw a circle analysis instead of the last position.
---
 src/app/services/kinematic-solver.service.ts | 26 ++++++++++----------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/app/services/kinematic-solver.service.ts b/src/app/services/kinematic-solver.service.ts
index 8c158a53..b7e8e176 100644
--- a/src/app/services/kinematic-solver.service.ts
+++ b/src/app/services/kinematic-solver.service.ts
@@ -652,7 +652,8 @@ export class PositionSolverService {
       nextPositions[solveOrder.indexOf(solvePrerequisite.knownJointOne!.id)!].y;
 
     let m = Math.tan((solvePrerequisite.jointToSolve!.angle * Math.PI) / 180);
-    if (m > 1000 || m < -1000) {
+    
+    if (m > 1000 || m < -1000) { // when angle is 90 degrees, tan will be 1/0 = undefined
       m = Number.MAX_VALUE;
     }
     const prevJointPosition: Coord =
@@ -666,18 +667,17 @@ export class PositionSolverService {
     const c = Math.pow(h, 2) + Math.pow(n - k, 2) - Math.pow(r, 2);
     // get discriminant
     const d = Math.pow(b, 2) - 4 * a * c;
+    
+    console.log('value of disciminant: ', d);
 
-    //if discriminant is too big or not a number, use alternative method
+    //if discriminant is too big or not a number (NaN), use alternative method. We will see this case when angle of slider = 90 degrees
     if (isNaN(d) || !isFinite(d)) {
-      let temp_a: number = 1;
-      let temp_b: number = -2 * solvePrerequisite.knownJointOne!._coords.y;
-      let temp_c: number =
-        Math.pow(solvePrerequisite.knownJointOne!._coords.y, 2) +
-        Math.pow(
-          solvePrerequisite.knownJointOne!._coords.x - prevJointPosition.x,
-          2
-        ) -
-        Math.pow(r, 2);
+      // Line (vertical slider): x = t
+      // Circle: (x - h)^2 + (y - k)^2 = r^2
+      const t = prevJointPosition.x;
+      const temp_a: number = 1;
+      const temp_b: number = -2 * k;
+      const temp_c: number = Math.pow(k, 2) + Math.pow(t-h,2) - Math.pow(r, 2);
       let temp_d: number = Math.pow(temp_b, 2) - 4 * temp_a * temp_c;
       if (temp_d < 0) {
         return undefined;
@@ -697,8 +697,7 @@ export class PositionSolverService {
         y = y_2;
       }
       x = prevJointPosition.x;
-      //if discriminant is normal, calculate intersection points and return closest.
-    } else {
+    } else { //if discriminant is normal, calculate intersection points and return closest.
       if (d >= 0) {
         const x_1 = (-b + Math.sqrt(Math.pow(b, 2) - 4 * a * c)) / (2 * a);
         const y_1 = m * x_1 + n;
@@ -722,6 +721,7 @@ export class PositionSolverService {
           y = intersectionPoints[0].y;
         }
       } else {
+        console.log('something weird happens to calculation logic with solveCircleLine() in kinematic-solver.service.ts')
         return undefined;
       }
     }

From eb8f6f23c54d085eb2ca0ac118b8b017cce879e2 Mon Sep 17 00:00:00 2001
From: tlnguyen2009 <tienlucnguyen2009@gmail.com>
Date: Sun, 2 Nov 2025 12:27:01 -0500
Subject: [PATCH 04/23] Fixed: Mechanism with slider doesn't move or animate
 when hit play button at some position on the grid

When solving for the slider's position, a quadratic equation provides two possible solutions (x1, x2). The correct solution is the one physically closest to the slider's previous position.

The old code always picked x1, which caused errors when x2 was the correct solution for some position on the grid. This commit updates the logic to choose the solution (x1 or x2) nearest to the previous position.
---
 src/app/services/kinematic-solver.service.ts | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/src/app/services/kinematic-solver.service.ts b/src/app/services/kinematic-solver.service.ts
index b7e8e176..6014120f 100644
--- a/src/app/services/kinematic-solver.service.ts
+++ b/src/app/services/kinematic-solver.service.ts
@@ -656,9 +656,10 @@ export class PositionSolverService {
     if (m > 1000 || m < -1000) { // when angle is 90 degrees, tan will be 1/0 = undefined
       m = Number.MAX_VALUE;
     }
+    
     const prevJointPosition: Coord =
       prevPositions[solveOrder.indexOf(solvePrerequisite.jointToSolve.id)];
-
+    
     const n = prevJointPosition.y - m * prevJointPosition.x;
     
     // get a, b, c values
@@ -668,7 +669,6 @@ export class PositionSolverService {
     // get discriminant
     const d = Math.pow(b, 2) - 4 * a * c;
     
-    console.log('value of disciminant: ', d);
 
     //if discriminant is too big or not a number (NaN), use alternative method. We will see this case when angle of slider = 90 degrees
     if (isNaN(d) || !isFinite(d)) {
@@ -698,7 +698,7 @@ export class PositionSolverService {
       }
       x = prevJointPosition.x;
     } else { //if discriminant is normal, calculate intersection points and return closest.
-      if (d >= 0) {
+      if (d >= 0) { // discriminant d >= 0, there is at least 1 solution and at most 2 solutions
         const x_1 = (-b + Math.sqrt(Math.pow(b, 2) - 4 * a * c)) / (2 * a);
         const y_1 = m * x_1 + n;
         const x_2 = (-b - Math.sqrt(Math.pow(b, 2) - 4 * a * c)) / (2 * a);
@@ -716,12 +716,15 @@ export class PositionSolverService {
           Math.pow(x_2 - prevJointPosition.x, 2) +
             Math.pow(y_2 - prevJointPosition.y, 2)
         );
-        if (intersection1Diff < intersection2Diff) {
+        if (intersection1Diff < intersection2Diff) { // (x1,y1) closer to the last slider's position 
           x = intersectionPoints[0].x;
           y = intersectionPoints[0].y;
+        } else { // (x2,y2) closer to the last slider's position
+          x = intersectionPoints[1].x;
+          y = intersectionPoints[1].y;
         }
-      } else {
-        console.log('something weird happens to calculation logic with solveCircleLine() in kinematic-solver.service.ts')
+      } else { // discriminant < 0, there is no solution and it's also the signal about limit of the movement of the crank and we need to swap direction.
+        console.log('crank hits its limit and ready to change direction');
         return undefined;
       }
     }

From a51b7d0036b9c2c1cd11f3ffced730a372a9065a Mon Sep 17 00:00:00 2001
From: tlnguyen2009 <tienlucnguyen2009@gmail.com>
Date: Sun, 2 Nov 2025 12:39:17 -0500
Subject: [PATCH 05/23] Fixed: Unexpected double blue path line for slider

The slider's blue path is generated from a series of connected points. A previous optimization attempted to draw this path by only using two endpoints.

However, the logic to find these points was incorrectly reused from a function designed for linkages. This bug caused the slider path to render incorrectly, appearing as a "double closed loop" like the outline of a linkage instead of a single, continuous line.

This commit removes the faulty optimization. The path is now drawn by connecting all of its points in sequence, which resolves the rendering bug.
---
 src/app/services/svg-path.service.ts | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/src/app/services/svg-path.service.ts b/src/app/services/svg-path.service.ts
index c1eff505..19a0fec9 100644
--- a/src/app/services/svg-path.service.ts
+++ b/src/app/services/svg-path.service.ts
@@ -29,13 +29,6 @@ export class SVGPathService {
       return '';
     }
 
-    //check if coordinates are collinear. If they are, use the two returned coords(the end points) to draw a line
-    const collinearCoords: Coord[] | undefined = this.findCollinearCoords(allCoords);
-    if (collinearCoords !== undefined) {
-
-      return this.calculateTwoPointPath(collinearCoords[0], collinearCoords[1], radius);
-    }
-
     let pathData = `M ${allCoords[0].x},${allCoords[0].y} `;
     for (let i = 1; i < allCoords.length; i++) {
       const currentCoord = allCoords[i];
@@ -84,7 +77,6 @@ export class SVGPathService {
         return undefined;
       }
     }
-
     // If all coords have the same slope with the 'start' point, they are collinear
     return [start, end];
   }

From be163ac94967b370803e82f6b080093601f0a5d1 Mon Sep 17 00:00:00 2001
From: mwalsh001 <matty71604@gmail.com>
Date: Sun, 30 Nov 2025 21:16:58 -0500
Subject: [PATCH 06/23] Correct velocity calculations for angular velocity of a
 4-bar link. Displays in analysis graph. Only displays one link velocity at a
 time that is hard-coded, needs to include the velocities of the selected
 link.

---
 package-lock.json                             |  88 ++-
 package.json                                  |   2 +
 .../link-analysis-panel.component.html        |   4 +-
 .../link-analysis-panel.component.ts          |  22 +-
 .../services/analysis-solver.service.spec.ts  |  55 ++
 src/app/services/analysis-solver.service.ts   | 703 ++++++++++--------
 6 files changed, 552 insertions(+), 322 deletions(-)
 create mode 100644 src/app/services/analysis-solver.service.spec.ts

diff --git a/package-lock.json b/package-lock.json
index 7585e033..91a7c47c 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -27,6 +27,8 @@
         "lodash": "^4.17.21",
         "lz-string": "^1.5.0",
         "material": "^0.7.5",
+        "math.js": "^1.1.46",
+        "mathjs": "^15.1.0",
         "ng2-charts": "^5.0.4",
         "papaparse": "^5.4.1",
         "rxjs": "~7.8.0",
@@ -3295,7 +3297,6 @@
       "version": "7.26.10",
       "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.26.10.tgz",
       "integrity": "sha512-2WJMeRQPHKSPemqk/awGrAiuFfzBmOIPXKizAsVhWH9YJqLZ0H+HS4c8loHGgW6utJ3E/ejXQUsiGaQy2NZ9Fw==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "regenerator-runtime": "^0.14.0"
@@ -8374,6 +8375,18 @@
       "integrity": "sha512-QE33hToZseCH3jS0qN96O/bSh3kaw/h+Tq7ngyY9eWDUnTlTNUyqfqvCXioLe5Na5jFsL78ra/wuBU4iuEgd4w==",
       "dev": true
     },
+    "node_modules/complex.js": {
+      "version": "2.4.3",
+      "resolved": "https://registry.npmjs.org/complex.js/-/complex.js-2.4.3.tgz",
+      "integrity": "sha512-UrQVSUur14tNX6tiP4y8T4w4FeJAX3bi2cIv0pu/DTLFNxoq7z2Yh83Vfzztj6Px3X/lubqQ9IrPp7Bpn6p4MQ==",
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/rawify"
+      }
+    },
     "node_modules/compressible": {
       "version": "2.0.18",
       "resolved": "https://registry.npmjs.org/compressible/-/compressible-2.0.18.tgz",
@@ -9037,6 +9050,11 @@
         }
       }
     },
+    "node_modules/decimal.js": {
+      "version": "10.6.0",
+      "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz",
+      "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg=="
+    },
     "node_modules/default-browser": {
       "version": "5.2.1",
       "resolved": "https://registry.npmjs.org/default-browser/-/default-browser-5.2.1.tgz",
@@ -9545,6 +9563,11 @@
       "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
       "dev": true
     },
+    "node_modules/escape-latex": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/escape-latex/-/escape-latex-1.2.0.tgz",
+      "integrity": "sha512-nV5aVWW1K0wEiUIEdZ4erkGGH8mDxGyxSeqPzRNtWP7ataw+/olFObw7hujFWlVjNsaDFw5VZ5NzVSIqRgfTiw=="
+    },
     "node_modules/escape-string-regexp": {
       "version": "1.0.5",
       "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
@@ -11283,6 +11306,11 @@
       "integrity": "sha512-VYz/BjjmC3klLJlLwA4Kw8ytk0zDSmbbDLNs794VnWmkcCB7I9aAL/D48VNQtmITyPvea2C3jdUMfc3kAoy0PQ==",
       "dev": true
     },
+    "node_modules/javascript-natural-sort": {
+      "version": "0.7.1",
+      "resolved": "https://registry.npmjs.org/javascript-natural-sort/-/javascript-natural-sort-0.7.1.tgz",
+      "integrity": "sha512-nO6jcEfZWQXDhOiBtG2KvKyEptz7RVbpGP4vTD2hLBdmNQSsCiicO2Ioinv6UI4y9ukqnBpy+XZ9H6uLNgJTlw=="
+    },
     "node_modules/jest-worker": {
       "version": "27.5.1",
       "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-27.5.1.tgz",
@@ -12259,6 +12287,45 @@
       "resolved": "https://registry.npmjs.org/material/-/material-0.7.9.tgz",
       "integrity": "sha512-6NJ2bKKXKR024377IhFAyP4OEejmktlHsHwRCas/cyyoPUykbAOYtctP8sDwTtCFE2ot9YitgnWzbMj0vVoRbA=="
     },
+    "node_modules/math.js": {
+      "version": "1.1.46",
+      "resolved": "https://registry.npmjs.org/math.js/-/math.js-1.1.46.tgz",
+      "integrity": "sha512-D4DS+oENshM6xI94mhzJFkH1D0jvSHyKjNuLbki2IdGM3RZ74WQDSw8KLIMy/76JFhl7BvY1/KkJc38kOvv/6Q=="
+    },
+    "node_modules/mathjs": {
+      "version": "15.1.0",
+      "resolved": "https://registry.npmjs.org/mathjs/-/mathjs-15.1.0.tgz",
+      "integrity": "sha512-HfnAcScQm9drGryodlDqeS3WAl4gUTYGDcOtcqL/8s23MZ28Ib1i8XnYK3ZdjNuaW/L4BAp9lIp8vxAMrcuu1w==",
+      "dependencies": {
+        "@babel/runtime": "^7.26.10",
+        "complex.js": "^2.2.5",
+        "decimal.js": "^10.4.3",
+        "escape-latex": "^1.2.0",
+        "fraction.js": "^5.2.1",
+        "javascript-natural-sort": "^0.7.1",
+        "seedrandom": "^3.0.5",
+        "tiny-emitter": "^2.1.0",
+        "typed-function": "^4.2.1"
+      },
+      "bin": {
+        "mathjs": "bin/cli.js"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/mathjs/node_modules/fraction.js": {
+      "version": "5.3.4",
+      "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-5.3.4.tgz",
+      "integrity": "sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ==",
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/rawify"
+      }
+    },
     "node_modules/media-typer": {
       "version": "0.3.0",
       "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
@@ -14061,7 +14128,6 @@
       "version": "0.14.1",
       "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.14.1.tgz",
       "integrity": "sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==",
-      "dev": true,
       "license": "MIT"
     },
     "node_modules/regex-parser": {
@@ -14483,6 +14549,11 @@
         "url": "https://opencollective.com/webpack"
       }
     },
+    "node_modules/seedrandom": {
+      "version": "3.0.5",
+      "resolved": "https://registry.npmjs.org/seedrandom/-/seedrandom-3.0.5.tgz",
+      "integrity": "sha512-8OwmbklUNzwezjGInmZ+2clQmExQPvomqjL7LFqOYqtmuxRgQYqOD3mHaU+MvZn5FLUeVxVfQjwLZW/n/JFuqg=="
+    },
     "node_modules/select-hose": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/select-hose/-/select-hose-2.0.0.tgz",
@@ -15488,6 +15559,11 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/tiny-emitter": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/tiny-emitter/-/tiny-emitter-2.1.0.tgz",
+      "integrity": "sha512-NB6Dk1A9xgQPMoGqC5CVXn123gWyte215ONT5Pp5a0yt4nlEoO1ZWeCwpncaekPHXO60i47ihFnZPiRPjRMq4Q=="
+    },
     "node_modules/tmp": {
       "version": "0.0.33",
       "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz",
@@ -15613,6 +15689,14 @@
       "integrity": "sha512-KNNZtayBCtmnNmbo5mG47p1XsCyrx6iVqomjcZnec/1Y5GGARaxPs6r49RnSPeUP3YjNYiU9sQHAtY4BBvnZwg==",
       "dev": true
     },
+    "node_modules/typed-function": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/typed-function/-/typed-function-4.2.1.tgz",
+      "integrity": "sha512-EGjWssW7Tsk4DGfE+5yluuljS1OGYWiI1J6e8puZz9nTMM51Oug8CD5Zo4gWMsOhq5BI+1bF+rWTm4Vbj3ivRA==",
+      "engines": {
+        "node": ">= 18"
+      }
+    },
     "node_modules/typescript": {
       "version": "5.5.4",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.5.4.tgz",
diff --git a/package.json b/package.json
index 17dd9920..bb1aa915 100644
--- a/package.json
+++ b/package.json
@@ -32,6 +32,8 @@
     "lodash": "^4.17.21",
     "lz-string": "^1.5.0",
     "material": "^0.7.5",
+    "math.js": "^1.1.46",
+    "mathjs": "^15.1.0",
     "ng2-charts": "^5.0.4",
     "papaparse": "^5.4.1",
     "rxjs": "~7.8.0",
diff --git a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.html b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.html
index 3d32376f..149cbc86 100644
--- a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.html
+++ b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.html
@@ -39,8 +39,8 @@
                              [btn1Action]="toggleGraph.bind(this, GraphType.referenceJointAngularVelocity)"
                              [graphText]= "currentGraphType === GraphType.referenceJointAngularVelocity ? 'Close Graph' : 'Show Graph'">></analysis-graph-button>
 
-      <p style="margin-left: 10px; margin-top: 1px;">ω: N/A rad/s</p>
-
+      <p style="margin-left: 10px; margin-top: 1px;">ω: rad/s</p>
+<!--      getCurrentLinkAnalysis()-->
       <ng-container *ngIf="currentGraphType === GraphType.referenceJointAngularVelocity">
           <div class="modal" (keyup.escape)="closeAnalysisGraph()">
             <app-analysis-graph-block class="large-graph"
diff --git a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
index eb256d05..d183079f 100644
--- a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
+++ b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
@@ -4,7 +4,7 @@ import {InteractionService} from "src/app/services/interaction.service";
 import {Mechanism} from "src/app/model/mechanism";
 import {LinkInteractor} from "src/app/controllers/link-interactor";
 import {Joint} from "src/app/model/joint";
-import {AnalysisSolveService, JointAnalysis} from "src/app/services/analysis-solver.service";
+import {AnalysisSolveService, JointAnalysis, LinkAnalysis} from "src/app/services/analysis-solver.service";
 
 // enum contains every kind of graph this panel can open.
 export enum GraphType {
@@ -53,11 +53,11 @@ export class LinkAnalysisPanelComponent {
     getCOMYCoord(): number {return this.getCurrentLink()?.centerOfMass.y.toFixed(3) as unknown as number;}
   openAnalysisGraph(graphType: GraphType): void {
     this.currentGraphType = graphType;
-    if(this.currentGraphType == GraphType.CoMPosition ||
-      this.currentGraphType == GraphType.CoMVelocity ||
-      this.currentGraphType == GraphType.CoMAcceleration){
-      this.addPlaceholderCoMJoint();
-    }
+    // if(this.currentGraphType == GraphType.CoMPosition ||
+    //   this.currentGraphType == GraphType.CoMVelocity ||
+    //   this.currentGraphType == GraphType.CoMAcceleration){
+    //   this.addPlaceholderCoMJoint();
+    // }
     this.getGraphData();
   }
 
@@ -87,11 +87,11 @@ export class LinkAnalysisPanelComponent {
       case GraphType.CoMAcceleration:
         return 'Center of Mass Acceleration(' + this.currentGlobalUSuffix + '/s²)';
       case GraphType.referenceJointAngle:
-        return 'Reference Joint Angle(' + this.currentGlobalAngleSuffix + ')'; 
+        return 'Reference Joint Angle(' + this.currentGlobalAngleSuffix + ')';
       case GraphType.referenceJointAngularVelocity:
-        return 'Reference Joint Angular Velocity(' + this.currentGlobalAngleSuffix + '/s)'; 
+        return 'Reference Joint Angular Velocity(' + this.currentGlobalAngleSuffix + '/s)';
       case GraphType.referenceJointAngularAcceleration:
-        return 'Reference Joint Angular Acceleration(' + this.currentGlobalAngleSuffix + '/s²)'; 
+        return 'Reference Joint Angular Acceleration(' + this.currentGlobalAngleSuffix + '/s²)';
       // Add more cases as needed
       default:
         return ''; // Handle unknown cases or add a default value
@@ -173,7 +173,7 @@ export class LinkAnalysisPanelComponent {
 
       case GraphType.referenceJointAngularVelocity:
         if(this.getReferenceJoint() !== undefined) {
-          let joints = this.getCurrentLink().getJoints();
+          let joints = this.getMechanism().getArrayOfJoints();
           let jointIds = joints.map(joint => joint.id);
           let linkKinematics = this.analysisSolverService.getLinkKinematics(jointIds);
           return this.analysisSolverService.transformLinkKinematicGraph(linkKinematics, "Velocity");
@@ -248,4 +248,6 @@ export class LinkAnalysisPanelComponent {
     link.click();
     document.body.removeChild(link);
   }
+
+
 }
diff --git a/src/app/services/analysis-solver.service.spec.ts b/src/app/services/analysis-solver.service.spec.ts
new file mode 100644
index 00000000..f64316a1
--- /dev/null
+++ b/src/app/services/analysis-solver.service.spec.ts
@@ -0,0 +1,55 @@
+import { TestBed } from '@angular/core/testing';
+import {AnalysisSolveService, JointAnalysis} from './analysis-solver.service';
+import { PositionSolverService } from './kinematic-solver.service';
+import { create, all } from 'mathjs';
+
+const math = create(all, {});
+
+describe('AnalysisSolveService getAngularVelocities', () => {
+  let service: AnalysisSolveService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        { provide: PositionSolverService, useValue: {} },
+        AnalysisSolveService,
+      ],
+    });
+
+    service = TestBed.inject(AnalysisSolveService);
+  });
+
+  const deg2rad = (deg: number) => deg * Math.PI / 180;
+
+  const r2 = 2.954;  // AB
+  const r3 = 5.752;  // BC
+  const r4 = 3.745;  // CD
+
+  it('computes correct ω3 and ω4 for time = 0', () => {
+    // Row:
+    // 0   80.0594   1.0472   -168.1626   -0.1401   95.0559   0.7726
+
+    const theta2 = deg2rad(80.0594);    // AB angle
+    const theta3 = deg2rad(-168.1626);  // CB angle
+    const theta4 = deg2rad(95.0559);    // DC angle
+    console.log('theta2: ' +theta2);
+    console.log('theta3: ' +theta3);
+    console.log('theta4: ' +theta4);
+    const omega2 = 1.0472;
+
+    const [omega3, omega4] = service.getAngularVelocities(
+      r2, r3, r4,
+      theta2, theta3, theta4,
+
+      omega2
+    );
+
+    console.log('t=0  ω3, ω4 =', omega3, omega4);
+
+    // From table: CB = -0.1401 rad/s, DC = 0.7726 rad/s
+    expect(omega3).toBeCloseTo(-0.1401, 4);
+    expect(omega4).toBeCloseTo(0.7726, 4);
+  });
+
+
+});
diff --git a/src/app/services/analysis-solver.service.ts b/src/app/services/analysis-solver.service.ts
index ac423aae..9e297211 100644
--- a/src/app/services/analysis-solver.service.ts
+++ b/src/app/services/analysis-solver.service.ts
@@ -2,348 +2,435 @@ import { Injectable } from '@angular/core';
 import { Coord } from '../model/coord';
 import { PositionSolverService, SolveOrder, SolvePrerequisite, SolveType } from './kinematic-solver.service';
 import { AnimationPositions } from './kinematic-solver.service';
+import { create, all, MathJsInstance } from 'mathjs'
+import {link} from "d3-shape";
 
 export interface JointAnalysis {
-    timeIncrement: number,
-    positions: Coord[],
-    velocities: Coord[],
-    accelerations: Coord[],
+  timeIncrement: number,
+  positions: Coord[],
+  velocities: Coord[],
+  accelerations: Coord[],
 }
 
 export interface LinkAnalysis {
-    timeIncrement: number,
-    COMpositions: Coord[],
-    COMvelocities: Coord[],
-    COMaccelerations: Coord[],
-    angle: number[],
-    angularVelocity: number[],
-    angularAcceleration: number[],
+  timeIncrement: number,
+  COMpositions: Coord[],
+  COMvelocities: Coord[],
+  COMaccelerations: Coord[],
+  angle: number[],
+  angularVelocity: number[],
+  angularAcceleration: number[],
 }
 
+const math: MathJsInstance = create(all, {});
 
 @Injectable({
-    providedIn: 'root'
+  providedIn: 'root'
 })
 export class AnalysisSolveService {
 
-    private solveOrders: SolveOrder[] = [];
-    private jointPositions: AnimationPositions[] = [];
-    private jointKinematics: Map<number, JointAnalysis> = new Map();
-    constructor(private positionSolver: PositionSolverService) {
+  private solveOrders: SolveOrder[] = [];
+  private jointPositions: AnimationPositions[] = [];
+  private jointKinematics: Map<number, JointAnalysis> = new Map();
 
-    }
-
-    // Updates kinematic data by fetching solve orders and joint positions, then solving submechanism kinematics.
-    updateKinematics() {
-        /**Order of operations
-         * 1. First we need the Solve Orders and Positions of the joints from position solver
-         * 2. For solving links we need to associate model links with the joints being solved for, we can do so by using the
-         * 3. Iterate over each position, solving for the needed information for both links and joints.
-         * 4. Update the Information
-         */
-        this.solveOrders = this.positionSolver.getSolveOrders();
-        this.jointPositions = this.positionSolver.getAnimationFrames();
-        this.jointKinematics = new Map();
-        for (let i = 0; i < this.solveOrders.length; i++) {
-            this.solveSubmechanimsKinematics(this.solveOrders[i], this.jointPositions[i]);
-        }
-    }
+  constructor(private positionSolver: PositionSolverService) {
 
-    // Solves kinematics for a specific submechanism given its solve order and joint positions.
-    solveSubmechanimsKinematics(solveOrder: SolveOrder, jointPositions: AnimationPositions) {
-        /**we are given the animation positions and solve order for a submechanism
-         * 1. iterate over each set of positions to solve
-         * 2. call a function that returns all relevant calculations
-         * 3. update jointKinematics
-         */
-        let mechanismVelocities: Coord[][] = [];
-        let mechanismAccelerations: Coord[][] = [];
-        for (let time = 0; time < jointPositions.positions.length; time++) {
-            let solutions = this.solveJointKinematics(solveOrder, jointPositions.positions[time]);
-            mechanismVelocities.push(solutions.velocities);
-            mechanismAccelerations.push(solutions.accelerations);
-        }
-        const arrayColumn = (array: Coord[][], columnIndex: number) => array.map(row => row[columnIndex])
-        this.jointKinematics = new Map();
-        let inputspeed: number = solveOrder.prerequisites.get(solveOrder.order[0])!.jointToSolve.inputSpeed;
-        let timeIncrement: number = 60 / (inputspeed * 360);
-        for (let i = 0; i < solveOrder.order.length; i++) {
-            let accelerations = arrayColumn(mechanismAccelerations, i);
-            let velocities = arrayColumn(mechanismVelocities, i);
-            let positions = arrayColumn(jointPositions.positions, i);
-            let joint: JointAnalysis = { timeIncrement: timeIncrement, positions: positions, velocities: velocities, accelerations: accelerations }
-            this.jointKinematics.set(solveOrder.order[i], joint);
-        }
-    }
+  }
 
-    // Computes velocities and accelerations for all joints in a solve order at a single time step.
-    solveJointKinematics(solveOrder: SolveOrder, positions: Coord[]): { velocities: Coord[], accelerations: Coord[] } {
-        let velocities: Coord[] = [];
-        let accelerations: Coord[] = [];
-
-        for (let index = 0; index < solveOrder.order.length; index++) {
-            let id = solveOrder.order[index];
-            let prereq = solveOrder.prerequisites.get(id)!;
-            let velocity_acceleration: { velocity: Coord, acceleration: Coord };
-            switch (prereq.solveType) {
-                case SolveType.Ground:
-                    velocities.push(new Coord(0, 0));
-                    accelerations.push(new Coord(0, 0));
-                    break;
-                case SolveType.RevoluteInput:
-                    velocity_acceleration = this.solveRevInputJointKinematics(index, prereq, positions);
-                    velocities.push(velocity_acceleration.velocity);
-                    accelerations.push(velocity_acceleration.acceleration);
-                    break;
-                case SolveType.PrismaticInput:
-                    velocity_acceleration = this.solvePrisInputJointKinematics(prereq);
-                    velocities.push(velocity_acceleration.velocity);
-                    accelerations.push(velocity_acceleration.acceleration);
-                    break;
-                case SolveType.CircleCircle:
-                    let knownIndex1 = solveOrder.order.indexOf(prereq.knownJointOne!.id);
-                    let knownIndex2 = solveOrder.order.indexOf(prereq.knownJointTwo!.id);
-                    velocity_acceleration = this.solveCircleCirlceJointKinematics(index, knownIndex1, knownIndex2, positions, velocities, accelerations);
-                    velocities.push(velocity_acceleration.velocity);
-                    accelerations.push(velocity_acceleration.acceleration);
-                    break;
-                case SolveType.CircleLine:
-                    knownIndex1 = solveOrder.order.indexOf(prereq.knownJointOne!.id);
-                    velocity_acceleration = this.solveCircleLineJointKinematics(index, knownIndex1, prereq, positions, velocities, accelerations)
-                    velocities.push(velocity_acceleration.velocity);
-                    accelerations.push(velocity_acceleration.acceleration);
-                    break;
-            }
-        }
-        return { velocities: velocities, accelerations: accelerations };
-    }
-
-    //need to account for switching directions
-    /**
-     * Solves for the velocity and acceleration of a joint connected to a grounded revolute input
-     * @param jointIndex - an index for the joint to be solved within with positions array.
-     * @param prereq - a SolvePrerequisite that corresponds to that joint.
-     * @param positions - an array of joint positions for a particular timestep.
-     * @returns
+  // Updates kinematic data by fetching solve orders and joint positions, then solving submechanism kinematics.
+  updateKinematics() {
+    /**Order of operations
+     * 1. First we need the Solve Orders and Positions of the joints from position solver
+     * 2. For solving links we need to associate model links with the joints being solved for, we can do so by using the
+     * 3. Iterate over each position, solving for the needed information for both links and joints.
+     * 4. Update the Information
      */
-    solveRevInputJointKinematics(jointIndex: number, prereq: SolvePrerequisite, positions: Coord[]): { velocity: Coord, acceleration: Coord } {
-
-        const xDifference = positions[jointIndex].x - positions[0].x;
-        const yDifference = positions[jointIndex].y - positions[0].y;
-        const angleToInput: number = Math.atan2(yDifference, xDifference);
-        const omega: number = 2 * Math.PI * (prereq.knownJointOne!.inputSpeed / 60); //Angular Velocity of Link in Radians
-        const r: number = prereq.distFromKnownJointOne!;
-
-        //velocity
-        const velocityMagnitude = r * omega; //Velocity magnitude
-        const velocityTheta = omega > 0 ? angleToInput - Math.PI / 2 : angleToInput + Math.PI / 2; //Velocity direction
-        const xVelocity: number = Math.cos(velocityTheta) * velocityMagnitude;
-        const yVelocity: number = Math.sin(velocityTheta) * velocityMagnitude;
-        const jointVelocity: Coord = new Coord(xVelocity, yVelocity);
-        //acceleration
-        const xAcceleration: number = -Math.cos(angleToInput) * velocityMagnitude * omega;
-        const yAcceleration: number = -Math.sin(angleToInput) * velocityMagnitude * omega;
-        const jointAcceleration: Coord = new Coord(xAcceleration, yAcceleration);
-        return { velocity: jointVelocity, acceleration: jointAcceleration };
+    this.solveOrders = this.positionSolver.getSolveOrders();
+    this.jointPositions = this.positionSolver.getAnimationFrames();
+    this.jointKinematics = new Map();
+    for (let i = 0; i < this.solveOrders.length; i++) {
+      this.solveSubmechanimsKinematics(this.solveOrders[i], this.jointPositions[i]);
     }
-
-    // Calculates velocity and acceleration for a prismatic input joint from its prerequisites.
-    solvePrisInputJointKinematics(prereq: SolvePrerequisite): { velocity: Coord, acceleration: Coord } {
-        const velocityMag = prereq.jointToSolve.inputSpeed * (0.05 * 6) //Kinematic solver generates frames for 0.05m increments, and animator uses Rev-Input timeInterval calculation
-        const velocityTheta = prereq.jointToSolve.angle;
-        const deltaX: number = Math.cos(velocityTheta) * velocityMag;
-        const deltaY: number = Math.sin(velocityTheta) * velocityMag;
-        const jointVelocity: Coord = new Coord(deltaX, deltaY);
-        const jointAcceleration: Coord = new Coord(0, 0);
-        return { velocity: jointVelocity, acceleration: jointAcceleration };
-    }
-
-    // Determines velocity and acceleration for a joint constrained by two circular motions using known indices, positions, velocities, and accelerations.
-    solveCircleCirlceJointKinematics(jointIndex: number, known1Index: number, known2Index: number, positions: Coord[], velocities: Coord[], accelerations: Coord[]): { velocity: Coord, acceleration: Coord } {
-        //velocity
-        const v_k1: Coord = velocities[known1Index];
-        const v_k2: Coord = velocities[known2Index];
-        const pos_j: Coord = positions[jointIndex];
-        const diff_jk1: Coord = new Coord(pos_j.x - positions[known1Index].x, pos_j.y - positions[known1Index].y);
-        const diff_jk2: Coord = new Coord(pos_j.x - positions[known2Index].x, pos_j.y - positions[known2Index].y);
-        const perp_angle_jk1: number = Math.atan2(diff_jk1.y, diff_jk1.x) + Math.PI / 2;
-        const perp_angle_jk2: number = Math.atan2(diff_jk2.y, diff_jk2.x) + Math.PI / 2;
-        const jointVelocity: Coord = this.parametricLineIntersection(v_k1, perp_angle_jk1, v_k2, perp_angle_jk2);
-        //acceleration of k1 + (V_k1j^2 / (k1-j)) for centripetal,
-        const x_centripetal_accel_jk1: number = accelerations[known1Index].x + Math.pow(jointVelocity.x, 2) / (-diff_jk1.x);
-        const y_centripetal_accel_jk1: number = accelerations[known1Index].y + Math.pow(jointVelocity.y, 2) / (-diff_jk1.y);
-        const x_centripetal_accel_jk2: number = accelerations[known2Index].x + Math.pow(jointVelocity.x, 2) / (-diff_jk2.x);
-        const y_centripetal_accel_jk2: number = accelerations[known2Index].y + Math.pow(jointVelocity.y, 2) / (-diff_jk2.y);
-        const centripetal_accel_jk1: Coord = new Coord(x_centripetal_accel_jk1, y_centripetal_accel_jk1);
-        const centripetal_accel_jk2: Coord = new Coord(x_centripetal_accel_jk2, y_centripetal_accel_jk2);
-        const jointAcceleration: Coord = this.parametricLineIntersection(centripetal_accel_jk1, perp_angle_jk1, centripetal_accel_jk2, perp_angle_jk2);
-        return { velocity: jointVelocity, acceleration: jointAcceleration };
+  }
+
+  // Solves kinematics for a specific submechanism given its solve order and joint positions.
+  solveSubmechanimsKinematics(solveOrder: SolveOrder, jointPositions: AnimationPositions) {
+    /**we are given the animation positions and solve order for a submechanism
+     * 1. iterate over each set of positions to solve
+     * 2. call a function that returns all relevant calculations
+     * 3. update jointKinematics
+     */
+    let mechanismVelocities: Coord[][] = [];
+    let mechanismAccelerations: Coord[][] = [];
+    for (let time = 0; time < jointPositions.positions.length; time++) {
+      let solutions = this.solveJointKinematics(solveOrder, jointPositions.positions[time]);
+      mechanismVelocities.push(solutions.velocities);
+      mechanismAccelerations.push(solutions.accelerations);
     }
-
-    // Determines velocity and acceleration for a joint constrained by a circle and a line using known index, prerequisites, positions, velocities, and accelerations.
-    solveCircleLineJointKinematics(jointIndex: number, known1Index: number, prereq: SolvePrerequisite, positions: Coord[], velocities: Coord[], accelerations: Coord[]): { velocity: Coord, acceleration: Coord } {
-        //velocity
-        const v_k1: Coord = velocities[known1Index];
-        const diff_jk1: Coord = new Coord(positions[jointIndex].x - positions[known1Index].x, positions[jointIndex].y - positions[known1Index].y);
-        const perp_angle_jk1: number = Math.atan2(diff_jk1.y, diff_jk1.x) + Math.PI / 2;
-        const jointVelocity: Coord = this.parametricLineIntersection(v_k1, perp_angle_jk1, new Coord(0, 0), prereq.jointToSolve.angle);
-        //acceleration
-        const x_centripetal_accel_jk1: number = accelerations[known1Index].x + Math.pow(jointVelocity.x, 2) / (-diff_jk1.x);
-        const y_centripetal_accel_jk1: number = accelerations[known1Index].y + Math.pow(jointVelocity.y, 2) / (-diff_jk1.y);
-        const centripetal_accel_jk1: Coord = new Coord(x_centripetal_accel_jk1, y_centripetal_accel_jk1);
-        const jointAcceleration: Coord = this.parametricLineIntersection(centripetal_accel_jk1, perp_angle_jk1, new Coord(0, 0), prereq.jointToSolve.angle);
-        return { velocity: jointVelocity, acceleration: jointAcceleration };
+    const arrayColumn = (array: Coord[][], columnIndex: number) => array.map(row => row[columnIndex])
+    this.jointKinematics = new Map();
+    let inputspeed: number = solveOrder.prerequisites.get(solveOrder.order[0])!.jointToSolve.inputSpeed;
+    let timeIncrement: number = 60 / (inputspeed * 360);
+    for (let i = 0; i < solveOrder.order.length; i++) {
+      let accelerations = arrayColumn(mechanismAccelerations, i);
+      let velocities = arrayColumn(mechanismVelocities, i);
+      let positions = arrayColumn(jointPositions.positions, i);
+      let joint: JointAnalysis = {
+        timeIncrement: timeIncrement,
+        positions: positions,
+        velocities: velocities,
+        accelerations: accelerations
+      }
+      this.jointKinematics.set(solveOrder.order[i], joint);
     }
-    // Finds the intersection point of two parametric lines defined by starting coordinates and angles.
-    parametricLineIntersection(pos1: Coord, theta1: number, pos2: Coord, theta2: number): Coord {
-        const t_2 = ((pos1.y - pos2.y) + ((pos2.x - pos1.x) / Math.cos(theta1))) / ((Math.sin(theta2)) - (Math.cos(theta2) / Math.cos(theta1)));
-        const x_intersection = pos2.x + (t_2 * Math.cos(theta2));
-        const y_intersection = pos2.y + (t_2 * Math.sin(theta2));
-        return new Coord(x_intersection, y_intersection);
+  }
+
+  // Computes velocities and accelerations for all joints in a solve order at a single time step.
+  solveJointKinematics(solveOrder: SolveOrder, positions: Coord[]): { velocities: Coord[], accelerations: Coord[] } {
+    let velocities: Coord[] = [];
+    let accelerations: Coord[] = [];
+
+    for (let index = 0; index < solveOrder.order.length; index++) {
+      let id = solveOrder.order[index];
+      let prereq = solveOrder.prerequisites.get(id)!;
+      let velocity_acceleration: { velocity: Coord, acceleration: Coord };
+      switch (prereq.solveType) {
+        case SolveType.Ground:
+          velocities.push(new Coord(0, 0));
+          accelerations.push(new Coord(0, 0));
+          break;
+        case SolveType.RevoluteInput:
+          velocity_acceleration = this.solveRevInputJointKinematics(index, prereq, positions);
+          velocities.push(velocity_acceleration.velocity);
+          accelerations.push(velocity_acceleration.acceleration);
+          break;
+        case SolveType.PrismaticInput:
+          velocity_acceleration = this.solvePrisInputJointKinematics(prereq);
+          velocities.push(velocity_acceleration.velocity);
+          accelerations.push(velocity_acceleration.acceleration);
+          break;
+        case SolveType.CircleCircle:
+          let knownIndex1 = solveOrder.order.indexOf(prereq.knownJointOne!.id);
+          let knownIndex2 = solveOrder.order.indexOf(prereq.knownJointTwo!.id);
+          velocity_acceleration = this.solveCircleCirlceJointKinematics(index, knownIndex1, knownIndex2, positions, velocities, accelerations);
+          velocities.push(velocity_acceleration.velocity);
+          accelerations.push(velocity_acceleration.acceleration);
+          break;
+        case SolveType.CircleLine:
+          knownIndex1 = solveOrder.order.indexOf(prereq.knownJointOne!.id);
+          velocity_acceleration = this.solveCircleLineJointKinematics(index, knownIndex1, prereq, positions, velocities, accelerations)
+          velocities.push(velocity_acceleration.velocity);
+          accelerations.push(velocity_acceleration.acceleration);
+          break;
+      }
     }
-
-    // Retrieves stored kinematic analysis (positions, velocities, accelerations) for a specific joint ID.
-    getJointKinematics(jointID: number): JointAnalysis {
-        return this.jointKinematics.get(jointID)!;
+    return {velocities: velocities, accelerations: accelerations};
+  }
+
+  //need to account for switching directions
+  /**
+   * Solves for the velocity and acceleration of a joint connected to a grounded revolute input
+   * @param jointIndex - an index for the joint to be solved within with positions array.
+   * @param prereq - a SolvePrerequisite that corresponds to that joint.
+   * @param positions - an array of joint positions for a particular timestep.
+   * @returns
+   */
+  solveRevInputJointKinematics(jointIndex: number, prereq: SolvePrerequisite, positions: Coord[]): {
+    velocity: Coord,
+    acceleration: Coord
+  } {
+
+    const xDifference = positions[jointIndex].x - positions[0].x;
+    const yDifference = positions[jointIndex].y - positions[0].y;
+    const angleToInput: number = Math.atan2(yDifference, xDifference);
+    const omega: number = 2 * Math.PI * (prereq.knownJointOne!.inputSpeed / 60); //Angular Velocity of Link in Radians
+    const r: number = prereq.distFromKnownJointOne!;
+
+    //velocity
+    const velocityMagnitude = r * omega; //Velocity magnitude
+    const velocityTheta = omega > 0 ? angleToInput - Math.PI / 2 : angleToInput + Math.PI / 2; //Velocity direction
+    const xVelocity: number = Math.cos(velocityTheta) * velocityMagnitude;
+    const yVelocity: number = Math.sin(velocityTheta) * velocityMagnitude;
+    const jointVelocity: Coord = new Coord(xVelocity, yVelocity);
+    //acceleration
+    const xAcceleration: number = -Math.cos(angleToInput) * velocityMagnitude * omega;
+    const yAcceleration: number = -Math.sin(angleToInput) * velocityMagnitude * omega;
+    const jointAcceleration: Coord = new Coord(xAcceleration, yAcceleration);
+    return {velocity: jointVelocity, acceleration: jointAcceleration};
+  }
+
+  // Calculates velocity and acceleration for a prismatic input joint from its prerequisites.
+  solvePrisInputJointKinematics(prereq: SolvePrerequisite): { velocity: Coord, acceleration: Coord } {
+    const velocityMag = prereq.jointToSolve.inputSpeed * (0.05 * 6) //Kinematic solver generates frames for 0.05m increments, and animator uses Rev-Input timeInterval calculation
+    const velocityTheta = prereq.jointToSolve.angle;
+    const deltaX: number = Math.cos(velocityTheta) * velocityMag;
+    const deltaY: number = Math.sin(velocityTheta) * velocityMag;
+    const jointVelocity: Coord = new Coord(deltaX, deltaY);
+    const jointAcceleration: Coord = new Coord(0, 0);
+    return {velocity: jointVelocity, acceleration: jointAcceleration};
+  }
+
+  // Determines velocity and acceleration for a joint constrained by two circular motions using known indices, positions, velocities, and accelerations.
+  solveCircleCirlceJointKinematics(jointIndex: number, known1Index: number, known2Index: number, positions: Coord[], velocities: Coord[], accelerations: Coord[]): {
+    velocity: Coord,
+    acceleration: Coord
+  } {
+    //velocity
+    const v_k1: Coord = velocities[known1Index];
+    const v_k2: Coord = velocities[known2Index];
+    const pos_j: Coord = positions[jointIndex];
+    const diff_jk1: Coord = new Coord(pos_j.x - positions[known1Index].x, pos_j.y - positions[known1Index].y);
+    const diff_jk2: Coord = new Coord(pos_j.x - positions[known2Index].x, pos_j.y - positions[known2Index].y);
+    const perp_angle_jk1: number = Math.atan2(diff_jk1.y, diff_jk1.x) + Math.PI / 2;
+    const perp_angle_jk2: number = Math.atan2(diff_jk2.y, diff_jk2.x) + Math.PI / 2;
+    const jointVelocity: Coord = this.parametricLineIntersection(v_k1, perp_angle_jk1, v_k2, perp_angle_jk2);
+    //acceleration of k1 + (V_k1j^2 / (k1-j)) for centripetal,
+    const x_centripetal_accel_jk1: number = accelerations[known1Index].x + Math.pow(jointVelocity.x, 2) / (-diff_jk1.x);
+    const y_centripetal_accel_jk1: number = accelerations[known1Index].y + Math.pow(jointVelocity.y, 2) / (-diff_jk1.y);
+    const x_centripetal_accel_jk2: number = accelerations[known2Index].x + Math.pow(jointVelocity.x, 2) / (-diff_jk2.x);
+    const y_centripetal_accel_jk2: number = accelerations[known2Index].y + Math.pow(jointVelocity.y, 2) / (-diff_jk2.y);
+    const centripetal_accel_jk1: Coord = new Coord(x_centripetal_accel_jk1, y_centripetal_accel_jk1);
+    const centripetal_accel_jk2: Coord = new Coord(x_centripetal_accel_jk2, y_centripetal_accel_jk2);
+    const jointAcceleration: Coord = this.parametricLineIntersection(centripetal_accel_jk1, perp_angle_jk1, centripetal_accel_jk2, perp_angle_jk2);
+    return {velocity: jointVelocity, acceleration: jointAcceleration};
+  }
+
+  // Determines velocity and acceleration for a joint constrained by a circle and a line using known index, prerequisites, positions, velocities, and accelerations.
+  solveCircleLineJointKinematics(jointIndex: number, known1Index: number, prereq: SolvePrerequisite, positions: Coord[], velocities: Coord[], accelerations: Coord[]): {
+    velocity: Coord,
+    acceleration: Coord
+  } {
+    //velocity
+    const v_k1: Coord = velocities[known1Index];
+    const diff_jk1: Coord = new Coord(positions[jointIndex].x - positions[known1Index].x, positions[jointIndex].y - positions[known1Index].y);
+    const perp_angle_jk1: number = Math.atan2(diff_jk1.y, diff_jk1.x) + Math.PI / 2;
+    const jointVelocity: Coord = this.parametricLineIntersection(v_k1, perp_angle_jk1, new Coord(0, 0), prereq.jointToSolve.angle);
+    //acceleration
+    const x_centripetal_accel_jk1: number = accelerations[known1Index].x + Math.pow(jointVelocity.x, 2) / (-diff_jk1.x);
+    const y_centripetal_accel_jk1: number = accelerations[known1Index].y + Math.pow(jointVelocity.y, 2) / (-diff_jk1.y);
+    const centripetal_accel_jk1: Coord = new Coord(x_centripetal_accel_jk1, y_centripetal_accel_jk1);
+    const jointAcceleration: Coord = this.parametricLineIntersection(centripetal_accel_jk1, perp_angle_jk1, new Coord(0, 0), prereq.jointToSolve.angle);
+    return {velocity: jointVelocity, acceleration: jointAcceleration};
+  }
+
+  // Finds the intersection point of two parametric lines defined by starting coordinates and angles.
+  parametricLineIntersection(pos1: Coord, theta1: number, pos2: Coord, theta2: number): Coord {
+    const t_2 = ((pos1.y - pos2.y) + ((pos2.x - pos1.x) / Math.cos(theta1))) / ((Math.sin(theta2)) - (Math.cos(theta2) / Math.cos(theta1)));
+    const x_intersection = pos2.x + (t_2 * Math.cos(theta2));
+    const y_intersection = pos2.y + (t_2 * Math.sin(theta2));
+    return new Coord(x_intersection, y_intersection);
+  }
+
+  // Retrieves stored kinematic analysis (positions, velocities, accelerations) for a specific joint ID.
+  getJointKinematics(jointID: number): JointAnalysis {
+    return this.jointKinematics.get(jointID)!;
+  }
+
+  // Converts joint kinematic data into arrays suitable for plotting, based on requested data type (position, velocity, or acceleration).
+  transformJointKinematicGraph(jointAnalysis: JointAnalysis, dataOf: string): {
+    xData: any[],
+    yData: any[],
+    timeLabels: string[]
+  } {
+    const xData: any[] = [];
+    const yData: any[] = [];
+    const timeLabels: string[] = [];
+
+    switch (dataOf) {
+      case ("Position"):
+        xData.push({data: jointAnalysis.positions.map(coord => coord.x), label: "X data of Position"});
+        yData.push({data: jointAnalysis.positions.map(coord => coord.y), label: "Y data of Position"});
+        timeLabels.push(...jointAnalysis.positions.map((_, index) => String(index)));
+
+        return {xData, yData, timeLabels};
+
+      case ("Velocity"):
+        xData.push({data: jointAnalysis.velocities.map(coord => coord.x), label: "X data of Velocity"});
+        yData.push({data: jointAnalysis.velocities.map(coord => coord.y), label: "Y data of Velocity"});
+        timeLabels.push(...jointAnalysis.velocities.map((_, index) => String(index)));
+
+        return {xData, yData, timeLabels};
+
+      case ("Acceleration"):
+        xData.push({data: jointAnalysis.accelerations.map(coord => coord.x), label: "X data of Acceleration"});
+        yData.push({data: jointAnalysis.accelerations.map(coord => coord.y), label: "Y data of Acceleration"});
+        timeLabels.push(...jointAnalysis.accelerations.map((_, index) => String(index)));
+
+        return {xData, yData, timeLabels};
+
+      default:
+        console.error("Invalid Graph type detected! Returning default values.")
+        return {xData, yData, timeLabels};
     }
 
-    // Converts joint kinematic data into arrays suitable for plotting, based on requested data type (position, velocity, or acceleration).
-    transformJointKinematicGraph(jointAnalysis: JointAnalysis, dataOf: string): { xData: any[], yData: any[], timeLabels: string[] } {
-        const xData: any[] = [];
-        const yData: any[] = [];
-        const timeLabels: string[] = [];
+  }
 
-        switch (dataOf) {
-            case ("Position"):
-                xData.push({ data: jointAnalysis.positions.map(coord => coord.x), label: "X data of Position" });
-                yData.push({ data: jointAnalysis.positions.map(coord => coord.y), label: "Y data of Position" });
-                timeLabels.push(...jointAnalysis.positions.map((_, index) => String(index)));
+  // Converts link kinematic data into arrays suitable for plotting, based on requested data type (angle, velocity, or acceleration).
+  transformLinkKinematicGraph(linkAnalysis: LinkAnalysis, dataOf: string): {
+    xData: any[],
+    yData: any[],
+    timeLabels: string[]
+  } {
+    const xData: any[] = [];
+    const yData: any[] = [];
+    const timeLabels: string[] = [];
 
-                return { xData, yData, timeLabels };
+    switch (dataOf) {
+      case ("Angle"):
+        xData.push({data: linkAnalysis.angle, label: "Angle of Reference Joint"});
+        timeLabels.push(...linkAnalysis.angle.map((_, index) => String(index)));
 
-            case ("Velocity"):
-                xData.push({ data: jointAnalysis.velocities.map(coord => coord.x), label: "X data of Velocity" });
-                yData.push({ data: jointAnalysis.velocities.map(coord => coord.y), label: "Y data of Velocity" });
-                timeLabels.push(...jointAnalysis.velocities.map((_, index) => String(index)));
+        return {xData, yData, timeLabels};
 
-                return { xData, yData, timeLabels };
+      case ("Velocity"):
+        // xData.push({data: linkAnalysis.angularVelocity.map(a => ), label: "Angular Velocity"});
+        // xData.push({data: linkAnalysis.angularVelocity, label: "Angular Velocity"});
+        xData.push({data: linkAnalysis.angularVelocity, label: "Angular Velocity (rad/s)"});
+        timeLabels.push(...linkAnalysis.angularVelocity.map((_, index) => String(index)));
 
-            case ("Acceleration"):
-                xData.push({ data: jointAnalysis.accelerations.map(coord => coord.x), label: "X data of Acceleration" });
-                yData.push({ data: jointAnalysis.accelerations.map(coord => coord.y), label: "Y data of Acceleration" });
-                timeLabels.push(...jointAnalysis.accelerations.map((_, index) => String(index)));
+        return {xData, yData, timeLabels};
 
-                return { xData, yData, timeLabels };
+      case ("Acceleration"):
+        xData.push({data: linkAnalysis.angularAcceleration, label: "Angular Acceleration"});
+        timeLabels.push(...linkAnalysis.angularAcceleration.map((_, index) => String(index)));
 
-            default:
-                console.error("Invalid Graph type detected! Returning default values.")
-                return { xData, yData, timeLabels };
-        }
+        return {xData, yData, timeLabels};
 
+      default:
+        console.error("Invalid Graph type detected! Returning default values.")
+        return {xData, yData, timeLabels};
     }
 
-    // Converts link kinematic data into arrays suitable for plotting, based on requested data type (angle, velocity, or acceleration).
-    transformLinkKinematicGraph(linkAnalysis: LinkAnalysis, dataOf: string): { xData: any[], yData: any[], timeLabels: string[] } {
-        const xData: any[] = [];
-        const yData: any[] = [];
-        const timeLabels: string[] = [];
-
-        switch (dataOf) {
-            case ("Angle"):
-                xData.push({ data: linkAnalysis.angle, label: "Angle of Reference Joint" });
-                timeLabels.push(...linkAnalysis.angle.map((_, index) => String(index)));
-
-                return { xData, yData, timeLabels };
-
-            case ("Velocity"):
-                xData.push({ data: linkAnalysis.angularVelocity, label: "Angular Velocity" });
-                timeLabels.push(...linkAnalysis.angularVelocity.map((_, index) => String(index)));
-
-                return { xData, yData, timeLabels };
-
-            case ("Acceleration"):
-                xData.push({ data: linkAnalysis.angularAcceleration, label: "Angular Acceleration" });
-                timeLabels.push(...linkAnalysis.angularAcceleration.map((_, index) => String(index)));
-
-                return { xData, yData, timeLabels };
-
-            default:
-                console.error("Invalid Graph type detected! Returning default values.")
-                return { xData, yData, timeLabels };
-        }
-
-    }
-    // Computes center-of-mass and angular kinematics for a link given its associated joint IDs.
-    getLinkKinematics(jointIDs: number[]): LinkAnalysis {
-        let subJoints: JointAnalysis[] = [];
-        for (let id of jointIDs) {
-            subJoints.push(this.jointKinematics.get(id)!);
-        }
-        let com_solutions: { pos: Coord[], vel: Coord[], acc: Coord[] } = this.getLinkCOMSolutions(subJoints);
-        let angle_solutions: { ang: number[], vel: number[], acc: number[] } = this.getLinkAngularSolutions(subJoints);
-        return {
-            timeIncrement: subJoints[0].timeIncrement,
-            COMpositions: com_solutions.pos,
-            COMvelocities: com_solutions.vel,
-            COMaccelerations: com_solutions.acc,
-            angle: angle_solutions.ang,
-            angularVelocity: angle_solutions.vel,
-            angularAcceleration: angle_solutions.acc,
-        } as LinkAnalysis
-
+  }
+
+  // Computes center-of-mass and angular kinematics for a link given its associated joint IDs.
+  getLinkKinematics(jointIDs: number[]): LinkAnalysis {
+    let subJoints: JointAnalysis[] = [];
+    console.log('=== getLinkKinematics called ===');
+    console.log('Joint IDs passed in:', jointIDs);
+
+    for (let id of jointIDs) {
+      const jointData = this.jointKinematics.get(id);
+      console.log(
+        `  JointID=${id}`,
+        'first pos =', jointData?.positions[0]
+      );
+      subJoints.push(jointData!);
     }
-    // Calculates center-of-mass positions, velocities, and accelerations from joint-level kinematic data for a link.
-    getLinkCOMSolutions(subJoints: JointAnalysis[]) {
-        let com_positions: Coord[] = [];
-        let com_velocities: Coord[] = [];
-        let com_accelerations: Coord[] = [];
-        for (let time = 0; time < subJoints[0].positions.length; time++) {
-            let x_pos: number = 0;
-            let y_pos: number = 0;
-            let x_vel: number = 0;
-            let y_vel: number = 0;
-            let x_acc: number = 0;
-            let y_acc: number = 0;
-            let denominator: number = subJoints.length;
-            for (let joint of subJoints) {
-                x_pos += joint.positions[time].x;
-                y_pos += joint.positions[time].y;
-                x_vel += joint.velocities[time].x;
-                y_vel += joint.velocities[time].y;
-                x_acc += joint.accelerations[time].x;
-                y_acc += joint.accelerations[time].y;
-            }
-            com_positions.push(new Coord(x_pos / denominator, y_pos / denominator));
-            com_velocities.push(new Coord(x_vel / denominator, y_vel / denominator));
-            com_accelerations.push(new Coord(x_acc / denominator, y_acc / denominator))
-        }
-        return { pos: com_positions, vel: com_velocities, acc: com_accelerations }
+    let com_solutions: { pos: Coord[], vel: Coord[], acc: Coord[] } = this.getLinkCOMSolutions(subJoints);
+    let angle_solutions: { ang: number[], vel: number[], acc: number[] } = this.getLinkAngularSolutions(subJoints);
+    return {
+      timeIncrement: subJoints[0].timeIncrement,
+      COMpositions: com_solutions.pos,
+      COMvelocities: com_solutions.vel,
+      COMaccelerations: com_solutions.acc,
+      angle: angle_solutions.ang,
+      angularVelocity: angle_solutions.vel,
+      angularAcceleration: angle_solutions.acc,
+    } as LinkAnalysis
+
+  }
+
+  // Calculates center-of-mass positions, velocities, and accelerations from joint-level kinematic data for a link.
+  getLinkCOMSolutions(subJoints: JointAnalysis[]) {
+    let com_positions: Coord[] = [];
+    let com_velocities: Coord[] = [];
+    let com_accelerations: Coord[] = [];
+    for (let time = 0; time < subJoints[0].positions.length; time++) {
+      let x_pos: number = 0;
+      let y_pos: number = 0;
+      let x_vel: number = 0;
+      let y_vel: number = 0;
+      let x_acc: number = 0;
+      let y_acc: number = 0;
+      let denominator: number = subJoints.length;
+      for (let joint of subJoints) {
+        x_pos += joint.positions[time].x;
+        y_pos += joint.positions[time].y;
+        x_vel += joint.velocities[time].x;
+        y_vel += joint.velocities[time].y;
+        x_acc += joint.accelerations[time].x;
+        y_acc += joint.accelerations[time].y;
+      }
+      com_positions.push(new Coord(x_pos / denominator, y_pos / denominator));
+      com_velocities.push(new Coord(x_vel / denominator, y_vel / denominator));
+      com_accelerations.push(new Coord(x_acc / denominator, y_acc / denominator))
     }
-
-    // Calculates angular positions, velocities, and accelerations for a link using two joint-level kinematic analyses.
-    getLinkAngularSolutions(subJoints: JointAnalysis[]) {
-        let ang_pos: number[] = [];
-        let ang_vel: number[] = [];
-        let ang_acc: number[] = [];
-        for (let time = 0; time < subJoints[0].positions.length; time++) {
-            let x_diff_pos: number = subJoints[1].positions[time].x - subJoints[0].positions[time].x;
-            let y_diff_pos: number = subJoints[1].positions[time].y - subJoints[0].positions[time].y;
-            let ang: number = Math.atan2(y_diff_pos, x_diff_pos);
-            let x_diff_vel: number = subJoints[1].velocities[time].x - subJoints[0].velocities[time].x;
-            let y_diff_vel: number = subJoints[1].velocities[time].y - subJoints[0].velocities[time].y;
-            let V_BA: number = Math.sqrt(Math.pow(x_diff_vel, 2) + Math.pow(y_diff_vel, 2));
-            let R_BA: number = Math.sqrt(Math.pow(x_diff_pos, 2) + Math.pow(y_diff_pos, 2));
-            let vel: number = V_BA / R_BA;
-            let x_diff_acc: number = subJoints[1].accelerations[time].x - subJoints[0].accelerations[time].x;
-            let y_diff_acc: number = subJoints[1].accelerations[time].y - subJoints[0].accelerations[time].y;
-            let A_BA: number = Math.sqrt(Math.pow(x_diff_acc, 2) + Math.pow(y_diff_acc, 2));
-            let acc: number = A_BA / R_BA;
-            ang_pos.push(ang);
-            ang_vel.push(vel);
-            ang_acc.push(acc);
-        }
-        return { ang: ang_pos, vel: ang_vel, acc: ang_acc };
+    return {pos: com_positions, vel: com_velocities, acc: com_accelerations}
+  }
+
+  // Calculates angular positions, velocities, and accelerations for all links.
+  getLinkAngularSolutions(subJoints: JointAnalysis[]) {
+
+    let ang_pos: number[] = [];
+    let ang_vel: number[] = [];
+    let ang_acc: number[] = [];
+
+    // Compute link lengths (r2 = AB, r3 = BC, r4 = CD)
+    const r2 = this.distance(subJoints[1].positions[0], subJoints[0].positions[0]);
+    const r3 = this.distance(subJoints[2].positions[0], subJoints[1].positions[0]);
+    const r4 = this.distance(subJoints[3].positions[0], subJoints[2].positions[0]);
+
+    // Input angular velocity ω2
+    const omega2 = 1.0472; // CHANGE TO BE SYSTEM
+
+    for (let time = 0; time < subJoints[0].positions.length; time++) {
+
+      const theta2 = Math.atan2(
+        subJoints[1].positions[time].y - subJoints[0].positions[time].y,
+        subJoints[1].positions[time].x - subJoints[0].positions[time].x
+      );
+
+      const theta3 = Math.atan2(
+        subJoints[2].positions[time].y - subJoints[1].positions[time].y,
+        subJoints[2].positions[time].x - subJoints[1].positions[time].x
+      );
+      const theta4 = Math.atan2(
+        subJoints[3].positions[time].y - subJoints[2].positions[time].y,
+        subJoints[3].positions[time].x - subJoints[2].positions[time].x
+      );
+
+      // Get angular velocity for links at postions at current time interval
+      const [omega3, omega4] = this.getAngularVelocities(
+        r2, r3, r4,
+        theta2, theta3, theta4,
+        omega2
+      );
+
+      // ang_vel.push(omega3);
+      // ang_pos.push(theta2, theta3, theta4);
+      // ang_vel.push(omega2, omega3, omega4);
+      ang_vel.push(omega2);
+
+      ang_acc.push(0);
     }
-
+    return {ang: ang_pos, vel: ang_vel, acc: ang_acc};
+  }
+
+  // Calculate unknown angular velocities of a 4 bar linkage // ω2k×r2+ω3k×r3−ω4k×r4=0
+  getAngularVelocities( r2: number, r3: number, r4: number, theta2: number, theta3: number, theta4: number, omega2: number ) {
+    let ang_vel: number[] = [];
+
+    // Build A matrix (2x2) for unknowns
+    const A = math.matrix([ [-r3 * Math.sin(theta3), r4 * Math.sin(theta4)], [ r3 * Math.cos(theta3), -r4 * Math.cos(theta4)], ]);
+    // Build right-hand side B (2x1)
+    const B = math.matrix([ [ r2 * omega2 * Math.sin(theta2) ], [-r2 * omega2 * Math.cos(theta2) ], ]);
+
+    // Solve for unknowns (system of equations)
+    const sol = math.lusolve(A, B) as any;
+
+    // get each row (0, 1) in sol matrix
+    const omega3 = sol.get([0, 0]) as number;
+    const omega4 = sol.get([1, 0]) as number;
+    ang_vel.push(omega3);
+    ang_vel.push(omega4);
+    return ang_vel;
+  }
+
+  // Calculate position distance between 2 joints
+  distance(a: Coord, b: Coord) {
+    return Math.sqrt((b.x - a.x) ** 2 + (b.y - a.y) ** 2);
+  }
 
 }
+

From 0db0ef783f40e2536c43d6f41ccd6fbc77757f2b Mon Sep 17 00:00:00 2001
From: mwalsh001 <matty71604@gmail.com>
Date: Sun, 30 Nov 2025 22:06:32 -0500
Subject: [PATCH 07/23] Angular velocity graph now displays the angular
 velocity of the currently selected link on the grid.

---
 .../link-analysis-panel.component.ts            | 15 +++++++++++----
 src/app/services/analysis-solver.service.ts     | 17 ++++++++++-------
 2 files changed, 21 insertions(+), 11 deletions(-)

diff --git a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
index d183079f..1036b9a4 100644
--- a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
+++ b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
@@ -162,7 +162,7 @@ export class LinkAnalysisPanelComponent {
         if(this.getReferenceJoint() !== undefined) {
           let joints = this.getCurrentLink().getJoints();
           let jointIds = joints.map(joint => joint.id);
-          let linkKinematics = this.analysisSolverService.getLinkKinematics(jointIds);
+          let linkKinematics = this.analysisSolverService.getLinkKinematics(jointIds, -1);
           return this.analysisSolverService.transformLinkKinematicGraph(linkKinematics, "Angle");
         }
         return {
@@ -173,9 +173,13 @@ export class LinkAnalysisPanelComponent {
 
       case GraphType.referenceJointAngularVelocity:
         if(this.getReferenceJoint() !== undefined) {
+          let currentLinkId = this.getCurrentLink().id;
+          const links = this.getMechanism().getArrayOfLinks();
+          const linkIndex = links.findIndex(link => link.id === currentLinkId);
+
           let joints = this.getMechanism().getArrayOfJoints();
           let jointIds = joints.map(joint => joint.id);
-          let linkKinematics = this.analysisSolverService.getLinkKinematics(jointIds);
+          let linkKinematics = this.analysisSolverService.getLinkKinematics(jointIds, linkIndex);
           return this.analysisSolverService.transformLinkKinematicGraph(linkKinematics, "Velocity");
         }
         return {
@@ -188,7 +192,7 @@ export class LinkAnalysisPanelComponent {
         if(this.getReferenceJoint() !== undefined) {
           let joints = this.getCurrentLink().getJoints();
           let jointIds = joints.map(joint => joint.id);
-          let linkKinematics = this.analysisSolverService.getLinkKinematics(jointIds);
+          let linkKinematics = this.analysisSolverService.getLinkKinematics(jointIds, -1);
           return this.analysisSolverService.transformLinkKinematicGraph(linkKinematics, "Acceleration");
         }
         return {
@@ -249,5 +253,8 @@ export class LinkAnalysisPanelComponent {
     document.body.removeChild(link);
   }
 
-
+  getCurrentLinkId(): number | null {
+    const link = this.getCurrentLink();
+    return link ? link.id : null;
+  }
 }
diff --git a/src/app/services/analysis-solver.service.ts b/src/app/services/analysis-solver.service.ts
index 9e297211..1cc31723 100644
--- a/src/app/services/analysis-solver.service.ts
+++ b/src/app/services/analysis-solver.service.ts
@@ -304,7 +304,7 @@ export class AnalysisSolveService {
   }
 
   // Computes center-of-mass and angular kinematics for a link given its associated joint IDs.
-  getLinkKinematics(jointIDs: number[]): LinkAnalysis {
+  getLinkKinematics(jointIDs: number[], linkIndex: number): LinkAnalysis {
     let subJoints: JointAnalysis[] = [];
     console.log('=== getLinkKinematics called ===');
     console.log('Joint IDs passed in:', jointIDs);
@@ -318,7 +318,7 @@ export class AnalysisSolveService {
       subJoints.push(jointData!);
     }
     let com_solutions: { pos: Coord[], vel: Coord[], acc: Coord[] } = this.getLinkCOMSolutions(subJoints);
-    let angle_solutions: { ang: number[], vel: number[], acc: number[] } = this.getLinkAngularSolutions(subJoints);
+    let angle_solutions: { ang: number[], vel: number[], acc: number[] } = this.getLinkAngularSolutions(subJoints, linkIndex);
     return {
       timeIncrement: subJoints[0].timeIncrement,
       COMpositions: com_solutions.pos,
@@ -360,7 +360,7 @@ export class AnalysisSolveService {
   }
 
   // Calculates angular positions, velocities, and accelerations for all links.
-  getLinkAngularSolutions(subJoints: JointAnalysis[]) {
+  getLinkAngularSolutions(subJoints: JointAnalysis[], linkIndex: number) {
 
     let ang_pos: number[] = [];
     let ang_vel: number[] = [];
@@ -397,11 +397,14 @@ export class AnalysisSolveService {
         omega2
       );
 
-      // ang_vel.push(omega3);
-      // ang_pos.push(theta2, theta3, theta4);
-      // ang_vel.push(omega2, omega3, omega4);
-      ang_vel.push(omega2);
+      const thetas = [theta2, theta3, theta4];
+      const omegas = [omega2, omega3, omega4];
 
+      const thetaForLink = thetas[linkIndex] ?? 0;
+      const omegaForLink = omegas[linkIndex] ?? 0;
+
+      ang_pos.push(thetaForLink);
+      ang_vel.push(omegaForLink);
       ang_acc.push(0);
     }
     return {ang: ang_pos, vel: ang_vel, acc: ang_acc};

From c18201db0953e85b20c62e75bba6a3ef32ccc545 Mon Sep 17 00:00:00 2001
From: mwalsh001 <matty71604@gmail.com>
Date: Mon, 1 Dec 2025 12:34:57 -0500
Subject: [PATCH 08/23] Fixed "Download CSV button for angular velocity to
 download file for a selected link. Graph only has X data and function
 previously checked for X and Y data being present. Error found in Velocity
 calculations - sign of velocities are not consistent so that needs to be
 fixed."

---
 .../link-analysis-panel/link-analysis-panel.component.html | 2 +-
 .../link-analysis-panel/link-analysis-panel.component.ts   | 4 ++++
 src/app/services/analysis-solver.service.ts                | 7 +------
 3 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.html b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.html
index 149cbc86..de85da12 100644
--- a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.html
+++ b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.html
@@ -39,7 +39,7 @@
                              [btn1Action]="toggleGraph.bind(this, GraphType.referenceJointAngularVelocity)"
                              [graphText]= "currentGraphType === GraphType.referenceJointAngularVelocity ? 'Close Graph' : 'Show Graph'">></analysis-graph-button>
 
-      <p style="margin-left: 10px; margin-top: 1px;">ω: rad/s</p>
+      <p style="margin-left: 10px; margin-top: 1px;">ω: {{ "N/A" }} rad/s</p>
 <!--      getCurrentLinkAnalysis()-->
       <ng-container *ngIf="currentGraphType === GraphType.referenceJointAngularVelocity">
           <div class="modal" (keyup.escape)="closeAnalysisGraph()">
diff --git a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
index 1036b9a4..59c40e21 100644
--- a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
+++ b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
@@ -30,6 +30,7 @@ export class LinkAnalysisPanelComponent {
   referenceJoint: Joint = this.getCurrentLink().joints.get(0) as Joint;
   currentGlobalUSuffix: any;
   currentGlobalAngleSuffix: any;
+
   constructor(private stateService: StateService, private interactorService: InteractionService,
               private analysisSolverService: AnalysisSolveService){
                 this.stateService.globalUSuffixCurrent.subscribe(value => {
@@ -180,6 +181,7 @@ export class LinkAnalysisPanelComponent {
           let joints = this.getMechanism().getArrayOfJoints();
           let jointIds = joints.map(joint => joint.id);
           let linkKinematics = this.analysisSolverService.getLinkKinematics(jointIds, linkIndex);
+
           return this.analysisSolverService.transformLinkKinematicGraph(linkKinematics, "Velocity");
         }
         return {
@@ -211,6 +213,7 @@ export class LinkAnalysisPanelComponent {
   public GraphType = GraphType;
 
   downloadCSV() {
+    console.log("DOWNLOAD CSV====================================")
     const table = document.querySelector(".table-auto");
     if (!table) return;
 
@@ -257,4 +260,5 @@ export class LinkAnalysisPanelComponent {
     const link = this.getCurrentLink();
     return link ? link.id : null;
   }
+
 }
diff --git a/src/app/services/analysis-solver.service.ts b/src/app/services/analysis-solver.service.ts
index 1cc31723..ca8c21e6 100644
--- a/src/app/services/analysis-solver.service.ts
+++ b/src/app/services/analysis-solver.service.ts
@@ -306,19 +306,14 @@ export class AnalysisSolveService {
   // Computes center-of-mass and angular kinematics for a link given its associated joint IDs.
   getLinkKinematics(jointIDs: number[], linkIndex: number): LinkAnalysis {
     let subJoints: JointAnalysis[] = [];
-    console.log('=== getLinkKinematics called ===');
-    console.log('Joint IDs passed in:', jointIDs);
 
     for (let id of jointIDs) {
       const jointData = this.jointKinematics.get(id);
-      console.log(
-        `  JointID=${id}`,
-        'first pos =', jointData?.positions[0]
-      );
       subJoints.push(jointData!);
     }
     let com_solutions: { pos: Coord[], vel: Coord[], acc: Coord[] } = this.getLinkCOMSolutions(subJoints);
     let angle_solutions: { ang: number[], vel: number[], acc: number[] } = this.getLinkAngularSolutions(subJoints, linkIndex);
+
     return {
       timeIncrement: subJoints[0].timeIncrement,
       COMpositions: com_solutions.pos,

From 6fd7940c3b70c724af6e026fde1bdebe96c3d104 Mon Sep 17 00:00:00 2001
From: mwalsh001 <matty71604@gmail.com>
Date: Mon, 1 Dec 2025 13:14:16 -0500
Subject: [PATCH 09/23] Fixed sign issue for CD link, will need to be
 re-visited once loop selection is implemented to decide the direction of
 theta values i.e. CD or DC.

---
 src/app/services/analysis-solver.service.ts | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/app/services/analysis-solver.service.ts b/src/app/services/analysis-solver.service.ts
index ca8c21e6..5a79dc2f 100644
--- a/src/app/services/analysis-solver.service.ts
+++ b/src/app/services/analysis-solver.service.ts
@@ -381,8 +381,11 @@ export class AnalysisSolveService {
         subJoints[2].positions[time].x - subJoints[1].positions[time].x
       );
       const theta4 = Math.atan2(
-        subJoints[3].positions[time].y - subJoints[2].positions[time].y,
-        subJoints[3].positions[time].x - subJoints[2].positions[time].x
+        // Quick fix for proper sign, once loop selection is implemented, that will determine the order
+        subJoints[2].positions[time].y - subJoints[3].positions[time].y,
+        subJoints[2].positions[time].x - subJoints[3].positions[time].x
+        // subJoints[3].positions[time].y - subJoints[2].positions[time].y,
+        // subJoints[3].positions[time].x - subJoints[2].positions[time].x
       );
 
       // Get angular velocity for links at postions at current time interval

From d22118f381e522c583c4141f42a2065d07f8da33 Mon Sep 17 00:00:00 2001
From: mwalsh001 <matty71604@gmail.com>
Date: Mon, 8 Dec 2025 11:34:16 -0500
Subject: [PATCH 10/23] Show velocity for current link.

---
 .../graph-section/graph-section.component.ts  | 64 +++++++++++++------
 .../link-analysis-panel.component.ts          | 19 ++----
 src/app/services/analysis-solver.service.ts   |  4 +-
 3 files changed, 54 insertions(+), 33 deletions(-)

diff --git a/src/app/components/Blocks/graph-section/graph-section.component.ts b/src/app/components/Blocks/graph-section/graph-section.component.ts
index 05c72317..b5588de3 100644
--- a/src/app/components/Blocks/graph-section/graph-section.component.ts
+++ b/src/app/components/Blocks/graph-section/graph-section.component.ts
@@ -40,14 +40,14 @@ export class GraphSectionComponent implements OnInit, AfterViewInit, OnDestroy {
 
   @ViewChild('graphCanvas', { static: true }) private graphCanvas!: ElementRef<HTMLCanvasElement>;
   @ViewChild('overlayCanvas', { static: true }) private overlayCanvas!: ElementRef<HTMLCanvasElement>;
-  
+
 
 
   chart?: Chart;
   showGrid = true;
   showXCurve = true;
   showYCurve = true;
-  
+
   private readonly destroy$ = new Subject<void>();
 
   constructor(private readonly animationService: AnimationService, private interactionService: InteractionService) {}
@@ -73,10 +73,10 @@ export class GraphSectionComponent implements OnInit, AfterViewInit, OnDestroy {
   }
   private syncOverlayCanvas(): void {
     if (!this.chart) return;
-    
+
     const chartCanvas = this.graphCanvas.nativeElement;
     const overlay = this.overlayCanvas.nativeElement;
-  
+
     // Use the chart's display size, not internal resolution
     const rect = chartCanvas.getBoundingClientRect();
     overlay.width = rect.width;
@@ -106,7 +106,7 @@ export class GraphSectionComponent implements OnInit, AfterViewInit, OnDestroy {
       animation: false,
       hover: {
         mode: 'index',
-        intersect: false    
+        intersect: false
       },
       interaction: {
         mode: 'index',
@@ -173,17 +173,17 @@ export class GraphSectionComponent implements OnInit, AfterViewInit, OnDestroy {
 
   private get chartDatasets(): ChartDataset<'line'>[] {
     const datasets: ChartDataset<'line'>[] = [];
-    
+
     // Add X data if enabled - always use first color
     if (this.showXCurve && this.inputXData) {
       const xDatasets = this.inputXData.map((dataset, index) => ({
         ...dataset,
-        borderColor: this.colorScheme.domain[0], 
+        borderColor: this.colorScheme.domain[0],
         backgroundColor: this.colorScheme.domain[0]
       }));
       datasets.push(...xDatasets);
     }
-    
+
     // Add Y data if enabled - always use second color
     if (this.showYCurve && this.inputYData) {
       const yDatasets = this.inputYData.map((dataset, index) => ({
@@ -193,7 +193,7 @@ export class GraphSectionComponent implements OnInit, AfterViewInit, OnDestroy {
       }));
       datasets.push(...yDatasets);
     }
-    
+
     return datasets;
   }
 
@@ -226,17 +226,17 @@ export class GraphSectionComponent implements OnInit, AfterViewInit, OnDestroy {
 
   private updateGraphAtStep(step: number): void {
     if (!this.chart || !this.overlayCanvas) return;
-  
+
     const overlay = this.overlayCanvas.nativeElement;
     const ctx = overlay.getContext('2d');
     if (!ctx) return;
-  
+
     const xScale = this.chart.scales['x'];
     const xPos = xScale.getPixelForValue(step);
     if (xPos === undefined) return;
-  
+
     ctx.clearRect(0, 0, overlay.width, overlay.height);
-  
+
     ctx.beginPath();
     ctx.moveTo(xPos, this.chart.chartArea.top);
     ctx.lineTo(xPos, this.chart.chartArea.bottom);
@@ -248,7 +248,7 @@ export class GraphSectionComponent implements OnInit, AfterViewInit, OnDestroy {
   onToggleGrid(event: Event): void {
     const target = event.target as HTMLInputElement;
     this.showGrid = target.checked;
-    
+
     if (this.chart) {
       this.chart.destroy();
       this.createChart();
@@ -266,9 +266,35 @@ export class GraphSectionComponent implements OnInit, AfterViewInit, OnDestroy {
   }
 
   downloadCSV(): void {
-    if (!this.inputLabels?.length || !this.inputXData?.length || !this.inputYData?.length) return;
+    console.log('downloadCSV clicked!', {
+      labels: this.inputLabels,
+      x: this.inputXData,
+      y: this.inputYData
+    });
+
+    if (!this.inputLabels?.length) {
+      alert('No data to export.');
+      return;
+    }
+
+    const hasX = this.inputXData.length;
+    const hasY = this.inputYData.length;
+
+    if (!hasX && !hasY) {
+      alert('No data to export.');
+      return;
+    }
+
+    const header = ['Time'];
+    if (hasX) {
+      header.push(this.inputXData[0].label ?? "X Data");
+    }
+    if (hasY) {
+      header.push(this.inputYData[0].label ?? "Y Data");
+    }
+
+    const rows: string[] = [header.join(',')];
 
-    const rows = ['Time,X Data,Y Data'];
     const maxLength = Math.max(
       this.inputLabels.length,
       this.inputXData[0]?.data?.length || 0,
@@ -291,7 +317,7 @@ export class GraphSectionComponent implements OnInit, AfterViewInit, OnDestroy {
     const canvas = this.chart.canvas;
     const exportCanvas = document.createElement('canvas');
     const ctx = exportCanvas.getContext('2d');
-    
+
     if (!ctx) return;
 
     exportCanvas.width = canvas.width;
@@ -300,7 +326,7 @@ export class GraphSectionComponent implements OnInit, AfterViewInit, OnDestroy {
     // White background
     ctx.fillStyle = 'white';
     ctx.fillRect(0, 0, exportCanvas.width, exportCanvas.height);
-    
+
     // Temporarily hide vertical line
     const currentStep = (this.chart as any).currentTimeStep;
     delete (this.chart as any).currentTimeStep;
@@ -331,4 +357,4 @@ export class GraphSectionComponent implements OnInit, AfterViewInit, OnDestroy {
     link.download = filename;
     link.click();
   }
-}
\ No newline at end of file
+}
diff --git a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
index 59c40e21..d0ce4a54 100644
--- a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
+++ b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
@@ -145,6 +145,12 @@ export class LinkAnalysisPanelComponent {
   getGraphData() {
     this.analysisSolverService.updateKinematics();
     let jointKinematics: JointAnalysis;
+    let currentLinkId = this.getCurrentLink().id;
+    const links = this.getMechanism().getArrayOfLinks();
+    const linkIndex = links.findIndex(link => link.id === currentLinkId);
+    let joints = this.getMechanism().getArrayOfJoints();
+    let jointIds = joints.map(joint => joint.id);
+
     switch(this.currentGraphType) {
       case GraphType.CoMPosition:
         jointKinematics = this.analysisSolverService.getJointKinematics(this.getPlaceholderCoMJoint().id);
@@ -161,9 +167,7 @@ export class LinkAnalysisPanelComponent {
 
       case GraphType.referenceJointAngle:
         if(this.getReferenceJoint() !== undefined) {
-          let joints = this.getCurrentLink().getJoints();
-          let jointIds = joints.map(joint => joint.id);
-          let linkKinematics = this.analysisSolverService.getLinkKinematics(jointIds, -1);
+          let linkKinematics = this.analysisSolverService.getLinkKinematics(jointIds, linkIndex);
           return this.analysisSolverService.transformLinkKinematicGraph(linkKinematics, "Angle");
         }
         return {
@@ -174,14 +178,7 @@ export class LinkAnalysisPanelComponent {
 
       case GraphType.referenceJointAngularVelocity:
         if(this.getReferenceJoint() !== undefined) {
-          let currentLinkId = this.getCurrentLink().id;
-          const links = this.getMechanism().getArrayOfLinks();
-          const linkIndex = links.findIndex(link => link.id === currentLinkId);
-
-          let joints = this.getMechanism().getArrayOfJoints();
-          let jointIds = joints.map(joint => joint.id);
           let linkKinematics = this.analysisSolverService.getLinkKinematics(jointIds, linkIndex);
-
           return this.analysisSolverService.transformLinkKinematicGraph(linkKinematics, "Velocity");
         }
         return {
@@ -192,8 +189,6 @@ export class LinkAnalysisPanelComponent {
 
       case GraphType.referenceJointAngularAcceleration:
         if(this.getReferenceJoint() !== undefined) {
-          let joints = this.getCurrentLink().getJoints();
-          let jointIds = joints.map(joint => joint.id);
           let linkKinematics = this.analysisSolverService.getLinkKinematics(jointIds, -1);
           return this.analysisSolverService.transformLinkKinematicGraph(linkKinematics, "Acceleration");
         }
diff --git a/src/app/services/analysis-solver.service.ts b/src/app/services/analysis-solver.service.ts
index 5a79dc2f..99c32e21 100644
--- a/src/app/services/analysis-solver.service.ts
+++ b/src/app/services/analysis-solver.service.ts
@@ -3,7 +3,6 @@ import { Coord } from '../model/coord';
 import { PositionSolverService, SolveOrder, SolvePrerequisite, SolveType } from './kinematic-solver.service';
 import { AnimationPositions } from './kinematic-solver.service';
 import { create, all, MathJsInstance } from 'mathjs'
-import {link} from "d3-shape";
 
 export interface JointAnalysis {
   timeIncrement: number,
@@ -400,7 +399,8 @@ export class AnalysisSolveService {
 
       const thetaForLink = thetas[linkIndex] ?? 0;
       const omegaForLink = omegas[linkIndex] ?? 0;
-
+      console.log("THETAS: " + thetaForLink);
+      // ang_pos.push(thetaForLink);
       ang_pos.push(thetaForLink);
       ang_vel.push(omegaForLink);
       ang_acc.push(0);

From 3b9327f6cd754c52d0f4e3b83849d4ec9d1328f7 Mon Sep 17 00:00:00 2001
From: mwalsh001 <matty71604@gmail.com>
Date: Mon, 8 Dec 2025 12:14:03 -0500
Subject: [PATCH 11/23] Gets the current input speed of the mechanism from
 StateService to calculate velocity.

---
 src/app/services/analysis-solver.service.ts | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/app/services/analysis-solver.service.ts b/src/app/services/analysis-solver.service.ts
index 99c32e21..a0821768 100644
--- a/src/app/services/analysis-solver.service.ts
+++ b/src/app/services/analysis-solver.service.ts
@@ -3,6 +3,7 @@ import { Coord } from '../model/coord';
 import { PositionSolverService, SolveOrder, SolvePrerequisite, SolveType } from './kinematic-solver.service';
 import { AnimationPositions } from './kinematic-solver.service';
 import { create, all, MathJsInstance } from 'mathjs'
+import {StateService} from "./state.service";
 
 export interface JointAnalysis {
   timeIncrement: number,
@@ -32,8 +33,7 @@ export class AnalysisSolveService {
   private jointPositions: AnimationPositions[] = [];
   private jointKinematics: Map<number, JointAnalysis> = new Map();
 
-  constructor(private positionSolver: PositionSolverService) {
-
+  constructor(private positionSolver: PositionSolverService, private stateService: StateService,) {
   }
 
   // Updates kinematic data by fetching solve orders and joint positions, then solving submechanism kinematics.
@@ -355,7 +355,6 @@ export class AnalysisSolveService {
 
   // Calculates angular positions, velocities, and accelerations for all links.
   getLinkAngularSolutions(subJoints: JointAnalysis[], linkIndex: number) {
-
     let ang_pos: number[] = [];
     let ang_vel: number[] = [];
     let ang_acc: number[] = [];
@@ -366,8 +365,11 @@ export class AnalysisSolveService {
     const r4 = this.distance(subJoints[3].positions[0], subJoints[2].positions[0]);
 
     // Input angular velocity ω2
-    const omega2 = 1.0472; // CHANGE TO BE SYSTEM
+    const mechanism = this.stateService.getMechanism();
+    const rpm = mechanism.getInputSpeed();
+    const omega2 = 2 * Math.PI * (rpm / 60);
 
+    console.log("RPM: " + rpm + ", Omega2: " + omega2);
     for (let time = 0; time < subJoints[0].positions.length; time++) {
 
       const theta2 = Math.atan2(
@@ -399,8 +401,7 @@ export class AnalysisSolveService {
 
       const thetaForLink = thetas[linkIndex] ?? 0;
       const omegaForLink = omegas[linkIndex] ?? 0;
-      console.log("THETAS: " + thetaForLink);
-      // ang_pos.push(thetaForLink);
+      // console.log("THETAS: " + thetaForLink);
       ang_pos.push(thetaForLink);
       ang_vel.push(omegaForLink);
       ang_acc.push(0);

From cc159b5c80f5add1ae5bdf10e1e8df7450ffc993 Mon Sep 17 00:00:00 2001
From: mwalsh001 <matty71604@gmail.com>
Date: Mon, 26 Jan 2026 18:20:15 -0500
Subject: [PATCH 12/23] Calculate link lengths through mechanism state and not
 manually to get correct lengths for all link shapes. To account for compound
 links, find the joint pair within a link with the farthest distance to
 calculate the angle of each link over time. Then, use the matrix solver to
 find the omega values. Values are slightly off due to some sign and loop
 order inconsistencies.

---
 .../link-analysis-panel.component.ts          | 125 ++++++++++----
 src/app/services/analysis-solver.service.ts   | 158 ++++++++++++------
 2 files changed, 197 insertions(+), 86 deletions(-)

diff --git a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
index d0ce4a54..1dda4d5b 100644
--- a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
+++ b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
@@ -5,6 +5,7 @@ import {Mechanism} from "src/app/model/mechanism";
 import {LinkInteractor} from "src/app/controllers/link-interactor";
 import {Joint} from "src/app/model/joint";
 import {AnalysisSolveService, JointAnalysis, LinkAnalysis} from "src/app/services/analysis-solver.service";
+import {Coord} from "../../../../model/coord";
 
 // enum contains every kind of graph this panel can open.
 export enum GraphType {
@@ -207,53 +208,111 @@ export class LinkAnalysisPanelComponent {
   }
   public GraphType = GraphType;
 
-  downloadCSV() {
-    console.log("DOWNLOAD CSV====================================")
-    const table = document.querySelector(".table-auto");
-    if (!table) return;
+  // Re-write from original
+  downloadCSV(): void {
+    console.log("DOWNLOAD CSV (multi-link angular data)");
 
-    const headers: string[] = [];
-    const data: string[][] = [];
+    // 1. Make sure kinematics are up to date
+    this.analysisSolverService.updateKinematics();
 
-    const ths = table.querySelectorAll("thead td");
-    ths.forEach((th, colIndex) => {
-      if (colIndex > 0) {
-        headers.push(th.textContent?.trim() || "");
-      }
-    });
+    const mechanism = this.getMechanism();
+    const allLinks = mechanism.getArrayOfLinks();          // all Link objects
+    const allJoints = mechanism.getArrayOfJoints();
+    const jointIds = allJoints.map(j => j.id);
 
-    const rows = table.querySelectorAll("tbody tr");
-    rows.forEach((row) => {
-      const cells = row.querySelectorAll("td");
-      const rowHeader = cells[0].textContent?.trim() || "";
+    if (!allLinks.length) {
+      alert("No links in mechanism.");
+      return;
+    }
 
-      cells.forEach((cell, index) => {
-        const checkbox = cell.querySelector("input[type='checkbox']") as HTMLInputElement;
-        if (checkbox && checkbox.checked) {
-          data.push([`${headers[index - 1]} ${rowHeader}`]);
-        }
-      });
+    // OPTIONAL: if you want to skip a ground link, you can filter here.
+    // Example heuristic: ignore links whose joints are all grounded.
+    // (Assumes your Joint class has `isGrounded`.)
+    const movingLinks = allLinks.filter(link =>
+      !link.getJoints().every(j => (j as any).isGrounded)
+    );
+
+    const linksToExport = movingLinks.length ? movingLinks : allLinks;
+
+    // 2. For each link, get its LinkAnalysis (angle + angularVelocity arrays)
+    const perLinkData = linksToExport.map(link => {
+      const linkIndex = allLinks.findIndex(l => l.id === link.id);
+      const analysis = this.analysisSolverService.getLinkKinematics(
+        jointIds,
+        linkIndex
+      );
+
+      return {
+        link,
+        analysis,                           // LinkAnalysis
+        name: link.name || `Link ${link.id}`
+      };
     });
 
-    if (data.length === 0) {
-      alert("No selections made");
+    const EPS = 1e-6;
+    const movingPerLinkData = perLinkData.filter(d =>
+      d.analysis.angularVelocity.some(w => Math.abs(w) > EPS)
+    );
+
+    if (!perLinkData.length) {
+      alert("No link kinematics available.");
+      return;
+    }
+
+    // Assume all links share same timeIncrement & number of steps
+    const numSteps = movingPerLinkData[0].analysis.angularVelocity.length;
+    const dt       = movingPerLinkData[0].analysis.timeIncrement;
+
+    if (!numSteps) {
+      alert("No time steps in kinematic solution.");
       return;
     }
 
-    const csvContent = ["Time," + data.map(d => d[0]).join(",")].join("\n");
+    // 3. Build header row
+    const header: string[] = ["Current Time"];
+    for (const d of movingPerLinkData) {
+      header.push(`${d.name} angle degree`);
+      header.push(`${d.name} angVel rad/s`);
+    }
+
+    const rows: string[] = [];
+    rows.push(header.join(","));
+
+    // 4. Build data rows: one row per time step
+    for (let i = 0; i < numSteps; i++) {
+      const t = i.toString();      // match your screenshot precision
+      const row: string[] = [t];
 
-    const blob = new Blob([csvContent], { type: "text/csv" });
-    const link = document.createElement("a");
-    link.href = URL.createObjectURL(blob);
-    link.download = "selected_data.csv";
-    document.body.appendChild(link);
-    link.click();
-    document.body.removeChild(link);
+      for (const d of perLinkData) {
+        const angRad = d.analysis.angle[i] ?? 0;
+        const omega  = d.analysis.angularVelocity[i] ?? 0;
+
+        const angDeg = (angRad * 180 / Math.PI).toFixed(4);
+        const omegaStr = omega.toFixed(4);
+
+        row.push(angDeg, omegaStr);
+      }
+
+      rows.push(row.join(","));
+    }
+
+    const csvContent = rows.join("\n");
+
+    // 5. Download as CSV
+    const blob = new Blob([csvContent], { type: "text/csv;charset=utf-8;" });
+    const url = URL.createObjectURL(blob);
+    const linkEl = document.createElement("a");
+    linkEl.href = url;
+    linkEl.download = "link_angular_kinematics.csv";
+    document.body.appendChild(linkEl);
+    linkEl.click();
+    document.body.removeChild(linkEl);
+    URL.revokeObjectURL(url);
   }
 
+
   getCurrentLinkId(): number | null {
     const link = this.getCurrentLink();
     return link ? link.id : null;
   }
-
 }
diff --git a/src/app/services/analysis-solver.service.ts b/src/app/services/analysis-solver.service.ts
index a0821768..e8c75be5 100644
--- a/src/app/services/analysis-solver.service.ts
+++ b/src/app/services/analysis-solver.service.ts
@@ -1,5 +1,6 @@
 import { Injectable } from '@angular/core';
 import { Coord } from '../model/coord';
+import { Link } from "../model/link";
 import { PositionSolverService, SolveOrder, SolvePrerequisite, SolveType } from './kinematic-solver.service';
 import { AnimationPositions } from './kinematic-solver.service';
 import { create, all, MathJsInstance } from 'mathjs'
@@ -11,7 +12,10 @@ export interface JointAnalysis {
   velocities: Coord[],
   accelerations: Coord[],
 }
-
+interface LinkSegmentInfo {
+  linkId: number;
+  jointIndices: number[];   // indices into jointIDs/subJoints
+}
 export interface LinkAnalysis {
   timeIncrement: number,
   COMpositions: Coord[],
@@ -36,6 +40,7 @@ export class AnalysisSolveService {
   constructor(private positionSolver: PositionSolverService, private stateService: StateService,) {
   }
 
+
   // Updates kinematic data by fetching solve orders and joint positions, then solving submechanism kinematics.
   updateKinematics() {
     /**Order of operations
@@ -311,7 +316,7 @@ export class AnalysisSolveService {
       subJoints.push(jointData!);
     }
     let com_solutions: { pos: Coord[], vel: Coord[], acc: Coord[] } = this.getLinkCOMSolutions(subJoints);
-    let angle_solutions: { ang: number[], vel: number[], acc: number[] } = this.getLinkAngularSolutions(subJoints, linkIndex);
+    let angle_solutions = this.getLinkAngularSolutions(subJoints, jointIDs, linkIndex);
 
     return {
       timeIncrement: subJoints[0].timeIncrement,
@@ -354,65 +359,77 @@ export class AnalysisSolveService {
   }
 
   // Calculates angular positions, velocities, and accelerations for all links.
-  getLinkAngularSolutions(subJoints: JointAnalysis[], linkIndex: number) {
+  getLinkAngularSolutions(subJoints: JointAnalysis[], jointIDs: number[], linkIndex: number) {
+    const mech = this.stateService.getMechanism();
+    const links = mech.getArrayOfLinks();
+    const link = links[linkIndex];
+
     let ang_pos: number[] = [];
     let ang_vel: number[] = [];
     let ang_acc: number[] = [];
 
-    // Compute link lengths (r2 = AB, r3 = BC, r4 = CD)
-    const r2 = this.distance(subJoints[1].positions[0], subJoints[0].positions[0]);
-    const r3 = this.distance(subJoints[2].positions[0], subJoints[1].positions[0]);
-    const r4 = this.distance(subJoints[3].positions[0], subJoints[2].positions[0]);
+    const numSteps = subJoints?.[0]?.positions?.length ?? 0;
+    if (!numSteps || !link) return { ang: ang_pos, vel: ang_vel, acc: ang_acc };
 
-    // Input angular velocity ω2
-    const mechanism = this.stateService.getMechanism();
-    const rpm = mechanism.getInputSpeed();
+    // Link lengths from mechanism
+    const r2 = links[0]?.length ?? 0;
+    const r3 = links[1]?.length ?? 0;
+    const r4 = links[2]?.length ?? 0;
+
+    // Known input speed -> omega2
+    const rpm = mech.getInputSpeed();
     const omega2 = 2 * Math.PI * (rpm / 60);
 
-    console.log("RPM: " + rpm + ", Omega2: " + omega2);
-    for (let time = 0; time < subJoints[0].positions.length; time++) {
+    for (let t = 0; t < numSteps; t++) {
+      // Theta for the CURRENT exported link
+      const thisLink = this.findJointPair(link, subJoints, jointIDs, t);
+      if (!thisLink) {
+        ang_pos.push(0); ang_vel.push(0); ang_acc.push(0);
+        continue;
+      }
 
-      const theta2 = Math.atan2(
-        subJoints[1].positions[time].y - subJoints[0].positions[time].y,
-        subJoints[1].positions[time].x - subJoints[0].positions[time].x
-      );
-
-      const theta3 = Math.atan2(
-        subJoints[2].positions[time].y - subJoints[1].positions[time].y,
-        subJoints[2].positions[time].x - subJoints[1].positions[time].x
-      );
-      const theta4 = Math.atan2(
-        // Quick fix for proper sign, once loop selection is implemented, that will determine the order
-        subJoints[2].positions[time].y - subJoints[3].positions[time].y,
-        subJoints[2].positions[time].x - subJoints[3].positions[time].x
-        // subJoints[3].positions[time].y - subJoints[2].positions[time].y,
-        // subJoints[3].positions[time].x - subJoints[2].positions[time].x
-      );
-
-      // Get angular velocity for links at postions at current time interval
-      const [omega3, omega4] = this.getAngularVelocities(
-        r2, r3, r4,
-        theta2, theta3, theta4,
-        omega2
-      );
-
-      const thetas = [theta2, theta3, theta4];
-      const omegas = [omega2, omega3, omega4];
+      const thisA = subJoints[thisLink.idxA].positions[t];
+      const thisB = subJoints[thisLink.idxB].positions[t];
+      const thisTheta = Math.atan2(thisB.y - thisA.y, thisB.x - thisA.x);
+      ang_pos.push(thisTheta);
 
-      const thetaForLink = thetas[linkIndex] ?? 0;
-      const omegaForLink = omegas[linkIndex] ?? 0;
-      // console.log("THETAS: " + thetaForLink);
-      ang_pos.push(thetaForLink);
-      ang_vel.push(omegaForLink);
-      ang_acc.push(0);
+      // Thetas for matrix solver
+      const p2 = this.findJointPair(links[0], subJoints, jointIDs, t);
+      const p3 = this.findJointPair(links[1], subJoints, jointIDs, t);
+      const p4 = this.findJointPair(links[2], subJoints, jointIDs, t);
+
+      if (!p2 || !p3 || !p4 || !r2 || !r3 || !r4) {
+        ang_vel.push(linkIndex === 0 ? omega2 : 0);
+        ang_acc.push(0);
+        continue;
+      }
+
+      // Current timestep positions for each link
+      const A2 = subJoints[p2.idxA].positions[t];
+      const B2 = subJoints[p2.idxB].positions[t];
+      const theta2 = Math.atan2(B2.y - A2.y, B2.x - A2.x);
+
+      const A3 = subJoints[p3.idxA].positions[t];
+      const B3 = subJoints[p3.idxB].positions[t];
+      const theta3 = Math.atan2(B3.y - A3.y, B3.x - A3.x);
+
+      const A4 = subJoints[p4.idxA].positions[t];
+      const B4 = subJoints[p4.idxB].positions[t];
+      const theta4 = Math.atan2(B4.y - A4.y, B4.x - A4.x);
+
+      // Matrix solution for unknown omegas
+      const { omega3, omega4 } = this.getAngularVelocities(r2, r3, r4, theta2, theta3, theta4, omega2);
+
+      const omegas = [omega2, omega3, omega4];
+      ang_vel.push(omegas[linkIndex] ?? 0); // Push the selected link velocity
+      ang_acc.push(0); // Placeholder for now
     }
-    return {ang: ang_pos, vel: ang_vel, acc: ang_acc};
+
+    return { ang: ang_pos, vel: ang_vel, acc: ang_acc };
   }
 
   // Calculate unknown angular velocities of a 4 bar linkage // ω2k×r2+ω3k×r3−ω4k×r4=0
   getAngularVelocities( r2: number, r3: number, r4: number, theta2: number, theta3: number, theta4: number, omega2: number ) {
-    let ang_vel: number[] = [];
-
     // Build A matrix (2x2) for unknowns
     const A = math.matrix([ [-r3 * Math.sin(theta3), r4 * Math.sin(theta4)], [ r3 * Math.cos(theta3), -r4 * Math.cos(theta4)], ]);
     // Build right-hand side B (2x1)
@@ -424,15 +441,50 @@ export class AnalysisSolveService {
     // get each row (0, 1) in sol matrix
     const omega3 = sol.get([0, 0]) as number;
     const omega4 = sol.get([1, 0]) as number;
-    ang_vel.push(omega3);
-    ang_vel.push(omega4);
-    return ang_vel;
+    return { omega2, omega3, omega4 };
   }
 
-  // Calculate position distance between 2 joints
-  distance(a: Coord, b: Coord) {
-    return Math.sqrt((b.x - a.x) ** 2 + (b.y - a.y) ** 2);
+  private findJointPair(link: any, subJoints: JointAnalysis[], jointIDs: number[], t: number): { idxA: number; idxB: number } | null {
+    const linkJointIds = Array.from(link.joints.keys())
+      .map(j => Number(j))
+      .sort((a, b) => a - b);
+
+    // Map link joint ids -> indices into subJoints (aligned with jointIDs)
+    const idxs: number[] = [];
+    for (const jid of linkJointIds) {
+      const idx = jointIDs.indexOf(jid);
+      if (idx >= 0) idxs.push(idx);
+    }
+
+    let bestI = -1, bestJ = -1;
+    let bestD2 = -Infinity;
+
+    for (let a = 0; a < idxs.length; a++) {
+      for (let b = a + 1; b < idxs.length; b++) {
+        const i = idxs[a];
+        const j = idxs[b];
+
+        const p = subJoints[i]?.positions?.[t];
+        const q = subJoints[j]?.positions?.[t];
+        if (!p || !q) continue;
+
+        const dx = q.x - p.x;
+        const dy = q.y - p.y;
+        const d2 = dx * dx + dy * dy;
+
+        if (d2 > bestD2) {
+          bestD2 = d2;
+          bestI = i;
+          bestJ = j;
+        }
+      }
+    }
+
+    if (bestI < 0 || bestJ < 0) return null;
+    return { idxA: bestI, idxB: bestJ };
   }
 
+
+
 }
 

From 7dce3d96757ceec4c93df6131cf483b3035ae0a6 Mon Sep 17 00:00:00 2001
From: mwalsh001 <matty71604@gmail.com>
Date: Thu, 19 Feb 2026 20:55:11 -0500
Subject: [PATCH 13/23] 4-bar velocity calculations.

---
 .../link-analysis-panel.component.ts          | 549 +++++++++++++++++-
 src/app/services/analysis-solver.service.ts   | 209 +++++--
 2 files changed, 722 insertions(+), 36 deletions(-)

diff --git a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
index 1dda4d5b..5fc9e141 100644
--- a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
+++ b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
@@ -280,10 +280,10 @@ export class LinkAnalysisPanelComponent {
 
     // 4. Build data rows: one row per time step
     for (let i = 0; i < numSteps; i++) {
-      const t = i.toString();      // match your screenshot precision
+      const t = (i * dt).toFixed(5);
       const row: string[] = [t];
 
-      for (const d of perLinkData) {
+      for (const d of movingPerLinkData) {
         const angRad = d.analysis.angle[i] ?? 0;
         const omega  = d.analysis.angularVelocity[i] ?? 0;
 
@@ -316,3 +316,548 @@ export class LinkAnalysisPanelComponent {
     return link ? link.id : null;
   }
 }
+
+// import { Injectable } from '@angular/core';
+// import { Coord } from '../model/coord';
+// import { Link } from "../model/link";
+// import { PositionSolverService, SolveOrder, SolvePrerequisite, SolveType } from './kinematic-solver.service';
+// import { AnimationPositions } from './kinematic-solver.service';
+// import { create, all, MathJsInstance } from 'mathjs'
+// import {StateService} from "./state.service";
+//
+// export interface JointAnalysis {
+//   timeIncrement: number,
+//   positions: Coord[],
+//   velocities: Coord[],
+//   accelerations: Coord[],
+// }
+// interface LinkSegmentInfo {
+//   linkId: number;
+//   jointIndices: number[];   // indices into jointIDs/subJoints
+// }
+// export interface LinkAnalysis {
+//   timeIncrement: number,
+//   COMpositions: Coord[],
+//   COMvelocities: Coord[],
+//   COMaccelerations: Coord[],
+//   angle: number[],
+//   angularVelocity: number[],
+//   angularAcceleration: number[],
+// }
+//
+// const math: MathJsInstance = create(all, {});
+//
+// @Injectable({
+//   providedIn: 'root'
+// })
+// export class AnalysisSolveService {
+//
+//   private solveOrders: SolveOrder[] = [];
+//   private jointPositions: AnimationPositions[] = [];
+//   private jointKinematics: Map<number, JointAnalysis> = new Map();
+//
+//   constructor(private positionSolver: PositionSolverService, private stateService: StateService,) {
+//   }
+//
+//
+//   // Updates kinematic data by fetching solve orders and joint positions, then solving submechanism kinematics.
+//   updateKinematics() {
+//     /**Order of operations
+//      * 1. First we need the Solve Orders and Positions of the joints from position solver
+//      * 2. For solving links we need to associate model links with the joints being solved for, we can do so by using the
+//      * 3. Iterate over each position, solving for the needed information for both links and joints.
+//      * 4. Update the Information
+//      */
+//     this.solveOrders = this.positionSolver.getSolveOrders();
+//     this.jointPositions = this.positionSolver.getAnimationFrames();
+//     this.jointKinematics = new Map();
+//     for (let i = 0; i < this.solveOrders.length; i++) {
+//       this.solveSubmechanimsKinematics(this.solveOrders[i], this.jointPositions[i]);
+//     }
+//   }
+//
+//   // Solves kinematics for a specific submechanism given its solve order and joint positions.
+//   solveSubmechanimsKinematics(solveOrder: SolveOrder, jointPositions: AnimationPositions) {
+//     /**we are given the animation positions and solve order for a submechanism
+//      * 1. iterate over each set of positions to solve
+//      * 2. call a function that returns all relevant calculations
+//      * 3. update jointKinematics
+//      */
+//     let mechanismVelocities: Coord[][] = [];
+//     let mechanismAccelerations: Coord[][] = [];
+//     for (let time = 0; time < jointPositions.positions.length; time++) {
+//       let solutions = this.solveJointKinematics(solveOrder, jointPositions.positions[time]);
+//       mechanismVelocities.push(solutions.velocities);
+//       mechanismAccelerations.push(solutions.accelerations);
+//     }
+//     const arrayColumn = (array: Coord[][], columnIndex: number) => array.map(row => row[columnIndex])
+//     this.jointKinematics = new Map();
+//     let inputspeed: number = solveOrder.prerequisites.get(solveOrder.order[0])!.jointToSolve.inputSpeed;
+//     let timeIncrement: number = 60 / (inputspeed * 360);
+//     for (let i = 0; i < solveOrder.order.length; i++) {
+//       let accelerations = arrayColumn(mechanismAccelerations, i);
+//       let velocities = arrayColumn(mechanismVelocities, i);
+//       let positions = arrayColumn(jointPositions.positions, i);
+//       let joint: JointAnalysis = {
+//         timeIncrement: timeIncrement,
+//         positions: positions,
+//         velocities: velocities,
+//         accelerations: accelerations
+//       }
+//       this.jointKinematics.set(solveOrder.order[i], joint);
+//     }
+//   }
+//
+//   // Computes velocities and accelerations for all joints in a solve order at a single time step.
+//   solveJointKinematics(solveOrder: SolveOrder, positions: Coord[]): { velocities: Coord[], accelerations: Coord[] } {
+//     let velocities: Coord[] = [];
+//     let accelerations: Coord[] = [];
+//
+//     for (let index = 0; index < solveOrder.order.length; index++) {
+//       let id = solveOrder.order[index];
+//       let prereq = solveOrder.prerequisites.get(id)!;
+//       let velocity_acceleration: { velocity: Coord, acceleration: Coord };
+//       switch (prereq.solveType) {
+//         case SolveType.Ground:
+//           velocities.push(new Coord(0, 0));
+//           accelerations.push(new Coord(0, 0));
+//           break;
+//         case SolveType.RevoluteInput:
+//           velocity_acceleration = this.solveRevInputJointKinematics(index, prereq, positions);
+//           velocities.push(velocity_acceleration.velocity);
+//           accelerations.push(velocity_acceleration.acceleration);
+//           break;
+//         case SolveType.PrismaticInput:
+//           velocity_acceleration = this.solvePrisInputJointKinematics(prereq);
+//           velocities.push(velocity_acceleration.velocity);
+//           accelerations.push(velocity_acceleration.acceleration);
+//           break;
+//         case SolveType.CircleCircle:
+//           let knownIndex1 = solveOrder.order.indexOf(prereq.knownJointOne!.id);
+//           let knownIndex2 = solveOrder.order.indexOf(prereq.knownJointTwo!.id);
+//           velocity_acceleration = this.solveCircleCirlceJointKinematics(index, knownIndex1, knownIndex2, positions, velocities, accelerations);
+//           velocities.push(velocity_acceleration.velocity);
+//           accelerations.push(velocity_acceleration.acceleration);
+//           break;
+//         case SolveType.CircleLine:
+//           knownIndex1 = solveOrder.order.indexOf(prereq.knownJointOne!.id);
+//           velocity_acceleration = this.solveCircleLineJointKinematics(index, knownIndex1, prereq, positions, velocities, accelerations)
+//           velocities.push(velocity_acceleration.velocity);
+//           accelerations.push(velocity_acceleration.acceleration);
+//           break;
+//       }
+//     }
+//     return {velocities: velocities, accelerations: accelerations};
+//   }
+//
+//   //need to account for switching directions
+//   /**
+//    * Solves for the velocity and acceleration of a joint connected to a grounded revolute input
+//    * @param jointIndex - an index for the joint to be solved within with positions array.
+//    * @param prereq - a SolvePrerequisite that corresponds to that joint.
+//    * @param positions - an array of joint positions for a particular timestep.
+//    * @returns
+//    */
+//   solveRevInputJointKinematics(jointIndex: number, prereq: SolvePrerequisite, positions: Coord[]): {
+//     velocity: Coord,
+//     acceleration: Coord
+//   } {
+//
+//     const xDifference = positions[jointIndex].x - positions[0].x;
+//     const yDifference = positions[jointIndex].y - positions[0].y;
+//     const angleToInput: number = Math.atan2(yDifference, xDifference);
+//     const omega: number = 2 * Math.PI * (prereq.knownJointOne!.inputSpeed / 60); //Angular Velocity of Link in Radians
+//     const r: number = prereq.distFromKnownJointOne!;
+//
+//     //velocity
+//     const velocityMagnitude = r * omega; //Velocity magnitude
+//     const velocityTheta = omega > 0 ? angleToInput - Math.PI / 2 : angleToInput + Math.PI / 2; //Velocity direction
+//     const xVelocity: number = Math.cos(velocityTheta) * velocityMagnitude;
+//     const yVelocity: number = Math.sin(velocityTheta) * velocityMagnitude;
+//     const jointVelocity: Coord = new Coord(xVelocity, yVelocity);
+//     //acceleration
+//     const xAcceleration: number = -Math.cos(angleToInput) * velocityMagnitude * omega;
+//     const yAcceleration: number = -Math.sin(angleToInput) * velocityMagnitude * omega;
+//     const jointAcceleration: Coord = new Coord(xAcceleration, yAcceleration);
+//     return {velocity: jointVelocity, acceleration: jointAcceleration};
+//   }
+//
+//   // Calculates velocity and acceleration for a prismatic input joint from its prerequisites.
+//   solvePrisInputJointKinematics(prereq: SolvePrerequisite): { velocity: Coord, acceleration: Coord } {
+//     const velocityMag = prereq.jointToSolve.inputSpeed * (0.05 * 6) //Kinematic solver generates frames for 0.05m increments, and animator uses Rev-Input timeInterval calculation
+//     const velocityTheta = prereq.jointToSolve.angle;
+//     const deltaX: number = Math.cos(velocityTheta) * velocityMag;
+//     const deltaY: number = Math.sin(velocityTheta) * velocityMag;
+//     const jointVelocity: Coord = new Coord(deltaX, deltaY);
+//     const jointAcceleration: Coord = new Coord(0, 0);
+//     return {velocity: jointVelocity, acceleration: jointAcceleration};
+//   }
+//
+//   // Determines velocity and acceleration for a joint constrained by two circular motions using known indices, positions, velocities, and accelerations.
+//   solveCircleCirlceJointKinematics(jointIndex: number, known1Index: number, known2Index: number, positions: Coord[], velocities: Coord[], accelerations: Coord[]): {
+//     velocity: Coord,
+//     acceleration: Coord
+//   } {
+//     //velocity
+//     const v_k1: Coord = velocities[known1Index];
+//     const v_k2: Coord = velocities[known2Index];
+//     const pos_j: Coord = positions[jointIndex];
+//     const diff_jk1: Coord = new Coord(pos_j.x - positions[known1Index].x, pos_j.y - positions[known1Index].y);
+//     const diff_jk2: Coord = new Coord(pos_j.x - positions[known2Index].x, pos_j.y - positions[known2Index].y);
+//     const perp_angle_jk1: number = Math.atan2(diff_jk1.y, diff_jk1.x) + Math.PI / 2;
+//     const perp_angle_jk2: number = Math.atan2(diff_jk2.y, diff_jk2.x) + Math.PI / 2;
+//     const jointVelocity: Coord = this.parametricLineIntersection(v_k1, perp_angle_jk1, v_k2, perp_angle_jk2);
+//     //acceleration of k1 + (V_k1j^2 / (k1-j)) for centripetal,
+//     const x_centripetal_accel_jk1: number = accelerations[known1Index].x + Math.pow(jointVelocity.x, 2) / (-diff_jk1.x);
+//     const y_centripetal_accel_jk1: number = accelerations[known1Index].y + Math.pow(jointVelocity.y, 2) / (-diff_jk1.y);
+//     const x_centripetal_accel_jk2: number = accelerations[known2Index].x + Math.pow(jointVelocity.x, 2) / (-diff_jk2.x);
+//     const y_centripetal_accel_jk2: number = accelerations[known2Index].y + Math.pow(jointVelocity.y, 2) / (-diff_jk2.y);
+//     const centripetal_accel_jk1: Coord = new Coord(x_centripetal_accel_jk1, y_centripetal_accel_jk1);
+//     const centripetal_accel_jk2: Coord = new Coord(x_centripetal_accel_jk2, y_centripetal_accel_jk2);
+//     const jointAcceleration: Coord = this.parametricLineIntersection(centripetal_accel_jk1, perp_angle_jk1, centripetal_accel_jk2, perp_angle_jk2);
+//     return {velocity: jointVelocity, acceleration: jointAcceleration};
+//   }
+//
+//   // Determines velocity and acceleration for a joint constrained by a circle and a line using known index, prerequisites, positions, velocities, and accelerations.
+//   solveCircleLineJointKinematics(jointIndex: number, known1Index: number, prereq: SolvePrerequisite, positions: Coord[], velocities: Coord[], accelerations: Coord[]): {
+//     velocity: Coord,
+//     acceleration: Coord
+//   } {
+//     //velocity
+//     const v_k1: Coord = velocities[known1Index];
+//     const diff_jk1: Coord = new Coord(positions[jointIndex].x - positions[known1Index].x, positions[jointIndex].y - positions[known1Index].y);
+//     const perp_angle_jk1: number = Math.atan2(diff_jk1.y, diff_jk1.x) + Math.PI / 2;
+//     const jointVelocity: Coord = this.parametricLineIntersection(v_k1, perp_angle_jk1, new Coord(0, 0), prereq.jointToSolve.angle);
+//     //acceleration
+//     const x_centripetal_accel_jk1: number = accelerations[known1Index].x + Math.pow(jointVelocity.x, 2) / (-diff_jk1.x);
+//     const y_centripetal_accel_jk1: number = accelerations[known1Index].y + Math.pow(jointVelocity.y, 2) / (-diff_jk1.y);
+//     const centripetal_accel_jk1: Coord = new Coord(x_centripetal_accel_jk1, y_centripetal_accel_jk1);
+//     const jointAcceleration: Coord = this.parametricLineIntersection(centripetal_accel_jk1, perp_angle_jk1, new Coord(0, 0), prereq.jointToSolve.angle);
+//     return {velocity: jointVelocity, acceleration: jointAcceleration};
+//   }
+//
+//   // Finds the intersection point of two parametric lines defined by starting coordinates and angles.
+//   parametricLineIntersection(pos1: Coord, theta1: number, pos2: Coord, theta2: number): Coord {
+//     const t_2 = ((pos1.y - pos2.y) + ((pos2.x - pos1.x) / Math.cos(theta1))) / ((Math.sin(theta2)) - (Math.cos(theta2) / Math.cos(theta1)));
+//     const x_intersection = pos2.x + (t_2 * Math.cos(theta2));
+//     const y_intersection = pos2.y + (t_2 * Math.sin(theta2));
+//     return new Coord(x_intersection, y_intersection);
+//   }
+//
+//   // Retrieves stored kinematic analysis (positions, velocities, accelerations) for a specific joint ID.
+//   getJointKinematics(jointID: number): JointAnalysis {
+//     return this.jointKinematics.get(jointID)!;
+//   }
+//
+//   // Converts joint kinematic data into arrays suitable for plotting, based on requested data type (position, velocity, or acceleration).
+//   transformJointKinematicGraph(jointAnalysis: JointAnalysis, dataOf: string): {
+//     xData: any[],
+//     yData: any[],
+//     timeLabels: string[]
+//   } {
+//     const xData: any[] = [];
+//     const yData: any[] = [];
+//     const timeLabels: string[] = [];
+//
+//     switch (dataOf) {
+//       case ("Position"):
+//         xData.push({data: jointAnalysis.positions.map(coord => coord.x), label: "X data of Position"});
+//         yData.push({data: jointAnalysis.positions.map(coord => coord.y), label: "Y data of Position"});
+//         timeLabels.push(...jointAnalysis.positions.map((_, index) => String(index)));
+//
+//         return {xData, yData, timeLabels};
+//
+//       case ("Velocity"):
+//         xData.push({data: jointAnalysis.velocities.map(coord => coord.x), label: "X data of Velocity"});
+//         yData.push({data: jointAnalysis.velocities.map(coord => coord.y), label: "Y data of Velocity"});
+//         timeLabels.push(...jointAnalysis.velocities.map((_, index) => String(index)));
+//
+//         return {xData, yData, timeLabels};
+//
+//       case ("Acceleration"):
+//         xData.push({data: jointAnalysis.accelerations.map(coord => coord.x), label: "X data of Acceleration"});
+//         yData.push({data: jointAnalysis.accelerations.map(coord => coord.y), label: "Y data of Acceleration"});
+//         timeLabels.push(...jointAnalysis.accelerations.map((_, index) => String(index)));
+//
+//         return {xData, yData, timeLabels};
+//
+//       default:
+//         console.error("Invalid Graph type detected! Returning default values.")
+//         return {xData, yData, timeLabels};
+//     }
+//
+//   }
+//
+//   // Converts link kinematic data into arrays suitable for plotting, based on requested data type (angle, velocity, or acceleration).
+//   transformLinkKinematicGraph(linkAnalysis: LinkAnalysis, dataOf: string): {
+//     xData: any[],
+//     yData: any[],
+//     timeLabels: string[]
+//   } {
+//     const xData: any[] = [];
+//     const yData: any[] = [];
+//     const timeLabels: string[] = [];
+//
+//     switch (dataOf) {
+//       case ("Angle"):
+//         xData.push({data: linkAnalysis.angle, label: "Angle of Reference Joint"});
+//         timeLabels.push(...linkAnalysis.angle.map((_, index) => String(index)));
+//
+//         return {xData, yData, timeLabels};
+//
+//       case ("Velocity"):
+//         // xData.push({data: linkAnalysis.angularVelocity.map(a => ), label: "Angular Velocity"});
+//         // xData.push({data: linkAnalysis.angularVelocity, label: "Angular Velocity"});
+//         xData.push({data: linkAnalysis.angularVelocity, label: "Angular Velocity (rad/s)"});
+//         timeLabels.push(...linkAnalysis.angularVelocity.map((_, index) => String(index)));
+//
+//         return {xData, yData, timeLabels};
+//
+//       case ("Acceleration"):
+//         xData.push({data: linkAnalysis.angularAcceleration, label: "Angular Acceleration"});
+//         timeLabels.push(...linkAnalysis.angularAcceleration.map((_, index) => String(index)));
+//
+//         return {xData, yData, timeLabels};
+//
+//       default:
+//         console.error("Invalid Graph type detected! Returning default values.")
+//         return {xData, yData, timeLabels};
+//     }
+//
+//   }
+//
+//   // Computes center-of-mass and angular kinematics for a link given its associated joint IDs.
+//   getLinkKinematics(jointIDs: number[], linkIndex: number): LinkAnalysis {
+//     let subJoints: JointAnalysis[] = [];
+//
+//     for (let id of jointIDs) {
+//       const jointData = this.jointKinematics.get(id);
+//       subJoints.push(jointData!);
+//     }
+//     let com_solutions: { pos: Coord[], vel: Coord[], acc: Coord[] } = this.getLinkCOMSolutions(subJoints);
+//     let angle_solutions = this.getLinkAngularSolutions(subJoints, jointIDs, linkIndex);
+//
+//     return {
+//       timeIncrement: subJoints[0].timeIncrement,
+//       COMpositions: com_solutions.pos,
+//       COMvelocities: com_solutions.vel,
+//       COMaccelerations: com_solutions.acc,
+//       angle: angle_solutions.ang,
+//       angularVelocity: angle_solutions.vel,
+//       angularAcceleration: angle_solutions.acc,
+//     } as LinkAnalysis
+//
+//   }
+//
+//   // Calculates center-of-mass positions, velocities, and accelerations from joint-level kinematic data for a link.
+//   getLinkCOMSolutions(subJoints: JointAnalysis[]) {
+//     let com_positions: Coord[] = [];
+//     let com_velocities: Coord[] = [];
+//     let com_accelerations: Coord[] = [];
+//     for (let time = 0; time < subJoints[0].positions.length; time++) {
+//       let x_pos: number = 0;
+//       let y_pos: number = 0;
+//       let x_vel: number = 0;
+//       let y_vel: number = 0;
+//       let x_acc: number = 0;
+//       let y_acc: number = 0;
+//       let denominator: number = subJoints.length;
+//       for (let joint of subJoints) {
+//         x_pos += joint.positions[time].x;
+//         y_pos += joint.positions[time].y;
+//         x_vel += joint.velocities[time].x;
+//         y_vel += joint.velocities[time].y;
+//         x_acc += joint.accelerations[time].x;
+//         y_acc += joint.accelerations[time].y;
+//       }
+//       com_positions.push(new Coord(x_pos / denominator, y_pos / denominator));
+//       com_velocities.push(new Coord(x_vel / denominator, y_vel / denominator));
+//       com_accelerations.push(new Coord(x_acc / denominator, y_acc / denominator))
+//     }
+//     return {pos: com_positions, vel: com_velocities, acc: com_accelerations}
+//   }
+//
+//   // Calculates angular positions, velocities, and accelerations for all links.
+//   getLinkAngularSolutions(subJoints: JointAnalysis[], jointIDs: number[], linkIndex: number) {
+//     const mech = this.stateService.getMechanism();
+//     const links = mech.getArrayOfLinks();
+//     const link = links[linkIndex];
+//
+//     let ang_pos: number[] = [];
+//     let ang_vel: number[] = [];
+//     let ang_acc: number[] = [];
+//
+//     const numSteps = subJoints?.[0]?.positions?.length ?? 0;
+//     if (!numSteps || !link) return { ang: ang_pos, vel: ang_vel, acc: ang_acc };
+//
+//     // Link lengths from mechanism
+//     const r2 = links[0]?.length ?? 0;
+//     const r3 = links[1]?.length ?? 0;
+//     const r4 = links[2]?.length ?? 0;
+//
+//     // Known input speed -> omega2
+//     const rpm = mech.getInputSpeed();
+//     const omega2 = 2 * Math.PI * (rpm / 60);
+//
+//     const normalizeAngle = (theta: number) => {
+//       const twoPi = 2 * Math.PI;
+//       const t = theta % twoPi;
+//       return t < 0 ? t + twoPi : t;
+//     };
+//
+//     const unwrapAngle = (prevUnwrapped: number, prevRaw: number, raw: number) => {
+//       let delta = raw - prevRaw;
+//       if (delta > Math.PI) delta -= 2 * Math.PI;
+//       else if (delta < -Math.PI) delta += 2 * Math.PI;
+//       return prevUnwrapped + delta;
+//     };
+//
+//     let prevThetaRaw: number | null = null;
+//     let prevThetaUnwrapped: number | null = null;
+//     const thetaUnwrapped: number[] = [];
+//
+//     for (let t = 0; t < numSteps; t++) {
+//       // Theta for the CURRENT exported link
+//       const thisLink = this.findJointPair(link, subJoints, jointIDs, t);
+//       if (!thisLink) {
+//         ang_pos.push(0); ang_vel.push(0); ang_acc.push(0);
+//         continue;
+//       }
+//
+//       const thisA = subJoints[thisLink.idxA].positions[t];
+//       const thisB = subJoints[thisLink.idxB].positions[t];
+//       const thisThetaRaw = Math.atan2(thisB.y - thisA.y, thisB.x - thisA.x);
+//       const priorRaw: number | null = prevThetaRaw;
+//       const priorUnwrapped: number | null = prevThetaUnwrapped;
+//       const thisThetaUnwrapped: number = priorRaw === null || priorUnwrapped === null
+//         ? thisThetaRaw
+//         : unwrapAngle(priorUnwrapped, priorRaw, thisThetaRaw);
+//       const dTheta: number = priorUnwrapped === null ? 0 : thisThetaUnwrapped - priorUnwrapped;
+//       prevThetaRaw = thisThetaRaw;
+//       prevThetaUnwrapped = thisThetaUnwrapped;
+//       thetaUnwrapped.push(thisThetaUnwrapped);
+//
+//       ang_pos.push(normalizeAngle(thisThetaRaw));
+//
+//       // Thetas for matrix solver
+//       const p2 = this.findJointPair(links[0], subJoints, jointIDs, t);
+//       const p3 = this.findJointPair(links[1], subJoints, jointIDs, t);
+//       const p4 = this.findJointPair(links[2], subJoints, jointIDs, t);
+//
+//       if (!p2 || !p3 || !p4 || !r2 || !r3 || !r4) {
+//         const omegaFallback = linkIndex === 0 ? omega2 : 0;
+//         const omegaOut = Math.abs(dTheta) > 1e-12 ? Math.sign(dTheta) * Math.abs(omegaFallback) : omegaFallback;
+//         ang_vel.push(omegaOut);
+//         ang_acc.push(0);
+//         continue;
+//       }
+//
+//       // Current timestep positions for each link
+//       const A2 = subJoints[p2.idxA].positions[t];
+//       const B2 = subJoints[p2.idxB].positions[t];
+//       const theta2 = Math.atan2(B2.y - A2.y, B2.x - A2.x);
+//
+//       const A3 = subJoints[p3.idxA].positions[t];
+//       const B3 = subJoints[p3.idxB].positions[t];
+//       const theta3 = Math.atan2(B3.y - A3.y, B3.x - A3.x);
+//
+//       const A4 = subJoints[p4.idxA].positions[t];
+//       const B4 = subJoints[p4.idxB].positions[t];
+//       const theta4 = Math.atan2(B4.y - A4.y, B4.x - A4.x);
+//
+//       // Matrix solution for unknown omegas
+//       const { omega3, omega4 } = this.getAngularVelocities(r2, r3, r4, theta2, theta3, theta4, omega2);
+//
+//       const omegas = [omega2, omega3, omega4];
+//       const omegaCandidate = omegas[linkIndex] ?? 0;
+//       const omegaOut = Math.abs(dTheta) > 1e-12 ? Math.sign(dTheta) * Math.abs(omegaCandidate) : omegaCandidate;
+//
+//       ang_vel.push(omegaOut); // Push the selected link velocity
+//       ang_acc.push(0); // Placeholder for now
+//     }
+//
+//     if (ang_vel.length > 1 && thetaUnwrapped.length > 1) {
+//       const dTheta0 = thetaUnwrapped[1] - thetaUnwrapped[0];
+//       if (Math.abs(dTheta0) > 1e-12) {
+//         ang_vel[0] = Math.sign(dTheta0) * Math.abs(ang_vel[0]);
+//       }
+//     }
+//
+//     return { ang: ang_pos, vel: ang_vel, acc: ang_acc };
+//   }
+//
+//   // Calculate unknown angular velocities of a 4 bar linkage // ω2k×r2+ω3k×r3−ω4k×r4=0
+//   getAngularVelocities( r2: number, r3: number, r4: number, theta2: number, theta3: number, theta4: number, omega2: number ) {
+//     // Build A matrix (2x2) for unknowns
+//     const A = math.matrix([ [-r3 * Math.sin(theta3), r4 * Math.sin(theta4)], [ r3 * Math.cos(theta3), -r4 * Math.cos(theta4)], ]);
+//     // Build right-hand side B (2x1)
+//     const B = math.matrix([ [ r2 * omega2 * Math.sin(theta2) ], [-r2 * omega2 * Math.cos(theta2) ], ]);
+//
+//     // Solve for unknowns (system of equations)
+//     const sol = math.lusolve(A, B) as any;
+//
+//     // get each row (0, 1) in sol matrix
+//     const omega3 = sol.get([0, 0]) as number;
+//     const omega4 = sol.get([1, 0]) as number;
+//     return { omega2, omega3, omega4 };
+//   }
+//
+//   private findJointPair(
+//     link: any,
+//     subJoints: JointAnalysis[],
+//     jointIDs: number[],
+//     t: number
+//   ): { idxA: number; idxB: number } | null {
+//
+//     const mech = this.stateService.getMechanism();
+//     const allLinks = mech.getArrayOfLinks();
+//     const degMap = this.buildJointDegreeMap(allLinks);
+//
+//     const linkJointIds = Array.from(link.joints.keys()).map(j => Number(j));
+//
+//     // Prefer joints that connect to other links (degree > 1)
+//     let preferred = linkJointIds.filter(jid => (degMap.get(jid) ?? 0) > 1);
+//
+//     // Fallback if we can't find two connection joints
+//     if (preferred.length < 2) preferred = linkJointIds;
+//
+//     // Map joint ids -> indices into subJoints
+//     const idxs: number[] = [];
+//     for (const jid of preferred) {
+//       const idx = jointIDs.indexOf(jid);
+//       if (idx >= 0) idxs.push(idx);
+//     }
+//
+//     // Pick farthest pair among preferred candidates (stable + works well)
+//     let bestI = -1, bestJ = -1, bestD2 = -Infinity;
+//     for (let a = 0; a < idxs.length; a++) {
+//       for (let b = a + 1; b < idxs.length; b++) {
+//         const i = idxs[a], j = idxs[b];
+//         const p = subJoints[i]?.positions?.[t];
+//         const q = subJoints[j]?.positions?.[t];
+//         if (!p || !q) continue;
+//
+//         const dx = q.x - p.x, dy = q.y - p.y;
+//         const d2 = dx*dx + dy*dy;
+//         if (d2 > bestD2) { bestD2 = d2; bestI = i; bestJ = j; }
+//       }
+//     }
+//
+//     if (bestI < 0 || bestJ < 0) return null;
+//     return { idxA: bestI, idxB: bestJ };
+//   }
+//
+//
+//   private buildJointDegreeMap(links: any[]): Map<number, number> {
+//     const deg = new Map<number, number>();
+//     for (const link of links) {
+//       for (const jid of link.joints.keys()) {
+//         deg.set(Number(jid), (deg.get(Number(jid)) ?? 0) + 1);
+//       }
+//     }
+//     return deg;
+//   }
+//
+//
+// }
+
diff --git a/src/app/services/analysis-solver.service.ts b/src/app/services/analysis-solver.service.ts
index e8c75be5..18b09cae 100644
--- a/src/app/services/analysis-solver.service.ts
+++ b/src/app/services/analysis-solver.service.ts
@@ -1,6 +1,7 @@
 import { Injectable } from '@angular/core';
 import { Coord } from '../model/coord';
 import { Link } from "../model/link";
+import { Joint } from "../model/joint";
 import { PositionSolverService, SolveOrder, SolvePrerequisite, SolveType } from './kinematic-solver.service';
 import { AnimationPositions } from './kinematic-solver.service';
 import { create, all, MathJsInstance } from 'mathjs'
@@ -371,15 +372,36 @@ export class AnalysisSolveService {
     const numSteps = subJoints?.[0]?.positions?.length ?? 0;
     if (!numSteps || !link) return { ang: ang_pos, vel: ang_vel, acc: ang_acc };
 
+    // Determine which link is actually the input/coupler/output for this mechanism
+    const fourBar = this.identifyFourBarLinks(links);
+    const hasFourBarMap = !!(fourBar.inputLink && fourBar.couplerLink && fourBar.outputLink);
+
     // Link lengths from mechanism
-    const r2 = links[0]?.length ?? 0;
-    const r3 = links[1]?.length ?? 0;
-    const r4 = links[2]?.length ?? 0;
+    const r2 = hasFourBarMap ? fourBar.inputLink!.length : (links[0]?.length ?? 0);
+    const r3 = hasFourBarMap ? fourBar.couplerLink!.length : (links[1]?.length ?? 0);
+    const r4 = hasFourBarMap ? fourBar.outputLink!.length : (links[2]?.length ?? 0);
 
-    // Known input speed -> omega2
-    const rpm = mech.getInputSpeed();
+    // Known input speed -> omega2 (prefer input joint speed when available)
+    const rpm = fourBar.inputJoint ? fourBar.inputJoint.inputSpeed : mech.getInputSpeed();
     const omega2 = 2 * Math.PI * (rpm / 60);
 
+    const normalizeAngle = (theta: number) => {
+      const twoPi = 2 * Math.PI;
+      const t = theta % twoPi;
+      return t < 0 ? t + twoPi : t;
+    };
+
+    const unwrapAngle = (prevUnwrapped: number, prevRaw: number, raw: number) => {
+      let delta = raw - prevRaw;
+      if (delta > Math.PI) delta -= 2 * Math.PI;
+      else if (delta < -Math.PI) delta += 2 * Math.PI;
+      return prevUnwrapped + delta;
+    };
+
+    let prevThetaRaw: number | null = null;
+    let prevThetaUnwrapped: number | null = null;
+    const thetaUnwrapped: number[] = [];
+
     for (let t = 0; t < numSteps; t++) {
       // Theta for the CURRENT exported link
       const thisLink = this.findJointPair(link, subJoints, jointIDs, t);
@@ -390,16 +412,32 @@ export class AnalysisSolveService {
 
       const thisA = subJoints[thisLink.idxA].positions[t];
       const thisB = subJoints[thisLink.idxB].positions[t];
-      const thisTheta = Math.atan2(thisB.y - thisA.y, thisB.x - thisA.x);
-      ang_pos.push(thisTheta);
+      const thisThetaRaw = Math.atan2(thisB.y - thisA.y, thisB.x - thisA.x);
+      const priorRaw: number | null = prevThetaRaw;
+      const priorUnwrapped: number | null = prevThetaUnwrapped;
+      const thisThetaUnwrapped: number = priorRaw === null || priorUnwrapped === null
+        ? thisThetaRaw
+        : unwrapAngle(priorUnwrapped, priorRaw, thisThetaRaw);
+      const dTheta: number = priorUnwrapped === null ? 0 : thisThetaUnwrapped - priorUnwrapped;
+      prevThetaRaw = thisThetaRaw;
+      prevThetaUnwrapped = thisThetaUnwrapped;
+      thetaUnwrapped.push(thisThetaUnwrapped);
+
+      ang_pos.push(normalizeAngle(thisThetaRaw));
 
       // Thetas for matrix solver
-      const p2 = this.findJointPair(links[0], subJoints, jointIDs, t);
-      const p3 = this.findJointPair(links[1], subJoints, jointIDs, t);
-      const p4 = this.findJointPair(links[2], subJoints, jointIDs, t);
+      const link2 = hasFourBarMap ? fourBar.inputLink! : links[0];
+      const link3 = hasFourBarMap ? fourBar.couplerLink! : links[1];
+      const link4 = hasFourBarMap ? fourBar.outputLink! : links[2];
+
+      const p2 = link2 ? this.findJointPair(link2, subJoints, jointIDs, t) : null;
+      const p3 = link3 ? this.findJointPair(link3, subJoints, jointIDs, t) : null;
+      const p4 = link4 ? this.findJointPair(link4, subJoints, jointIDs, t) : null;
 
       if (!p2 || !p3 || !p4 || !r2 || !r3 || !r4) {
-        ang_vel.push(linkIndex === 0 ? omega2 : 0);
+        const omegaFallback = (!hasFourBarMap && linkIndex === 0) || (hasFourBarMap && link === fourBar.inputLink) ? omega2 : 0;
+        const omegaOut = Math.abs(dTheta) > 1e-12 ? Math.sign(dTheta) * Math.abs(omegaFallback) : omegaFallback;
+        ang_vel.push(omegaOut);
         ang_acc.push(0);
         continue;
       }
@@ -420,11 +458,29 @@ export class AnalysisSolveService {
       // Matrix solution for unknown omegas
       const { omega3, omega4 } = this.getAngularVelocities(r2, r3, r4, theta2, theta3, theta4, omega2);
 
-      const omegas = [omega2, omega3, omega4];
-      ang_vel.push(omegas[linkIndex] ?? 0); // Push the selected link velocity
+      let omegaCandidate = 0;
+      if (hasFourBarMap) {
+        if (link === fourBar.inputLink) omegaCandidate = omega2;
+        else if (link === fourBar.couplerLink) omegaCandidate = omega3;
+        else if (link === fourBar.outputLink) omegaCandidate = omega4;
+        else omegaCandidate = 0;
+      } else {
+        const omegas = [omega2, omega3, omega4];
+        omegaCandidate = omegas[linkIndex] ?? 0;
+      }
+      const omegaOut = Math.abs(dTheta) > 1e-12 ? Math.sign(dTheta) * Math.abs(omegaCandidate) : omegaCandidate;
+
+      ang_vel.push(omegaOut); // Push the selected link velocity
       ang_acc.push(0); // Placeholder for now
     }
 
+    if (ang_vel.length > 1 && thetaUnwrapped.length > 1) {
+      const dTheta0 = thetaUnwrapped[1] - thetaUnwrapped[0];
+      if (Math.abs(dTheta0) > 1e-12) {
+        ang_vel[0] = Math.sign(dTheta0) * Math.abs(ang_vel[0]);
+      }
+    }
+
     return { ang: ang_pos, vel: ang_vel, acc: ang_acc };
   }
 
@@ -444,39 +500,44 @@ export class AnalysisSolveService {
     return { omega2, omega3, omega4 };
   }
 
-  private findJointPair(link: any, subJoints: JointAnalysis[], jointIDs: number[], t: number): { idxA: number; idxB: number } | null {
-    const linkJointIds = Array.from(link.joints.keys())
-      .map(j => Number(j))
-      .sort((a, b) => a - b);
+  private findJointPair(
+    link: any,
+    subJoints: JointAnalysis[],
+    jointIDs: number[],
+    t: number
+  ): { idxA: number; idxB: number } | null {
 
-    // Map link joint ids -> indices into subJoints (aligned with jointIDs)
+    const mech = this.stateService.getMechanism();
+    const allLinks = mech.getArrayOfLinks();
+    const degMap = this.buildJointDegreeMap(allLinks);
+
+    const linkJointIds = Array.from(link.joints.keys()).map(j => Number(j));
+
+    // Prefer joints that connect to other links (degree > 1)
+    let preferred = linkJointIds.filter(jid => (degMap.get(jid) ?? 0) > 1);
+
+    // Fallback if we can't find two connection joints
+    if (preferred.length < 2) preferred = linkJointIds;
+
+    // Map joint ids -> indices into subJoints
     const idxs: number[] = [];
-    for (const jid of linkJointIds) {
+    for (const jid of preferred) {
       const idx = jointIDs.indexOf(jid);
       if (idx >= 0) idxs.push(idx);
     }
 
-    let bestI = -1, bestJ = -1;
-    let bestD2 = -Infinity;
-
+    // Pick farthest pair among preferred candidates (stable + works well)
+    let bestI = -1, bestJ = -1, bestD2 = -Infinity;
     for (let a = 0; a < idxs.length; a++) {
       for (let b = a + 1; b < idxs.length; b++) {
-        const i = idxs[a];
-        const j = idxs[b];
-
+        const i = idxs[a], j = idxs[b];
         const p = subJoints[i]?.positions?.[t];
         const q = subJoints[j]?.positions?.[t];
         if (!p || !q) continue;
 
-        const dx = q.x - p.x;
-        const dy = q.y - p.y;
-        const d2 = dx * dx + dy * dy;
-
-        if (d2 > bestD2) {
-          bestD2 = d2;
-          bestI = i;
-          bestJ = j;
-        }
+        const dx = q.x - p.x, dy = q.y - p.y;
+        const d2 = dx*dx + dy*dy;
+        if (d2 > bestD2) { bestD2 = d2; bestI = i; bestJ = j; }
       }
     }
 
@@ -484,6 +545,86 @@ export class AnalysisSolveService {
     return { idxA: bestI, idxB: bestJ };
   }
 
+  private identifyFourBarLinks(links: Link[]): {
+    inputLink?: Link;
+    couplerLink?: Link;
+    outputLink?: Link;
+    groundLink?: Link;
+    inputJoint?: Joint;
+  } {
+    const mech = this.stateService.getMechanism();
+    const joints = mech.getArrayOfJoints();
+    const inputJoint = joints.find(j => j.isInput);
+    const groundedJoints = joints.filter(j => j.isGrounded);
+
+    const isGroundLink = (link: Link) => {
+      const js = link.getJoints();
+      return js.length >= 2 && js.every(j => j.isGrounded);
+    };
+
+    const groundLink = links.find(isGroundLink);
+
+    let inputLink: Link | undefined;
+    let inputOther: Joint | undefined;
+    if (inputJoint) {
+      for (const l of links) {
+        if (!l.containsJoint(inputJoint.id)) continue;
+        const other = l.getJoints().find(j => j.id !== inputJoint.id);
+        if (other && !other.isGrounded) {
+          inputLink = l;
+          inputOther = other;
+          break;
+        }
+      }
+    }
+
+    let outputJoint: Joint | undefined;
+    if (inputJoint) {
+      outputJoint = groundedJoints.find(j => j.id !== inputJoint.id);
+    }
+
+    let outputLink: Link | undefined;
+    let outputOther: Joint | undefined;
+    if (outputJoint) {
+      for (const l of links) {
+        if (!l.containsJoint(outputJoint.id)) continue;
+        const other = l.getJoints().find(j => j.id !== outputJoint?.id);
+        if (other && !other.isGrounded) {
+          outputLink = l;
+          outputOther = other;
+          break;
+        }
+      }
+    }
+
+    let couplerLink: Link | undefined;
+    if (inputOther && outputOther) {
+      const inputOtherId = inputOther.id;
+      const outputOtherId = outputOther.id;
+      couplerLink = links.find(l => l.containsJoint(inputOtherId) && l.containsJoint(outputOtherId));
+    }
+    if (!couplerLink) {
+      couplerLink = links.find(l =>
+        l !== inputLink &&
+        l !== outputLink &&
+        l !== groundLink &&
+        l.getJoints().every(j => !j.isGrounded)
+      );
+    }
+
+    return { inputLink, couplerLink, outputLink, groundLink, inputJoint };
+  }
+
+
+  private buildJointDegreeMap(links: any[]): Map<number, number> {
+    const deg = new Map<number, number>();
+    for (const link of links) {
+      for (const jid of link.joints.keys()) {
+        deg.set(Number(jid), (deg.get(Number(jid)) ?? 0) + 1);
+      }
+    }
+    return deg;
+  }
 
 
 }

From 1030bc83956db7063563c1214ff8952d6ef7a3c9 Mon Sep 17 00:00:00 2001
From: mwalsh001 <matty71604@gmail.com>
Date: Mon, 23 Mar 2026 11:17:41 -0400
Subject: [PATCH 14/23] 4-bar velocity calculations.

---
 .../link-analysis-panel.component.html        |  24 +-
 .../link-analysis-panel.component.ts          | 807 +++------------
 src/app/services/analysis-solver.service.ts   | 919 ++++++++++++------
 3 files changed, 791 insertions(+), 959 deletions(-)

diff --git a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.html b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.html
index de85da12..2eb886a2 100644
--- a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.html
+++ b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.html
@@ -145,13 +145,13 @@
         <td class="border px-4 py-2">Position</td>
         <td class="border px-4 py-2 text-center">
           <label class="switch">
-            <input type="checkbox">
+            <input type="checkbox" data-parameter="position" data-entity="joints">
             <span class="slider round"></span>
           </label>
         </td>
         <td class="border px-4 py-2 text-center">
           <label class="switch">
-            <input type="checkbox">
+            <input type="checkbox" data-parameter="position" data-entity="links">
             <span class="slider round"></span>
           </label>
         </td>
@@ -161,13 +161,13 @@
         <td class="border px-4 py-2">Velocity</td>
         <td class="border px-4 py-2 text-center">
           <label class="switch">
-            <input type="checkbox">
+            <input type="checkbox" data-parameter="velocity" data-entity="joints">
             <span class="slider round"></span>
           </label>
         </td>
         <td class="border px-4 py-2 text-center">
           <label class="switch">
-            <input type="checkbox">
+            <input type="checkbox" data-parameter="velocity" data-entity="links">
             <span class="slider round"></span>
           </label>
         </td>
@@ -177,13 +177,13 @@
         <td class="border px-4 py-2">Acceleration</td>
         <td class="border px-4 py-2 text-center">
           <label class="switch">
-            <input type="checkbox">
+            <input type="checkbox" data-parameter="acceleration" data-entity="joints">
             <span class="slider round"></span>
           </label>
         </td>
         <td class="border px-4 py-2 text-center">
           <label class="switch">
-            <input type="checkbox">
+            <input type="checkbox" data-parameter="acceleration" data-entity="links">
             <span class="slider round"></span>
           </label>
         </td>
@@ -193,7 +193,7 @@
         <td class="border px-4 py-2">Forces/Torque</td>
         <td class="border px-4 py-2 text-center">
           <label class="switch">
-            <input type="checkbox">
+            <input type="checkbox" data-parameter="forces-torque" data-entity="joints">
             <span class="slider round"></span>
           </label>
         </td>
@@ -204,13 +204,13 @@
         <td class="border px-4 py-2">Stress</td>
         <td class="border px-4 py-2 text-center">
           <label class="switch">
-            <input type="checkbox">
+            <input type="checkbox" data-parameter="stress" data-entity="joints">
             <span class="slider round"></span>
           </label>
         </td>
         <td class="border px-4 py-2 text-center">
           <label class="switch">
-            <input type="checkbox">
+            <input type="checkbox" data-parameter="stress" data-entity="links">
             <span class="slider round"></span>
           </label>
         </td>
@@ -221,7 +221,7 @@
         <td class="border px-4 py-2"></td>
         <td class="border px-4 py-2 text-center">
           <label class="switch">
-            <input type="checkbox">
+            <input type="checkbox" data-parameter="instant-centers" data-entity="links">
             <span class="slider round"></span>
           </label>
         </td>
@@ -233,7 +233,7 @@
         <td class="border px-4 py-2"></td>
         <td class="border px-4 py-2 text-center">
           <label class="switch">
-            <input type="checkbox">
+            <input type="checkbox" data-parameter="three-position-synthesis" data-entity="custom">
             <span class="slider round"></span>
           </label>
         </td>
@@ -244,7 +244,7 @@
         <td class="border px-4 py-2"></td>
         <td class="border px-4 py-2 text-center">
           <label class="switch">
-            <input type="checkbox">
+            <input type="checkbox" data-parameter="path-synthesis" data-entity="custom">
             <span class="slider round"></span>
           </label>
         </td>
diff --git a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
index 5fc9e141..6a2f84f6 100644
--- a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
+++ b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
@@ -5,7 +5,6 @@ import {Mechanism} from "src/app/model/mechanism";
 import {LinkInteractor} from "src/app/controllers/link-interactor";
 import {Joint} from "src/app/model/joint";
 import {AnalysisSolveService, JointAnalysis, LinkAnalysis} from "src/app/services/analysis-solver.service";
-import {Coord} from "../../../../model/coord";
 
 // enum contains every kind of graph this panel can open.
 export enum GraphType {
@@ -19,9 +18,9 @@ export enum GraphType {
 }
 
 @Component({
-    selector: 'app-link-analysis-panel',
-    templateUrl: './link-analysis-panel.component.html',
-    styleUrls: ['./link-analysis-panel.component.scss'],
+  selector: 'app-link-analysis-panel',
+  templateUrl: './link-analysis-panel.component.html',
+  styleUrls: ['./link-analysis-panel.component.scss'],
 
 })
 
@@ -31,17 +30,16 @@ export class LinkAnalysisPanelComponent {
   referenceJoint: Joint = this.getCurrentLink().joints.get(0) as Joint;
   currentGlobalUSuffix: any;
   currentGlobalAngleSuffix: any;
-
   constructor(private stateService: StateService, private interactorService: InteractionService,
               private analysisSolverService: AnalysisSolveService){
-                this.stateService.globalUSuffixCurrent.subscribe(value => {
-                  this.currentGlobalUSuffix = value;
-                });
-                this.stateService.globalASuffixCurrent.subscribe(value => {
-                  this.currentGlobalAngleSuffix = value;
-                });
+    this.stateService.globalUSuffixCurrent.subscribe(value => {
+      this.currentGlobalUSuffix = value;
+    });
+    this.stateService.globalASuffixCurrent.subscribe(value => {
+      this.currentGlobalAngleSuffix = value;
+    });
 
-    }
+  }
 
   getMechanism(): Mechanism {return this.stateService.getMechanism();}
   getCurrentLink(){
@@ -49,17 +47,17 @@ export class LinkAnalysisPanelComponent {
     return (currentLinkInteractor as LinkInteractor).getLink();
   }
   getLinkName(): string {return this.getCurrentLink().name;}
-    getReferenceJoint(){return this.referenceJoint;}
+  getReferenceJoint(){return this.referenceJoint;}
 // get x coord and y coord return the number of the center of mass
   getCOMXCoord(): number {return this.getCurrentLink()?.centerOfMass.x.toFixed(3) as unknown as number;}
-    getCOMYCoord(): number {return this.getCurrentLink()?.centerOfMass.y.toFixed(3) as unknown as number;}
+  getCOMYCoord(): number {return this.getCurrentLink()?.centerOfMass.y.toFixed(3) as unknown as number;}
   openAnalysisGraph(graphType: GraphType): void {
     this.currentGraphType = graphType;
-    // if(this.currentGraphType == GraphType.CoMPosition ||
-    //   this.currentGraphType == GraphType.CoMVelocity ||
-    //   this.currentGraphType == GraphType.CoMAcceleration){
-    //   this.addPlaceholderCoMJoint();
-    // }
+    if(this.currentGraphType == GraphType.CoMPosition ||
+      this.currentGraphType == GraphType.CoMVelocity ||
+      this.currentGraphType == GraphType.CoMAcceleration){
+      this.addPlaceholderCoMJoint();
+    }
     this.getGraphData();
   }
 
@@ -139,19 +137,13 @@ export class LinkAnalysisPanelComponent {
 
     // @ts-ignore
     return maxJoint;
-}
+  }
 
   // calls the positionSolver on current joint and reformats data into a type that chart,js can take
   // see transformJointKinematicGraph function in kinematic solver for more detail
   getGraphData() {
     this.analysisSolverService.updateKinematics();
     let jointKinematics: JointAnalysis;
-    let currentLinkId = this.getCurrentLink().id;
-    const links = this.getMechanism().getArrayOfLinks();
-    const linkIndex = links.findIndex(link => link.id === currentLinkId);
-    let joints = this.getMechanism().getArrayOfJoints();
-    let jointIds = joints.map(joint => joint.id);
-
     switch(this.currentGraphType) {
       case GraphType.CoMPosition:
         jointKinematics = this.analysisSolverService.getJointKinematics(this.getPlaceholderCoMJoint().id);
@@ -168,7 +160,9 @@ export class LinkAnalysisPanelComponent {
 
       case GraphType.referenceJointAngle:
         if(this.getReferenceJoint() !== undefined) {
-          let linkKinematics = this.analysisSolverService.getLinkKinematics(jointIds, linkIndex);
+          let joints = this.getCurrentLink().getJoints();
+          let jointIds = joints.map(joint => joint.id);
+          let linkKinematics = this.analysisSolverService.getLinkKinematics(jointIds);
           return this.analysisSolverService.transformLinkKinematicGraph(linkKinematics, "Angle");
         }
         return {
@@ -179,7 +173,9 @@ export class LinkAnalysisPanelComponent {
 
       case GraphType.referenceJointAngularVelocity:
         if(this.getReferenceJoint() !== undefined) {
-          let linkKinematics = this.analysisSolverService.getLinkKinematics(jointIds, linkIndex);
+          let joints = this.getCurrentLink().getJoints();
+          let jointIds = joints.map(joint => joint.id);
+          let linkKinematics = this.analysisSolverService.getLinkKinematics(jointIds);
           return this.analysisSolverService.transformLinkKinematicGraph(linkKinematics, "Velocity");
         }
         return {
@@ -190,7 +186,9 @@ export class LinkAnalysisPanelComponent {
 
       case GraphType.referenceJointAngularAcceleration:
         if(this.getReferenceJoint() !== undefined) {
-          let linkKinematics = this.analysisSolverService.getLinkKinematics(jointIds, -1);
+          let joints = this.getCurrentLink().getJoints();
+          let jointIds = joints.map(joint => joint.id);
+          let linkKinematics = this.analysisSolverService.getLinkKinematics(jointIds);
           return this.analysisSolverService.transformLinkKinematicGraph(linkKinematics, "Acceleration");
         }
         return {
@@ -208,656 +206,157 @@ export class LinkAnalysisPanelComponent {
   }
   public GraphType = GraphType;
 
-  // Re-write from original
-  downloadCSV(): void {
-    console.log("DOWNLOAD CSV (multi-link angular data)");
+  downloadCSV() {
+    const table = document.querySelector(".table-auto");
+    if (!table) return;
 
-    // 1. Make sure kinematics are up to date
-    this.analysisSolverService.updateKinematics();
+    const selections = Array.from(
+      table.querySelectorAll<HTMLInputElement>("input[type='checkbox']:checked")
+    ).map((input) => ({
+      entity: input.dataset["entity"] || "",
+      parameter: input.dataset["parameter"] || ""
+    }));
 
-    const mechanism = this.getMechanism();
-    const allLinks = mechanism.getArrayOfLinks();          // all Link objects
-    const allJoints = mechanism.getArrayOfJoints();
-    const jointIds = allJoints.map(j => j.id);
-
-    if (!allLinks.length) {
-      alert("No links in mechanism.");
+    if (selections.length === 0) {
+      alert("No selections made");
       return;
     }
 
-    // OPTIONAL: if you want to skip a ground link, you can filter here.
-    // Example heuristic: ignore links whose joints are all grounded.
-    // (Assumes your Joint class has `isGrounded`.)
-    const movingLinks = allLinks.filter(link =>
-      !link.getJoints().every(j => (j as any).isGrounded)
-    );
-
-    const linksToExport = movingLinks.length ? movingLinks : allLinks;
-
-    // 2. For each link, get its LinkAnalysis (angle + angularVelocity arrays)
-    const perLinkData = linksToExport.map(link => {
-      const linkIndex = allLinks.findIndex(l => l.id === link.id);
-      const analysis = this.analysisSolverService.getLinkKinematics(
-        jointIds,
-        linkIndex
-      );
-
-      return {
-        link,
-        analysis,                           // LinkAnalysis
-        name: link.name || `Link ${link.id}`
-      };
-    });
-
-    const EPS = 1e-6;
-    const movingPerLinkData = perLinkData.filter(d =>
-      d.analysis.angularVelocity.some(w => Math.abs(w) > EPS)
+    const unsupportedSelections = selections.filter(selection =>
+      !["position", "velocity", "acceleration"].includes(selection.parameter)
     );
-
-    if (!perLinkData.length) {
-      alert("No link kinematics available.");
+    if (unsupportedSelections.length > 0) {
+      alert("CSV export currently supports only position, velocity, and acceleration selections.");
       return;
     }
 
-    // Assume all links share same timeIncrement & number of steps
-    const numSteps = movingPerLinkData[0].analysis.angularVelocity.length;
-    const dt       = movingPerLinkData[0].analysis.timeIncrement;
+    this.analysisSolverService.updateKinematics();
+    const mechanism = this.getMechanism();
+    const mechanismJoints = mechanism.getArrayOfJoints()
+      .map(joint => ({joint, analysis: this.analysisSolverService.getJointKinematics(joint.id)}))
+      .filter(({analysis}) => !!analysis);
+    const mechanismLinks = mechanism.getArrayOfLinks()
+      .map(link => ({link, joints: link.getJoints()}))
+      .filter(({joints}) => joints.length >= 2)
+      .map(({link, joints}) => ({
+        link,
+        analysis: this.analysisSolverService.getLinkKinematics(joints.map(joint => joint.id))
+      }))
+      .filter(({analysis}) => !!analysis);
 
-    if (!numSteps) {
-      alert("No time steps in kinematic solution.");
+    if (mechanismJoints.length === 0 && mechanismLinks.length === 0) {
+      alert("No kinematic data available for export.");
       return;
     }
 
-    // 3. Build header row
-    const header: string[] = ["Current Time"];
-    for (const d of movingPerLinkData) {
-      header.push(`${d.name} angle degree`);
-      header.push(`${d.name} angVel rad/s`);
-    }
+    const series: Array<{header: string, values: number[]}> = [];
 
-    const rows: string[] = [];
-    rows.push(header.join(","));
+    const jointParameters = selections
+      .filter(selection => selection.entity === "joints")
+      .map(selection => selection.parameter);
+    const linkParameters = selections
+      .filter(selection => selection.entity === "links")
+      .map(selection => selection.parameter);
 
-    // 4. Build data rows: one row per time step
-    for (let i = 0; i < numSteps; i++) {
-      const t = (i * dt).toFixed(5);
-      const row: string[] = [t];
+    if (jointParameters.length > 0) {
+      this.appendJointSeries(series, mechanismJoints, jointParameters);
+    }
 
-      for (const d of movingPerLinkData) {
-        const angRad = d.analysis.angle[i] ?? 0;
-        const omega  = d.analysis.angularVelocity[i] ?? 0;
+    if (linkParameters.length > 0) {
+      for (const {link, analysis} of mechanismLinks) {
+        this.appendLinkSeries(series, link.name, analysis, linkParameters);
+      }
+    }
 
-        const angDeg = (angRad * 180 / Math.PI).toFixed(4);
-        const omegaStr = omega.toFixed(4);
+    if (series.length === 0) {
+      alert("The selected export options did not produce any CSV data.");
+      return;
+    }
 
-        row.push(angDeg, omegaStr);
-      }
+    const numFrames = series[0].values.length;
+    const timeIncrement = mechanismLinks[0]?.analysis.timeIncrement || mechanismJoints[0]?.analysis.timeIncrement || 0;
+    const rows: string[] = [["Time", ...series.map(item => item.header)].join(",")];
 
-      rows.push(row.join(","));
+    for (let index = 0; index < numFrames; index++) {
+      const time = timeIncrement > 0 ? index * timeIncrement : index;
+      rows.push([time, ...series.map(item => item.values[index])].join(","));
     }
 
     const csvContent = rows.join("\n");
 
-    // 5. Download as CSV
-    const blob = new Blob([csvContent], { type: "text/csv;charset=utf-8;" });
-    const url = URL.createObjectURL(blob);
-    const linkEl = document.createElement("a");
-    linkEl.href = url;
-    linkEl.download = "link_angular_kinematics.csv";
-    document.body.appendChild(linkEl);
-    linkEl.click();
-    document.body.removeChild(linkEl);
-    URL.revokeObjectURL(url);
+    const blob = new Blob([csvContent], { type: "text/csv" });
+    const link = document.createElement("a");
+    link.href = URL.createObjectURL(blob);
+    link.download = "selected_data.csv";
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
   }
 
+  private appendJointSeries(
+    series: Array<{header: string, values: number[]}>,
+    jointAnalyses: Array<{joint: Joint, analysis: JointAnalysis}>,
+    parameters: string[]
+  ): void {
+    for (const {joint, analysis} of jointAnalyses) {
+      for (const parameter of parameters) {
+        switch (parameter) {
+          case "position":
+            series.push(
+              {header: `joint_${joint.id}_x`, values: analysis.positions.map(coord => coord.x)},
+              {header: `joint_${joint.id}_y`, values: analysis.positions.map(coord => coord.y)}
+            );
+            break;
+          case "velocity":
+            series.push(
+              {header: `joint_${joint.id}_vx`, values: analysis.velocities.map(coord => coord.x)},
+              {header: `joint_${joint.id}_vy`, values: analysis.velocities.map(coord => coord.y)}
+            );
+            break;
+          case "acceleration":
+            series.push(
+              {header: `joint_${joint.id}_ax`, values: analysis.accelerations.map(coord => coord.x)},
+              {header: `joint_${joint.id}_ay`, values: analysis.accelerations.map(coord => coord.y)}
+            );
+            break;
+        }
+      }
+    }
+  }
 
-  getCurrentLinkId(): number | null {
-    const link = this.getCurrentLink();
-    return link ? link.id : null;
+  private appendLinkSeries(
+    series: Array<{header: string, values: number[]}>,
+    linkName: string,
+    linkKinematics: LinkAnalysis,
+    parameters: string[]
+  ): void {
+    for (const parameter of parameters) {
+      switch (parameter) {
+        case "position":
+          series.push(
+            {
+              header: `link_${linkName}_angle_deg`,
+              values: linkKinematics.angle.map(angle => {
+                let normalizedAngle = angle % (2 * Math.PI);
+                if (normalizedAngle < 0) {
+                  normalizedAngle += 2 * Math.PI;
+                }
+                return normalizedAngle * 180 / Math.PI;
+              })
+            }
+          );
+          break;
+        case "velocity":
+          series.push(
+            {header: `link_${linkName}_omega_rad_s`, values: linkKinematics.angularVelocity}
+          );
+          break;
+        case "acceleration":
+          series.push(
+            {header: `link_${linkName}_alpha_rad_s2`, values: linkKinematics.angularAcceleration}
+          );
+          break;
+      }
+    }
   }
 }
-
-// import { Injectable } from '@angular/core';
-// import { Coord } from '../model/coord';
-// import { Link } from "../model/link";
-// import { PositionSolverService, SolveOrder, SolvePrerequisite, SolveType } from './kinematic-solver.service';
-// import { AnimationPositions } from './kinematic-solver.service';
-// import { create, all, MathJsInstance } from 'mathjs'
-// import {StateService} from "./state.service";
-//
-// export interface JointAnalysis {
-//   timeIncrement: number,
-//   positions: Coord[],
-//   velocities: Coord[],
-//   accelerations: Coord[],
-// }
-// interface LinkSegmentInfo {
-//   linkId: number;
-//   jointIndices: number[];   // indices into jointIDs/subJoints
-// }
-// export interface LinkAnalysis {
-//   timeIncrement: number,
-//   COMpositions: Coord[],
-//   COMvelocities: Coord[],
-//   COMaccelerations: Coord[],
-//   angle: number[],
-//   angularVelocity: number[],
-//   angularAcceleration: number[],
-// }
-//
-// const math: MathJsInstance = create(all, {});
-//
-// @Injectable({
-//   providedIn: 'root'
-// })
-// export class AnalysisSolveService {
-//
-//   private solveOrders: SolveOrder[] = [];
-//   private jointPositions: AnimationPositions[] = [];
-//   private jointKinematics: Map<number, JointAnalysis> = new Map();
-//
-//   constructor(private positionSolver: PositionSolverService, private stateService: StateService,) {
-//   }
-//
-//
-//   // Updates kinematic data by fetching solve orders and joint positions, then solving submechanism kinematics.
-//   updateKinematics() {
-//     /**Order of operations
-//      * 1. First we need the Solve Orders and Positions of the joints from position solver
-//      * 2. For solving links we need to associate model links with the joints being solved for, we can do so by using the
-//      * 3. Iterate over each position, solving for the needed information for both links and joints.
-//      * 4. Update the Information
-//      */
-//     this.solveOrders = this.positionSolver.getSolveOrders();
-//     this.jointPositions = this.positionSolver.getAnimationFrames();
-//     this.jointKinematics = new Map();
-//     for (let i = 0; i < this.solveOrders.length; i++) {
-//       this.solveSubmechanimsKinematics(this.solveOrders[i], this.jointPositions[i]);
-//     }
-//   }
-//
-//   // Solves kinematics for a specific submechanism given its solve order and joint positions.
-//   solveSubmechanimsKinematics(solveOrder: SolveOrder, jointPositions: AnimationPositions) {
-//     /**we are given the animation positions and solve order for a submechanism
-//      * 1. iterate over each set of positions to solve
-//      * 2. call a function that returns all relevant calculations
-//      * 3. update jointKinematics
-//      */
-//     let mechanismVelocities: Coord[][] = [];
-//     let mechanismAccelerations: Coord[][] = [];
-//     for (let time = 0; time < jointPositions.positions.length; time++) {
-//       let solutions = this.solveJointKinematics(solveOrder, jointPositions.positions[time]);
-//       mechanismVelocities.push(solutions.velocities);
-//       mechanismAccelerations.push(solutions.accelerations);
-//     }
-//     const arrayColumn = (array: Coord[][], columnIndex: number) => array.map(row => row[columnIndex])
-//     this.jointKinematics = new Map();
-//     let inputspeed: number = solveOrder.prerequisites.get(solveOrder.order[0])!.jointToSolve.inputSpeed;
-//     let timeIncrement: number = 60 / (inputspeed * 360);
-//     for (let i = 0; i < solveOrder.order.length; i++) {
-//       let accelerations = arrayColumn(mechanismAccelerations, i);
-//       let velocities = arrayColumn(mechanismVelocities, i);
-//       let positions = arrayColumn(jointPositions.positions, i);
-//       let joint: JointAnalysis = {
-//         timeIncrement: timeIncrement,
-//         positions: positions,
-//         velocities: velocities,
-//         accelerations: accelerations
-//       }
-//       this.jointKinematics.set(solveOrder.order[i], joint);
-//     }
-//   }
-//
-//   // Computes velocities and accelerations for all joints in a solve order at a single time step.
-//   solveJointKinematics(solveOrder: SolveOrder, positions: Coord[]): { velocities: Coord[], accelerations: Coord[] } {
-//     let velocities: Coord[] = [];
-//     let accelerations: Coord[] = [];
-//
-//     for (let index = 0; index < solveOrder.order.length; index++) {
-//       let id = solveOrder.order[index];
-//       let prereq = solveOrder.prerequisites.get(id)!;
-//       let velocity_acceleration: { velocity: Coord, acceleration: Coord };
-//       switch (prereq.solveType) {
-//         case SolveType.Ground:
-//           velocities.push(new Coord(0, 0));
-//           accelerations.push(new Coord(0, 0));
-//           break;
-//         case SolveType.RevoluteInput:
-//           velocity_acceleration = this.solveRevInputJointKinematics(index, prereq, positions);
-//           velocities.push(velocity_acceleration.velocity);
-//           accelerations.push(velocity_acceleration.acceleration);
-//           break;
-//         case SolveType.PrismaticInput:
-//           velocity_acceleration = this.solvePrisInputJointKinematics(prereq);
-//           velocities.push(velocity_acceleration.velocity);
-//           accelerations.push(velocity_acceleration.acceleration);
-//           break;
-//         case SolveType.CircleCircle:
-//           let knownIndex1 = solveOrder.order.indexOf(prereq.knownJointOne!.id);
-//           let knownIndex2 = solveOrder.order.indexOf(prereq.knownJointTwo!.id);
-//           velocity_acceleration = this.solveCircleCirlceJointKinematics(index, knownIndex1, knownIndex2, positions, velocities, accelerations);
-//           velocities.push(velocity_acceleration.velocity);
-//           accelerations.push(velocity_acceleration.acceleration);
-//           break;
-//         case SolveType.CircleLine:
-//           knownIndex1 = solveOrder.order.indexOf(prereq.knownJointOne!.id);
-//           velocity_acceleration = this.solveCircleLineJointKinematics(index, knownIndex1, prereq, positions, velocities, accelerations)
-//           velocities.push(velocity_acceleration.velocity);
-//           accelerations.push(velocity_acceleration.acceleration);
-//           break;
-//       }
-//     }
-//     return {velocities: velocities, accelerations: accelerations};
-//   }
-//
-//   //need to account for switching directions
-//   /**
-//    * Solves for the velocity and acceleration of a joint connected to a grounded revolute input
-//    * @param jointIndex - an index for the joint to be solved within with positions array.
-//    * @param prereq - a SolvePrerequisite that corresponds to that joint.
-//    * @param positions - an array of joint positions for a particular timestep.
-//    * @returns
-//    */
-//   solveRevInputJointKinematics(jointIndex: number, prereq: SolvePrerequisite, positions: Coord[]): {
-//     velocity: Coord,
-//     acceleration: Coord
-//   } {
-//
-//     const xDifference = positions[jointIndex].x - positions[0].x;
-//     const yDifference = positions[jointIndex].y - positions[0].y;
-//     const angleToInput: number = Math.atan2(yDifference, xDifference);
-//     const omega: number = 2 * Math.PI * (prereq.knownJointOne!.inputSpeed / 60); //Angular Velocity of Link in Radians
-//     const r: number = prereq.distFromKnownJointOne!;
-//
-//     //velocity
-//     const velocityMagnitude = r * omega; //Velocity magnitude
-//     const velocityTheta = omega > 0 ? angleToInput - Math.PI / 2 : angleToInput + Math.PI / 2; //Velocity direction
-//     const xVelocity: number = Math.cos(velocityTheta) * velocityMagnitude;
-//     const yVelocity: number = Math.sin(velocityTheta) * velocityMagnitude;
-//     const jointVelocity: Coord = new Coord(xVelocity, yVelocity);
-//     //acceleration
-//     const xAcceleration: number = -Math.cos(angleToInput) * velocityMagnitude * omega;
-//     const yAcceleration: number = -Math.sin(angleToInput) * velocityMagnitude * omega;
-//     const jointAcceleration: Coord = new Coord(xAcceleration, yAcceleration);
-//     return {velocity: jointVelocity, acceleration: jointAcceleration};
-//   }
-//
-//   // Calculates velocity and acceleration for a prismatic input joint from its prerequisites.
-//   solvePrisInputJointKinematics(prereq: SolvePrerequisite): { velocity: Coord, acceleration: Coord } {
-//     const velocityMag = prereq.jointToSolve.inputSpeed * (0.05 * 6) //Kinematic solver generates frames for 0.05m increments, and animator uses Rev-Input timeInterval calculation
-//     const velocityTheta = prereq.jointToSolve.angle;
-//     const deltaX: number = Math.cos(velocityTheta) * velocityMag;
-//     const deltaY: number = Math.sin(velocityTheta) * velocityMag;
-//     const jointVelocity: Coord = new Coord(deltaX, deltaY);
-//     const jointAcceleration: Coord = new Coord(0, 0);
-//     return {velocity: jointVelocity, acceleration: jointAcceleration};
-//   }
-//
-//   // Determines velocity and acceleration for a joint constrained by two circular motions using known indices, positions, velocities, and accelerations.
-//   solveCircleCirlceJointKinematics(jointIndex: number, known1Index: number, known2Index: number, positions: Coord[], velocities: Coord[], accelerations: Coord[]): {
-//     velocity: Coord,
-//     acceleration: Coord
-//   } {
-//     //velocity
-//     const v_k1: Coord = velocities[known1Index];
-//     const v_k2: Coord = velocities[known2Index];
-//     const pos_j: Coord = positions[jointIndex];
-//     const diff_jk1: Coord = new Coord(pos_j.x - positions[known1Index].x, pos_j.y - positions[known1Index].y);
-//     const diff_jk2: Coord = new Coord(pos_j.x - positions[known2Index].x, pos_j.y - positions[known2Index].y);
-//     const perp_angle_jk1: number = Math.atan2(diff_jk1.y, diff_jk1.x) + Math.PI / 2;
-//     const perp_angle_jk2: number = Math.atan2(diff_jk2.y, diff_jk2.x) + Math.PI / 2;
-//     const jointVelocity: Coord = this.parametricLineIntersection(v_k1, perp_angle_jk1, v_k2, perp_angle_jk2);
-//     //acceleration of k1 + (V_k1j^2 / (k1-j)) for centripetal,
-//     const x_centripetal_accel_jk1: number = accelerations[known1Index].x + Math.pow(jointVelocity.x, 2) / (-diff_jk1.x);
-//     const y_centripetal_accel_jk1: number = accelerations[known1Index].y + Math.pow(jointVelocity.y, 2) / (-diff_jk1.y);
-//     const x_centripetal_accel_jk2: number = accelerations[known2Index].x + Math.pow(jointVelocity.x, 2) / (-diff_jk2.x);
-//     const y_centripetal_accel_jk2: number = accelerations[known2Index].y + Math.pow(jointVelocity.y, 2) / (-diff_jk2.y);
-//     const centripetal_accel_jk1: Coord = new Coord(x_centripetal_accel_jk1, y_centripetal_accel_jk1);
-//     const centripetal_accel_jk2: Coord = new Coord(x_centripetal_accel_jk2, y_centripetal_accel_jk2);
-//     const jointAcceleration: Coord = this.parametricLineIntersection(centripetal_accel_jk1, perp_angle_jk1, centripetal_accel_jk2, perp_angle_jk2);
-//     return {velocity: jointVelocity, acceleration: jointAcceleration};
-//   }
-//
-//   // Determines velocity and acceleration for a joint constrained by a circle and a line using known index, prerequisites, positions, velocities, and accelerations.
-//   solveCircleLineJointKinematics(jointIndex: number, known1Index: number, prereq: SolvePrerequisite, positions: Coord[], velocities: Coord[], accelerations: Coord[]): {
-//     velocity: Coord,
-//     acceleration: Coord
-//   } {
-//     //velocity
-//     const v_k1: Coord = velocities[known1Index];
-//     const diff_jk1: Coord = new Coord(positions[jointIndex].x - positions[known1Index].x, positions[jointIndex].y - positions[known1Index].y);
-//     const perp_angle_jk1: number = Math.atan2(diff_jk1.y, diff_jk1.x) + Math.PI / 2;
-//     const jointVelocity: Coord = this.parametricLineIntersection(v_k1, perp_angle_jk1, new Coord(0, 0), prereq.jointToSolve.angle);
-//     //acceleration
-//     const x_centripetal_accel_jk1: number = accelerations[known1Index].x + Math.pow(jointVelocity.x, 2) / (-diff_jk1.x);
-//     const y_centripetal_accel_jk1: number = accelerations[known1Index].y + Math.pow(jointVelocity.y, 2) / (-diff_jk1.y);
-//     const centripetal_accel_jk1: Coord = new Coord(x_centripetal_accel_jk1, y_centripetal_accel_jk1);
-//     const jointAcceleration: Coord = this.parametricLineIntersection(centripetal_accel_jk1, perp_angle_jk1, new Coord(0, 0), prereq.jointToSolve.angle);
-//     return {velocity: jointVelocity, acceleration: jointAcceleration};
-//   }
-//
-//   // Finds the intersection point of two parametric lines defined by starting coordinates and angles.
-//   parametricLineIntersection(pos1: Coord, theta1: number, pos2: Coord, theta2: number): Coord {
-//     const t_2 = ((pos1.y - pos2.y) + ((pos2.x - pos1.x) / Math.cos(theta1))) / ((Math.sin(theta2)) - (Math.cos(theta2) / Math.cos(theta1)));
-//     const x_intersection = pos2.x + (t_2 * Math.cos(theta2));
-//     const y_intersection = pos2.y + (t_2 * Math.sin(theta2));
-//     return new Coord(x_intersection, y_intersection);
-//   }
-//
-//   // Retrieves stored kinematic analysis (positions, velocities, accelerations) for a specific joint ID.
-//   getJointKinematics(jointID: number): JointAnalysis {
-//     return this.jointKinematics.get(jointID)!;
-//   }
-//
-//   // Converts joint kinematic data into arrays suitable for plotting, based on requested data type (position, velocity, or acceleration).
-//   transformJointKinematicGraph(jointAnalysis: JointAnalysis, dataOf: string): {
-//     xData: any[],
-//     yData: any[],
-//     timeLabels: string[]
-//   } {
-//     const xData: any[] = [];
-//     const yData: any[] = [];
-//     const timeLabels: string[] = [];
-//
-//     switch (dataOf) {
-//       case ("Position"):
-//         xData.push({data: jointAnalysis.positions.map(coord => coord.x), label: "X data of Position"});
-//         yData.push({data: jointAnalysis.positions.map(coord => coord.y), label: "Y data of Position"});
-//         timeLabels.push(...jointAnalysis.positions.map((_, index) => String(index)));
-//
-//         return {xData, yData, timeLabels};
-//
-//       case ("Velocity"):
-//         xData.push({data: jointAnalysis.velocities.map(coord => coord.x), label: "X data of Velocity"});
-//         yData.push({data: jointAnalysis.velocities.map(coord => coord.y), label: "Y data of Velocity"});
-//         timeLabels.push(...jointAnalysis.velocities.map((_, index) => String(index)));
-//
-//         return {xData, yData, timeLabels};
-//
-//       case ("Acceleration"):
-//         xData.push({data: jointAnalysis.accelerations.map(coord => coord.x), label: "X data of Acceleration"});
-//         yData.push({data: jointAnalysis.accelerations.map(coord => coord.y), label: "Y data of Acceleration"});
-//         timeLabels.push(...jointAnalysis.accelerations.map((_, index) => String(index)));
-//
-//         return {xData, yData, timeLabels};
-//
-//       default:
-//         console.error("Invalid Graph type detected! Returning default values.")
-//         return {xData, yData, timeLabels};
-//     }
-//
-//   }
-//
-//   // Converts link kinematic data into arrays suitable for plotting, based on requested data type (angle, velocity, or acceleration).
-//   transformLinkKinematicGraph(linkAnalysis: LinkAnalysis, dataOf: string): {
-//     xData: any[],
-//     yData: any[],
-//     timeLabels: string[]
-//   } {
-//     const xData: any[] = [];
-//     const yData: any[] = [];
-//     const timeLabels: string[] = [];
-//
-//     switch (dataOf) {
-//       case ("Angle"):
-//         xData.push({data: linkAnalysis.angle, label: "Angle of Reference Joint"});
-//         timeLabels.push(...linkAnalysis.angle.map((_, index) => String(index)));
-//
-//         return {xData, yData, timeLabels};
-//
-//       case ("Velocity"):
-//         // xData.push({data: linkAnalysis.angularVelocity.map(a => ), label: "Angular Velocity"});
-//         // xData.push({data: linkAnalysis.angularVelocity, label: "Angular Velocity"});
-//         xData.push({data: linkAnalysis.angularVelocity, label: "Angular Velocity (rad/s)"});
-//         timeLabels.push(...linkAnalysis.angularVelocity.map((_, index) => String(index)));
-//
-//         return {xData, yData, timeLabels};
-//
-//       case ("Acceleration"):
-//         xData.push({data: linkAnalysis.angularAcceleration, label: "Angular Acceleration"});
-//         timeLabels.push(...linkAnalysis.angularAcceleration.map((_, index) => String(index)));
-//
-//         return {xData, yData, timeLabels};
-//
-//       default:
-//         console.error("Invalid Graph type detected! Returning default values.")
-//         return {xData, yData, timeLabels};
-//     }
-//
-//   }
-//
-//   // Computes center-of-mass and angular kinematics for a link given its associated joint IDs.
-//   getLinkKinematics(jointIDs: number[], linkIndex: number): LinkAnalysis {
-//     let subJoints: JointAnalysis[] = [];
-//
-//     for (let id of jointIDs) {
-//       const jointData = this.jointKinematics.get(id);
-//       subJoints.push(jointData!);
-//     }
-//     let com_solutions: { pos: Coord[], vel: Coord[], acc: Coord[] } = this.getLinkCOMSolutions(subJoints);
-//     let angle_solutions = this.getLinkAngularSolutions(subJoints, jointIDs, linkIndex);
-//
-//     return {
-//       timeIncrement: subJoints[0].timeIncrement,
-//       COMpositions: com_solutions.pos,
-//       COMvelocities: com_solutions.vel,
-//       COMaccelerations: com_solutions.acc,
-//       angle: angle_solutions.ang,
-//       angularVelocity: angle_solutions.vel,
-//       angularAcceleration: angle_solutions.acc,
-//     } as LinkAnalysis
-//
-//   }
-//
-//   // Calculates center-of-mass positions, velocities, and accelerations from joint-level kinematic data for a link.
-//   getLinkCOMSolutions(subJoints: JointAnalysis[]) {
-//     let com_positions: Coord[] = [];
-//     let com_velocities: Coord[] = [];
-//     let com_accelerations: Coord[] = [];
-//     for (let time = 0; time < subJoints[0].positions.length; time++) {
-//       let x_pos: number = 0;
-//       let y_pos: number = 0;
-//       let x_vel: number = 0;
-//       let y_vel: number = 0;
-//       let x_acc: number = 0;
-//       let y_acc: number = 0;
-//       let denominator: number = subJoints.length;
-//       for (let joint of subJoints) {
-//         x_pos += joint.positions[time].x;
-//         y_pos += joint.positions[time].y;
-//         x_vel += joint.velocities[time].x;
-//         y_vel += joint.velocities[time].y;
-//         x_acc += joint.accelerations[time].x;
-//         y_acc += joint.accelerations[time].y;
-//       }
-//       com_positions.push(new Coord(x_pos / denominator, y_pos / denominator));
-//       com_velocities.push(new Coord(x_vel / denominator, y_vel / denominator));
-//       com_accelerations.push(new Coord(x_acc / denominator, y_acc / denominator))
-//     }
-//     return {pos: com_positions, vel: com_velocities, acc: com_accelerations}
-//   }
-//
-//   // Calculates angular positions, velocities, and accelerations for all links.
-//   getLinkAngularSolutions(subJoints: JointAnalysis[], jointIDs: number[], linkIndex: number) {
-//     const mech = this.stateService.getMechanism();
-//     const links = mech.getArrayOfLinks();
-//     const link = links[linkIndex];
-//
-//     let ang_pos: number[] = [];
-//     let ang_vel: number[] = [];
-//     let ang_acc: number[] = [];
-//
-//     const numSteps = subJoints?.[0]?.positions?.length ?? 0;
-//     if (!numSteps || !link) return { ang: ang_pos, vel: ang_vel, acc: ang_acc };
-//
-//     // Link lengths from mechanism
-//     const r2 = links[0]?.length ?? 0;
-//     const r3 = links[1]?.length ?? 0;
-//     const r4 = links[2]?.length ?? 0;
-//
-//     // Known input speed -> omega2
-//     const rpm = mech.getInputSpeed();
-//     const omega2 = 2 * Math.PI * (rpm / 60);
-//
-//     const normalizeAngle = (theta: number) => {
-//       const twoPi = 2 * Math.PI;
-//       const t = theta % twoPi;
-//       return t < 0 ? t + twoPi : t;
-//     };
-//
-//     const unwrapAngle = (prevUnwrapped: number, prevRaw: number, raw: number) => {
-//       let delta = raw - prevRaw;
-//       if (delta > Math.PI) delta -= 2 * Math.PI;
-//       else if (delta < -Math.PI) delta += 2 * Math.PI;
-//       return prevUnwrapped + delta;
-//     };
-//
-//     let prevThetaRaw: number | null = null;
-//     let prevThetaUnwrapped: number | null = null;
-//     const thetaUnwrapped: number[] = [];
-//
-//     for (let t = 0; t < numSteps; t++) {
-//       // Theta for the CURRENT exported link
-//       const thisLink = this.findJointPair(link, subJoints, jointIDs, t);
-//       if (!thisLink) {
-//         ang_pos.push(0); ang_vel.push(0); ang_acc.push(0);
-//         continue;
-//       }
-//
-//       const thisA = subJoints[thisLink.idxA].positions[t];
-//       const thisB = subJoints[thisLink.idxB].positions[t];
-//       const thisThetaRaw = Math.atan2(thisB.y - thisA.y, thisB.x - thisA.x);
-//       const priorRaw: number | null = prevThetaRaw;
-//       const priorUnwrapped: number | null = prevThetaUnwrapped;
-//       const thisThetaUnwrapped: number = priorRaw === null || priorUnwrapped === null
-//         ? thisThetaRaw
-//         : unwrapAngle(priorUnwrapped, priorRaw, thisThetaRaw);
-//       const dTheta: number = priorUnwrapped === null ? 0 : thisThetaUnwrapped - priorUnwrapped;
-//       prevThetaRaw = thisThetaRaw;
-//       prevThetaUnwrapped = thisThetaUnwrapped;
-//       thetaUnwrapped.push(thisThetaUnwrapped);
-//
-//       ang_pos.push(normalizeAngle(thisThetaRaw));
-//
-//       // Thetas for matrix solver
-//       const p2 = this.findJointPair(links[0], subJoints, jointIDs, t);
-//       const p3 = this.findJointPair(links[1], subJoints, jointIDs, t);
-//       const p4 = this.findJointPair(links[2], subJoints, jointIDs, t);
-//
-//       if (!p2 || !p3 || !p4 || !r2 || !r3 || !r4) {
-//         const omegaFallback = linkIndex === 0 ? omega2 : 0;
-//         const omegaOut = Math.abs(dTheta) > 1e-12 ? Math.sign(dTheta) * Math.abs(omegaFallback) : omegaFallback;
-//         ang_vel.push(omegaOut);
-//         ang_acc.push(0);
-//         continue;
-//       }
-//
-//       // Current timestep positions for each link
-//       const A2 = subJoints[p2.idxA].positions[t];
-//       const B2 = subJoints[p2.idxB].positions[t];
-//       const theta2 = Math.atan2(B2.y - A2.y, B2.x - A2.x);
-//
-//       const A3 = subJoints[p3.idxA].positions[t];
-//       const B3 = subJoints[p3.idxB].positions[t];
-//       const theta3 = Math.atan2(B3.y - A3.y, B3.x - A3.x);
-//
-//       const A4 = subJoints[p4.idxA].positions[t];
-//       const B4 = subJoints[p4.idxB].positions[t];
-//       const theta4 = Math.atan2(B4.y - A4.y, B4.x - A4.x);
-//
-//       // Matrix solution for unknown omegas
-//       const { omega3, omega4 } = this.getAngularVelocities(r2, r3, r4, theta2, theta3, theta4, omega2);
-//
-//       const omegas = [omega2, omega3, omega4];
-//       const omegaCandidate = omegas[linkIndex] ?? 0;
-//       const omegaOut = Math.abs(dTheta) > 1e-12 ? Math.sign(dTheta) * Math.abs(omegaCandidate) : omegaCandidate;
-//
-//       ang_vel.push(omegaOut); // Push the selected link velocity
-//       ang_acc.push(0); // Placeholder for now
-//     }
-//
-//     if (ang_vel.length > 1 && thetaUnwrapped.length > 1) {
-//       const dTheta0 = thetaUnwrapped[1] - thetaUnwrapped[0];
-//       if (Math.abs(dTheta0) > 1e-12) {
-//         ang_vel[0] = Math.sign(dTheta0) * Math.abs(ang_vel[0]);
-//       }
-//     }
-//
-//     return { ang: ang_pos, vel: ang_vel, acc: ang_acc };
-//   }
-//
-//   // Calculate unknown angular velocities of a 4 bar linkage // ω2k×r2+ω3k×r3−ω4k×r4=0
-//   getAngularVelocities( r2: number, r3: number, r4: number, theta2: number, theta3: number, theta4: number, omega2: number ) {
-//     // Build A matrix (2x2) for unknowns
-//     const A = math.matrix([ [-r3 * Math.sin(theta3), r4 * Math.sin(theta4)], [ r3 * Math.cos(theta3), -r4 * Math.cos(theta4)], ]);
-//     // Build right-hand side B (2x1)
-//     const B = math.matrix([ [ r2 * omega2 * Math.sin(theta2) ], [-r2 * omega2 * Math.cos(theta2) ], ]);
-//
-//     // Solve for unknowns (system of equations)
-//     const sol = math.lusolve(A, B) as any;
-//
-//     // get each row (0, 1) in sol matrix
-//     const omega3 = sol.get([0, 0]) as number;
-//     const omega4 = sol.get([1, 0]) as number;
-//     return { omega2, omega3, omega4 };
-//   }
-//
-//   private findJointPair(
-//     link: any,
-//     subJoints: JointAnalysis[],
-//     jointIDs: number[],
-//     t: number
-//   ): { idxA: number; idxB: number } | null {
-//
-//     const mech = this.stateService.getMechanism();
-//     const allLinks = mech.getArrayOfLinks();
-//     const degMap = this.buildJointDegreeMap(allLinks);
-//
-//     const linkJointIds = Array.from(link.joints.keys()).map(j => Number(j));
-//
-//     // Prefer joints that connect to other links (degree > 1)
-//     let preferred = linkJointIds.filter(jid => (degMap.get(jid) ?? 0) > 1);
-//
-//     // Fallback if we can't find two connection joints
-//     if (preferred.length < 2) preferred = linkJointIds;
-//
-//     // Map joint ids -> indices into subJoints
-//     const idxs: number[] = [];
-//     for (const jid of preferred) {
-//       const idx = jointIDs.indexOf(jid);
-//       if (idx >= 0) idxs.push(idx);
-//     }
-//
-//     // Pick farthest pair among preferred candidates (stable + works well)
-//     let bestI = -1, bestJ = -1, bestD2 = -Infinity;
-//     for (let a = 0; a < idxs.length; a++) {
-//       for (let b = a + 1; b < idxs.length; b++) {
-//         const i = idxs[a], j = idxs[b];
-//         const p = subJoints[i]?.positions?.[t];
-//         const q = subJoints[j]?.positions?.[t];
-//         if (!p || !q) continue;
-//
-//         const dx = q.x - p.x, dy = q.y - p.y;
-//         const d2 = dx*dx + dy*dy;
-//         if (d2 > bestD2) { bestD2 = d2; bestI = i; bestJ = j; }
-//       }
-//     }
-//
-//     if (bestI < 0 || bestJ < 0) return null;
-//     return { idxA: bestI, idxB: bestJ };
-//   }
-//
-//
-//   private buildJointDegreeMap(links: any[]): Map<number, number> {
-//     const deg = new Map<number, number>();
-//     for (const link of links) {
-//       for (const jid of link.joints.keys()) {
-//         deg.set(Number(jid), (deg.get(Number(jid)) ?? 0) + 1);
-//       }
-//     }
-//     return deg;
-//   }
-//
-//
-// }
-
diff --git a/src/app/services/analysis-solver.service.ts b/src/app/services/analysis-solver.service.ts
index 18b09cae..24dc0cb9 100644
--- a/src/app/services/analysis-solver.service.ts
+++ b/src/app/services/analysis-solver.service.ts
@@ -1,11 +1,10 @@
 import { Injectable } from '@angular/core';
 import { Coord } from '../model/coord';
-import { Link } from "../model/link";
-import { Joint } from "../model/joint";
 import { PositionSolverService, SolveOrder, SolvePrerequisite, SolveType } from './kinematic-solver.service';
 import { AnimationPositions } from './kinematic-solver.service';
-import { create, all, MathJsInstance } from 'mathjs'
-import {StateService} from "./state.service";
+import { StateService } from './state.service';
+import { create, all, MathJsInstance } from 'mathjs';
+const math: MathJsInstance = create(all, {});
 
 export interface JointAnalysis {
   timeIncrement: number,
@@ -13,10 +12,7 @@ export interface JointAnalysis {
   velocities: Coord[],
   accelerations: Coord[],
 }
-interface LinkSegmentInfo {
-  linkId: number;
-  jointIndices: number[];   // indices into jointIDs/subJoints
-}
+
 export interface LinkAnalysis {
   timeIncrement: number,
   COMpositions: Coord[],
@@ -27,7 +23,77 @@ export interface LinkAnalysis {
   angularAcceleration: number[],
 }
 
-const math: MathJsInstance = create(all, {});
+// ─── Graph types for the generalized loop solver ──────────────────────────────
+
+/** One joint (node) in the mechanism graph. */
+export interface LinkGraphNode {
+  id:         number;
+  isGrounded: boolean;  // joint.isGrounded from the model
+  isInput:    boolean;  // joint.isInput — true only for the grounded motor pivot
+}
+
+/**
+ * One link (undirected edge) connecting joints idA and idB.
+ * The canonical traversal direction is idA → idB.
+ * aGrounded / bGrounded / aIsInput / bIsInput mirror the corresponding
+ * node flags and are stored here so the loop solver never has to look
+ * them up again.
+ */
+export interface LinkGraphEdge {
+  idA:       number;
+  idB:       number;
+  aGrounded: boolean;
+  bGrounded: boolean;
+  aIsInput:  boolean;
+  bIsInput:  boolean;
+}
+
+/**
+ * Undirected adjacency graph for one submechanism.
+ *
+ * NOTE: this graph contains only the links that are explicit in the
+ * SolveOrder prerequisites (crank, couplers, followers).
+ * Ground-to-ground closing edges and prismatic-closing edges are
+ * NOT added here — that is Step 2 (spanning tree + loop detection).
+ */
+export interface LinkGraph {
+  /** Joint-id → node metadata. */
+  nodes: Map<number, LinkGraphNode>;
+  /** All edges derived from the solve prerequisites. */
+  edges: LinkGraphEdge[];
+  /**
+   * Undirected adjacency list.
+   * adj.get(id) is a list of { neighbor, edgeIndex } entries so the
+   * DFS in Step 2 can traverse edges in O(1) and look up edge metadata
+   * by index.
+   */
+  adj: Map<number, Array<{ neighbor: number; edgeIndex: number }>>;
+}
+
+/**
+ * One directed step within a velocity loop.
+ *
+ * idA / idB are the canonical endpoints of the underlying physical link
+ * exactly as stored in the augmented edge list (graph edges + ground-chain
+ * closing edges).  The direction flag records which way the loop walks
+ * across that link:
+ *
+ *   direction = +1  →  step traverses the link idA → idB (canonical)
+ *   direction = −1  →  step traverses the link idB → idA (reversed)
+ *
+ * Sign convention for matrix assembly (Step 4):
+ *   revolute link:  X += direction * (−r sinθ) * ω
+ *                   Y += direction * ( r cosθ) * ω
+ *   prismatic link: X += direction * cosθ_slide * ṡ
+ *                   Y += direction * sinθ_slide * ṡ
+ * where θ is always atan2(idB.pos − idA.pos) regardless of direction.
+ */
+export interface LoopEdge {
+  idA:       number;
+  idB:       number;
+  direction: 1 | -1;
+}
+
 
 @Injectable({
   providedIn: 'root'
@@ -38,9 +104,19 @@ export class AnalysisSolveService {
   private jointPositions: AnimationPositions[] = [];
   private jointKinematics: Map<number, JointAnalysis> = new Map();
 
-  constructor(private positionSolver: PositionSolverService, private stateService: StateService,) {
-  }
+  // Cache of link angular velocities keyed by sorted joint-ID pair, e.g. "2_5".
+  // Populated by computeVelocityLoopOmegas() after each submechanism is solved.
+  private linkAngularVelocityCache: Map<string, number[]> = new Map();
+  // Cache of link angular accelerations keyed by sorted joint-ID pair.
+  private linkAngularAccelerationCache: Map<string, number[]> = new Map();
 
+  // Most-recently solved SolveOrder, retained so exportLinkKinematicsCSV() can be
+  // called on demand without needing a parameter.
+  private lastSolveOrder: SolveOrder | null = null;
+
+  constructor(private positionSolver: PositionSolverService, private stateService: StateService) {
+
+  }
 
   // Updates kinematic data by fetching solve orders and joint positions, then solving submechanism kinematics.
   updateKinematics() {
@@ -52,6 +128,7 @@ export class AnalysisSolveService {
      */
     this.solveOrders = this.positionSolver.getSolveOrders();
     this.jointPositions = this.positionSolver.getAnimationFrames();
+
     this.jointKinematics = new Map();
     for (let i = 0; i < this.solveOrders.length; i++) {
       this.solveSubmechanimsKinematics(this.solveOrders[i], this.jointPositions[i]);
@@ -64,6 +141,7 @@ export class AnalysisSolveService {
      * 1. iterate over each set of positions to solve
      * 2. call a function that returns all relevant calculations
      * 3. update jointKinematics
+     * 4. calls velocity loop solver to compute link angular velocities and accelerations for the submechanism
      */
     let mechanismVelocities: Coord[][] = [];
     let mechanismAccelerations: Coord[][] = [];
@@ -80,14 +158,13 @@ export class AnalysisSolveService {
       let accelerations = arrayColumn(mechanismAccelerations, i);
       let velocities = arrayColumn(mechanismVelocities, i);
       let positions = arrayColumn(jointPositions.positions, i);
-      let joint: JointAnalysis = {
-        timeIncrement: timeIncrement,
-        positions: positions,
-        velocities: velocities,
-        accelerations: accelerations
-      }
+      let joint: JointAnalysis = { timeIncrement: timeIncrement, positions: positions, velocities: velocities, accelerations: accelerations }
       this.jointKinematics.set(solveOrder.order[i], joint);
     }
+
+    // compute link angular velocities using velocity-loop matrix method
+    this.computeVelocityLoopOmegas(solveOrder);
+    this.lastSolveOrder = solveOrder;
   }
 
   // Computes velocities and accelerations for all joints in a solve order at a single time step.
@@ -114,22 +191,24 @@ export class AnalysisSolveService {
           velocities.push(velocity_acceleration.velocity);
           accelerations.push(velocity_acceleration.acceleration);
           break;
-        case SolveType.CircleCircle:
-          let knownIndex1 = solveOrder.order.indexOf(prereq.knownJointOne!.id);
-          let knownIndex2 = solveOrder.order.indexOf(prereq.knownJointTwo!.id);
+        case SolveType.CircleCircle: {
+          const knownIndex1 = solveOrder.order.indexOf(prereq.knownJointOne!.id);
+          const knownIndex2 = solveOrder.order.indexOf(prereq.knownJointTwo!.id);
           velocity_acceleration = this.solveCircleCirlceJointKinematics(index, knownIndex1, knownIndex2, positions, velocities, accelerations);
           velocities.push(velocity_acceleration.velocity);
           accelerations.push(velocity_acceleration.acceleration);
           break;
-        case SolveType.CircleLine:
-          knownIndex1 = solveOrder.order.indexOf(prereq.knownJointOne!.id);
+        }
+        case SolveType.CircleLine: {
+          const knownIndex1 = solveOrder.order.indexOf(prereq.knownJointOne!.id);
           velocity_acceleration = this.solveCircleLineJointKinematics(index, knownIndex1, prereq, positions, velocities, accelerations)
           velocities.push(velocity_acceleration.velocity);
           accelerations.push(velocity_acceleration.acceleration);
           break;
+        }
       }
     }
-    return {velocities: velocities, accelerations: accelerations};
+    return { velocities: velocities, accelerations: accelerations };
   }
 
   //need to account for switching directions
@@ -140,10 +219,7 @@ export class AnalysisSolveService {
    * @param positions - an array of joint positions for a particular timestep.
    * @returns
    */
-  solveRevInputJointKinematics(jointIndex: number, prereq: SolvePrerequisite, positions: Coord[]): {
-    velocity: Coord,
-    acceleration: Coord
-  } {
+  solveRevInputJointKinematics(jointIndex: number, prereq: SolvePrerequisite, positions: Coord[]): { velocity: Coord, acceleration: Coord } {
 
     const xDifference = positions[jointIndex].x - positions[0].x;
     const yDifference = positions[jointIndex].y - positions[0].y;
@@ -153,7 +229,7 @@ export class AnalysisSolveService {
 
     //velocity
     const velocityMagnitude = r * omega; //Velocity magnitude
-    const velocityTheta = omega > 0 ? angleToInput - Math.PI / 2 : angleToInput + Math.PI / 2; //Velocity direction
+    const velocityTheta = omega > 0 ? angleToInput + Math.PI / 2 : angleToInput - Math.PI / 2;
     const xVelocity: number = Math.cos(velocityTheta) * velocityMagnitude;
     const yVelocity: number = Math.sin(velocityTheta) * velocityMagnitude;
     const jointVelocity: Coord = new Coord(xVelocity, yVelocity);
@@ -161,7 +237,7 @@ export class AnalysisSolveService {
     const xAcceleration: number = -Math.cos(angleToInput) * velocityMagnitude * omega;
     const yAcceleration: number = -Math.sin(angleToInput) * velocityMagnitude * omega;
     const jointAcceleration: Coord = new Coord(xAcceleration, yAcceleration);
-    return {velocity: jointVelocity, acceleration: jointAcceleration};
+    return { velocity: jointVelocity, acceleration: jointAcceleration };
   }
 
   // Calculates velocity and acceleration for a prismatic input joint from its prerequisites.
@@ -172,14 +248,11 @@ export class AnalysisSolveService {
     const deltaY: number = Math.sin(velocityTheta) * velocityMag;
     const jointVelocity: Coord = new Coord(deltaX, deltaY);
     const jointAcceleration: Coord = new Coord(0, 0);
-    return {velocity: jointVelocity, acceleration: jointAcceleration};
+    return { velocity: jointVelocity, acceleration: jointAcceleration };
   }
 
   // Determines velocity and acceleration for a joint constrained by two circular motions using known indices, positions, velocities, and accelerations.
-  solveCircleCirlceJointKinematics(jointIndex: number, known1Index: number, known2Index: number, positions: Coord[], velocities: Coord[], accelerations: Coord[]): {
-    velocity: Coord,
-    acceleration: Coord
-  } {
+  solveCircleCirlceJointKinematics(jointIndex: number, known1Index: number, known2Index: number, positions: Coord[], velocities: Coord[], accelerations: Coord[]): { velocity: Coord, acceleration: Coord } {
     //velocity
     const v_k1: Coord = velocities[known1Index];
     const v_k2: Coord = velocities[known2Index];
@@ -197,14 +270,11 @@ export class AnalysisSolveService {
     const centripetal_accel_jk1: Coord = new Coord(x_centripetal_accel_jk1, y_centripetal_accel_jk1);
     const centripetal_accel_jk2: Coord = new Coord(x_centripetal_accel_jk2, y_centripetal_accel_jk2);
     const jointAcceleration: Coord = this.parametricLineIntersection(centripetal_accel_jk1, perp_angle_jk1, centripetal_accel_jk2, perp_angle_jk2);
-    return {velocity: jointVelocity, acceleration: jointAcceleration};
+    return { velocity: jointVelocity, acceleration: jointAcceleration };
   }
 
   // Determines velocity and acceleration for a joint constrained by a circle and a line using known index, prerequisites, positions, velocities, and accelerations.
-  solveCircleLineJointKinematics(jointIndex: number, known1Index: number, prereq: SolvePrerequisite, positions: Coord[], velocities: Coord[], accelerations: Coord[]): {
-    velocity: Coord,
-    acceleration: Coord
-  } {
+  solveCircleLineJointKinematics(jointIndex: number, known1Index: number, prereq: SolvePrerequisite, positions: Coord[], velocities: Coord[], accelerations: Coord[]): { velocity: Coord, acceleration: Coord } {
     //velocity
     const v_k1: Coord = velocities[known1Index];
     const diff_jk1: Coord = new Coord(positions[jointIndex].x - positions[known1Index].x, positions[jointIndex].y - positions[known1Index].y);
@@ -215,9 +285,8 @@ export class AnalysisSolveService {
     const y_centripetal_accel_jk1: number = accelerations[known1Index].y + Math.pow(jointVelocity.y, 2) / (-diff_jk1.y);
     const centripetal_accel_jk1: Coord = new Coord(x_centripetal_accel_jk1, y_centripetal_accel_jk1);
     const jointAcceleration: Coord = this.parametricLineIntersection(centripetal_accel_jk1, perp_angle_jk1, new Coord(0, 0), prereq.jointToSolve.angle);
-    return {velocity: jointVelocity, acceleration: jointAcceleration};
+    return { velocity: jointVelocity, acceleration: jointAcceleration };
   }
-
   // Finds the intersection point of two parametric lines defined by starting coordinates and angles.
   parametricLineIntersection(pos1: Coord, theta1: number, pos2: Coord, theta2: number): Coord {
     const t_2 = ((pos1.y - pos2.y) + ((pos2.x - pos1.x) / Math.cos(theta1))) / ((Math.sin(theta2)) - (Math.cos(theta2) / Math.cos(theta1)));
@@ -232,93 +301,80 @@ export class AnalysisSolveService {
   }
 
   // Converts joint kinematic data into arrays suitable for plotting, based on requested data type (position, velocity, or acceleration).
-  transformJointKinematicGraph(jointAnalysis: JointAnalysis, dataOf: string): {
-    xData: any[],
-    yData: any[],
-    timeLabels: string[]
-  } {
+  transformJointKinematicGraph(jointAnalysis: JointAnalysis, dataOf: string): { xData: any[], yData: any[], timeLabels: string[] } {
     const xData: any[] = [];
     const yData: any[] = [];
     const timeLabels: string[] = [];
 
     switch (dataOf) {
       case ("Position"):
-        xData.push({data: jointAnalysis.positions.map(coord => coord.x), label: "X data of Position"});
-        yData.push({data: jointAnalysis.positions.map(coord => coord.y), label: "Y data of Position"});
+        xData.push({ data: jointAnalysis.positions.map(coord => coord.x), label: "X data of Position" });
+        yData.push({ data: jointAnalysis.positions.map(coord => coord.y), label: "Y data of Position" });
         timeLabels.push(...jointAnalysis.positions.map((_, index) => String(index)));
 
-        return {xData, yData, timeLabels};
+        return { xData, yData, timeLabels };
 
       case ("Velocity"):
-        xData.push({data: jointAnalysis.velocities.map(coord => coord.x), label: "X data of Velocity"});
-        yData.push({data: jointAnalysis.velocities.map(coord => coord.y), label: "Y data of Velocity"});
+        xData.push({ data: jointAnalysis.velocities.map(coord => coord.x), label: "X data of Velocity" });
+        yData.push({ data: jointAnalysis.velocities.map(coord => coord.y), label: "Y data of Velocity" });
         timeLabels.push(...jointAnalysis.velocities.map((_, index) => String(index)));
 
-        return {xData, yData, timeLabels};
+        return { xData, yData, timeLabels };
 
       case ("Acceleration"):
-        xData.push({data: jointAnalysis.accelerations.map(coord => coord.x), label: "X data of Acceleration"});
-        yData.push({data: jointAnalysis.accelerations.map(coord => coord.y), label: "Y data of Acceleration"});
+        xData.push({ data: jointAnalysis.accelerations.map(coord => coord.x), label: "X data of Acceleration" });
+        yData.push({ data: jointAnalysis.accelerations.map(coord => coord.y), label: "Y data of Acceleration" });
         timeLabels.push(...jointAnalysis.accelerations.map((_, index) => String(index)));
 
-        return {xData, yData, timeLabels};
+        return { xData, yData, timeLabels };
 
       default:
         console.error("Invalid Graph type detected! Returning default values.")
-        return {xData, yData, timeLabels};
+        return { xData, yData, timeLabels };
     }
 
   }
 
   // Converts link kinematic data into arrays suitable for plotting, based on requested data type (angle, velocity, or acceleration).
-  transformLinkKinematicGraph(linkAnalysis: LinkAnalysis, dataOf: string): {
-    xData: any[],
-    yData: any[],
-    timeLabels: string[]
-  } {
+  transformLinkKinematicGraph(linkAnalysis: LinkAnalysis, dataOf: string): { xData: any[], yData: any[], timeLabels: string[] } {
     const xData: any[] = [];
     const yData: any[] = [];
     const timeLabels: string[] = [];
 
     switch (dataOf) {
       case ("Angle"):
-        xData.push({data: linkAnalysis.angle, label: "Angle of Reference Joint"});
+        xData.push({ data: linkAnalysis.angle, label: "Angle of Reference Joint" });
         timeLabels.push(...linkAnalysis.angle.map((_, index) => String(index)));
 
-        return {xData, yData, timeLabels};
+        return { xData, yData, timeLabels };
 
       case ("Velocity"):
-        // xData.push({data: linkAnalysis.angularVelocity.map(a => ), label: "Angular Velocity"});
-        // xData.push({data: linkAnalysis.angularVelocity, label: "Angular Velocity"});
-        xData.push({data: linkAnalysis.angularVelocity, label: "Angular Velocity (rad/s)"});
+        xData.push({ data: linkAnalysis.angularVelocity, label: "Angular Velocity" });
         timeLabels.push(...linkAnalysis.angularVelocity.map((_, index) => String(index)));
 
-        return {xData, yData, timeLabels};
+        return { xData, yData, timeLabels };
 
       case ("Acceleration"):
-        xData.push({data: linkAnalysis.angularAcceleration, label: "Angular Acceleration"});
+        xData.push({ data: linkAnalysis.angularAcceleration, label: "Angular Acceleration" });
         timeLabels.push(...linkAnalysis.angularAcceleration.map((_, index) => String(index)));
 
-        return {xData, yData, timeLabels};
+        return { xData, yData, timeLabels };
 
       default:
         console.error("Invalid Graph type detected! Returning default values.")
-        return {xData, yData, timeLabels};
+        return { xData, yData, timeLabels };
     }
 
   }
 
   // Computes center-of-mass and angular kinematics for a link given its associated joint IDs.
-  getLinkKinematics(jointIDs: number[], linkIndex: number): LinkAnalysis {
+  getLinkKinematics(jointIDs: number[]): LinkAnalysis {
     let subJoints: JointAnalysis[] = [];
-
     for (let id of jointIDs) {
-      const jointData = this.jointKinematics.get(id);
-      subJoints.push(jointData!);
+      subJoints.push(this.jointKinematics.get(id)!);
     }
     let com_solutions: { pos: Coord[], vel: Coord[], acc: Coord[] } = this.getLinkCOMSolutions(subJoints);
-    let angle_solutions = this.getLinkAngularSolutions(subJoints, jointIDs, linkIndex);
-
+    let angle_solutions: { ang: number[], vel: number[], acc: number[] } = this.getLinkAngularSolutions(subJoints, jointIDs);
     return {
       timeIncrement: subJoints[0].timeIncrement,
       COMpositions: com_solutions.pos,
@@ -356,276 +412,553 @@ export class AnalysisSolveService {
       com_velocities.push(new Coord(x_vel / denominator, y_vel / denominator));
       com_accelerations.push(new Coord(x_acc / denominator, y_acc / denominator))
     }
-    return {pos: com_positions, vel: com_velocities, acc: com_accelerations}
+    return { pos: com_positions, vel: com_velocities, acc: com_accelerations }
   }
 
-  // Calculates angular positions, velocities, and accelerations for all links.
-  getLinkAngularSolutions(subJoints: JointAnalysis[], jointIDs: number[], linkIndex: number) {
-    const mech = this.stateService.getMechanism();
-    const links = mech.getArrayOfLinks();
-    const link = links[linkIndex];
+  /**
+   * Calculates angular position, velocity, and acceleration for a link.
+   *
+   * Angle:    theta = atan2(yB - yA, xB - xA) using the first two joints at each timestep.
+   * Velocity: omega from the pre-computed velocity-loop cache (see computeVelocityLoopOmegas).
+   * Acceleration: prefers loop-solved alpha, otherwise 0.
+   *
+   * @param subJoints - JointAnalysis objects for the joints on this link (at least 2).
+   * @param jointIDs  - Corresponding joint IDs, used to look up the velocity-loop cache.
+   */
+  getLinkAngularSolutions(subJoints: JointAnalysis[], jointIDs?: number[]): { ang: number[], vel: number[], acc: number[] } {
+    const numSteps = subJoints[0].positions.length;
+
+    if (subJoints.length < 2) {
+      return {
+        ang: new Array(numSteps).fill(0),
+        vel: new Array(numSteps).fill(0),
+        acc: new Array(numSteps).fill(0),
+      };
+    }
+
+    const j0 = subJoints[0];
+    const j1 = subJoints[1];
+
+    // Step 1: link orientation angle theta = atan2(yB - yA, xB - xA)
+    const ang: number[] = [];
+    for (let t = 0; t < numSteps; t++) {
+      ang.push(Math.atan2(
+        j1.positions[t].y - j0.positions[t].y,
+        j1.positions[t].x - j0.positions[t].x,
+      ));
+    }
 
-    let ang_pos: number[] = [];
-    let ang_vel: number[] = [];
-    let ang_acc: number[] = [];
+    if (!jointIDs || jointIDs.length < 2) {
+      return {
+        ang,
+        vel: new Array(numSteps).fill(0),
+        acc: new Array(numSteps).fill(0),
+      };
+    }
 
-    const numSteps = subJoints?.[0]?.positions?.length ?? 0;
-    if (!numSteps || !link) return { ang: ang_pos, vel: ang_vel, acc: ang_acc };
+    const key = this.linkKey(jointIDs[0], jointIDs[1]);
 
-    // Determine which link is actually the input/coupler/output for this mechanism
-    const fourBar = this.identifyFourBarLinks(links);
-    const hasFourBarMap = !!(fourBar.inputLink && fourBar.couplerLink && fourBar.outputLink);
+    const cachedOmega = this.linkAngularVelocityCache.get(key);
+    const vel: number[] = cachedOmega ?? new Array(numSteps).fill(0);
 
-    // Link lengths from mechanism
-    const r2 = hasFourBarMap ? fourBar.inputLink!.length : (links[0]?.length ?? 0);
-    const r3 = hasFourBarMap ? fourBar.couplerLink!.length : (links[1]?.length ?? 0);
-    const r4 = hasFourBarMap ? fourBar.outputLink!.length : (links[2]?.length ?? 0);
+    const cachedAlpha = this.linkAngularAccelerationCache.get(key);
+    const acc: number[] = (cachedAlpha && cachedAlpha.length === numSteps)
+      ? cachedAlpha
+      : new Array(numSteps).fill(0);
 
-    // Known input speed -> omega2 (prefer input joint speed when available)
-    const rpm = fourBar.inputJoint ? fourBar.inputJoint.inputSpeed : mech.getInputSpeed();
-    const omega2 = 2 * Math.PI * (rpm / 60);
+    return { ang, vel, acc };
+  }
 
-    const normalizeAngle = (theta: number) => {
-      const twoPi = 2 * Math.PI;
-      const t = theta % twoPi;
-      return t < 0 ? t + twoPi : t;
-    };
+  /**
+   * Step 1 in solveGeneralVelocityLoops()
+   * Maps each joint and link in a mechanism to nodes and edges
+   * Identifies grounded and input joints, which joints connect to each other, and which joint pair IDs belong
+   * to each link
+   *
+   * So that solveGeneralVelocityLoops() can know:
+   * what joints exist
+   * what links connect them
+   * which joints are grounded
+   * which link is the input crank
+   * what closed loops can be formed
+   *
+   * returns graph with:
+   * a collection of nodes for the joints
+   * a collection of edges for the links
+   * adjacency information showing which joints are connected
+   * flags or metadata for grounded/input joints
+   */
+  private buildLinkGraph(solveOrder: SolveOrder): LinkGraph {
+
+    // Build nodes (joints)
+    const nodes = new Map<number, LinkGraphNode>();
+    for (const id of solveOrder.order) {
+      const joint = solveOrder.prerequisites.get(id)!.jointToSolve;
+      nodes.set(id, { // Store joint ID, if it's grounded, if it's an input
+        id,
+        isGrounded: joint.isGrounded,
+        isInput:    joint.isInput,
+      });
+    }
 
-    const unwrapAngle = (prevUnwrapped: number, prevRaw: number, raw: number) => {
-      let delta = raw - prevRaw;
-      if (delta > Math.PI) delta -= 2 * Math.PI;
-      else if (delta < -Math.PI) delta += 2 * Math.PI;
-      return prevUnwrapped + delta;
+    // Build edges (links)
+    const edges: LinkGraphEdge[] = [];
+
+    // addEdge creates an edge between two joints (a link) to store the joint information in each link
+    const addEdge = (aId: number, bId: number): void => {
+      const a = nodes.get(aId)!;
+      const b = nodes.get(bId)!;
+      edges.push({ // Store the endpoint joint IDs, if joint A & B are grounded and/or inputs
+        idA: aId, idB: bId,
+        aGrounded: a.isGrounded, bGrounded: b.isGrounded,
+        aIsInput:  a.isInput,    bIsInput:  b.isInput,
+      });
     };
 
-    let prevThetaRaw: number | null = null;
-    let prevThetaUnwrapped: number | null = null;
-    const thetaUnwrapped: number[] = [];
+    // Based on the solve type of each joint (revolute, circle-circle, circle-line),
+    for (const id of solveOrder.order) {
+      const prereq = solveOrder.prerequisites.get(id)!;
+      switch (prereq.solveType) {
+        case SolveType.RevoluteInput:
+          addEdge(prereq.knownJointOne!.id, id);
+          break;
+        case SolveType.CircleCircle:
+          addEdge(prereq.knownJointOne!.id, id);
+          addEdge(prereq.knownJointTwo!.id, id);
+          break;
+        case SolveType.CircleLine:
+          addEdge(prereq.knownJointOne!.id, id);
+          break;
+      }
+    }
 
-    for (let t = 0; t < numSteps; t++) {
-      // Theta for the CURRENT exported link
-      const thisLink = this.findJointPair(link, subJoints, jointIDs, t);
-      if (!thisLink) {
-        ang_pos.push(0); ang_vel.push(0); ang_acc.push(0);
-        continue;
+    // Build adjacency list - for each joint, creates array of neighbor joints. Then maps neighbors to an edge
+    // Used for DFS
+    const adj = new Map<number, Array<{ neighbor: number; edgeIndex: number }>>();
+    for (const id of solveOrder.order) adj.set(id, []);
+    for (let i = 0; i < edges.length; i++) {
+      adj.get(edges[i].idA)!.push({ neighbor: edges[i].idB, edgeIndex: i });
+      adj.get(edges[i].idB)!.push({ neighbor: edges[i].idA, edgeIndex: i });
+    }
+
+    return { nodes, edges, adj };
+  }
+
+  /**
+   * Uses the graph created in buildLinkGraph() and finds the independent closed loops of the mechanism
+   * Velocity solver needs to know:
+   * which loops exist
+   * which links belong to each loop
+   * what direction each link has within the loop.
+   *
+   * Uses DFS to detect loops in the mechanism grpah and return ordered sequence of directed edges for the loop equations
+   * Returns ordered set of loops for the velocity solver
+   */
+  private findVelocityLoops(graph: LinkGraph, solveOrder: SolveOrder): LoopEdge[][] {
+
+    // get the grounded joints from the graph to identify when the loops are closed through the ground
+    const groundIds: number[] = [];
+    for (const id of solveOrder.order) {
+      const t = solveOrder.prerequisites.get(id)!.solveType;
+      if (t === SolveType.Ground || t === SolveType.PrismaticInput) {
+        groundIds.push(id);
       }
+    }
+
+    // need ≥ 2 ground joints for a closing edge
+    if (groundIds.length < 2) return [];
+
+    // create temporary edge between grounded joints to close paths for complete loops for the DFS to detect
+    interface AugEdge { idA: number; idB: number; }
+    const augEdges: AugEdge[] = graph.edges.map(e => ({ idA: e.idA, idB: e.idB }));
+    for (let i = 0; i < groundIds.length - 1; i++) {
+      augEdges.push({ idA: groundIds[i], idB: groundIds[i + 1] });
+    }
 
-      const thisA = subJoints[thisLink.idxA].positions[t];
-      const thisB = subJoints[thisLink.idxB].positions[t];
-      const thisThetaRaw = Math.atan2(thisB.y - thisA.y, thisB.x - thisA.x);
-      const priorRaw: number | null = prevThetaRaw;
-      const priorUnwrapped: number | null = prevThetaUnwrapped;
-      const thisThetaUnwrapped: number = priorRaw === null || priorUnwrapped === null
-        ? thisThetaRaw
-        : unwrapAngle(priorUnwrapped, priorRaw, thisThetaRaw);
-      const dTheta: number = priorUnwrapped === null ? 0 : thisThetaUnwrapped - priorUnwrapped;
-      prevThetaRaw = thisThetaRaw;
-      prevThetaUnwrapped = thisThetaUnwrapped;
-      thetaUnwrapped.push(thisThetaUnwrapped);
-
-      ang_pos.push(normalizeAngle(thisThetaRaw));
-
-      // Thetas for matrix solver
-      const link2 = hasFourBarMap ? fourBar.inputLink! : links[0];
-      const link3 = hasFourBarMap ? fourBar.couplerLink! : links[1];
-      const link4 = hasFourBarMap ? fourBar.outputLink! : links[2];
-
-      const p2 = link2 ? this.findJointPair(link2, subJoints, jointIDs, t) : null;
-      const p3 = link3 ? this.findJointPair(link3, subJoints, jointIDs, t) : null;
-      const p4 = link4 ? this.findJointPair(link4, subJoints, jointIDs, t) : null;
-
-      if (!p2 || !p3 || !p4 || !r2 || !r3 || !r4) {
-        const omegaFallback = (!hasFourBarMap && linkIndex === 0) || (hasFourBarMap && link === fourBar.inputLink) ? omega2 : 0;
-        const omegaOut = Math.abs(dTheta) > 1e-12 ? Math.sign(dTheta) * Math.abs(omegaFallback) : omegaFallback;
-        ang_vel.push(omegaOut);
-        ang_acc.push(0);
-        continue;
+    // build new adjacency list using the aug edges
+    const adj = new Map<number, Array<{ neighbor: number; edgeIdx: number }>>();
+    for (const id of solveOrder.order) adj.set(id, []);
+    for (let i = 0; i < augEdges.length; i++) {
+      adj.get(augEdges[i].idA)!.push({ neighbor: augEdges[i].idB, edgeIdx: i });
+      adj.get(augEdges[i].idB)!.push({ neighbor: augEdges[i].idA, edgeIdx: i });
+    }
+
+    // DFS
+    const visited    = new Map<number, boolean>();
+    const depth      = new Map<number, number>();
+    const parentEdge = new Map<number, number>();
+    const backEdges: Array<{ from: number; to: number; edgeIdx: number }> = [];
+
+    const dfs = (nodeId: number): void => {
+      visited.set(nodeId, true);
+      for (const { neighbor, edgeIdx } of adj.get(nodeId)!) {
+        if (!visited.get(neighbor)) {
+          depth.set(neighbor, depth.get(nodeId)! + 1);
+          parentEdge.set(neighbor, edgeIdx);
+          dfs(neighbor);
+        } else if (
+          edgeIdx !== parentEdge.get(nodeId) &&
+          depth.get(neighbor)! < depth.get(nodeId)!
+        ) {
+          backEdges.push({ from: nodeId, to: neighbor, edgeIdx });
+        }
       }
+    };
 
-      // Current timestep positions for each link
-      const A2 = subJoints[p2.idxA].positions[t];
-      const B2 = subJoints[p2.idxB].positions[t];
-      const theta2 = Math.atan2(B2.y - A2.y, B2.x - A2.x);
-
-      const A3 = subJoints[p3.idxA].positions[t];
-      const B3 = subJoints[p3.idxB].positions[t];
-      const theta3 = Math.atan2(B3.y - A3.y, B3.x - A3.x);
-
-      const A4 = subJoints[p4.idxA].positions[t];
-      const B4 = subJoints[p4.idxB].positions[t];
-      const theta4 = Math.atan2(B4.y - A4.y, B4.x - A4.x);
-
-      // Matrix solution for unknown omegas
-      const { omega3, omega4 } = this.getAngularVelocities(r2, r3, r4, theta2, theta3, theta4, omega2);
-
-      let omegaCandidate = 0;
-      if (hasFourBarMap) {
-        if (link === fourBar.inputLink) omegaCandidate = omega2;
-        else if (link === fourBar.couplerLink) omegaCandidate = omega3;
-        else if (link === fourBar.outputLink) omegaCandidate = omega4;
-        else omegaCandidate = 0;
-      } else {
-        const omegas = [omega2, omega3, omega4];
-        omegaCandidate = omegas[linkIndex] ?? 0;
+    const startId = groundIds[0];
+    depth.set(startId, 0);
+    dfs(startId);
+
+    const loops: LoopEdge[][] = [];
+
+    for (const be of backEdges) {
+      const pathNodes: number[] = [];
+      let cursor = be.from;
+      while (cursor !== be.to) {
+        pathNodes.push(cursor);
+        const pei = parentEdge.get(cursor)!;
+        const e   = augEdges[pei];
+        cursor = (e.idA === cursor) ? e.idB : e.idA;
       }
-      const omegaOut = Math.abs(dTheta) > 1e-12 ? Math.sign(dTheta) * Math.abs(omegaCandidate) : omegaCandidate;
+      pathNodes.push(be.to);
+      pathNodes.reverse();
 
-      ang_vel.push(omegaOut); // Push the selected link velocity
-      ang_acc.push(0); // Placeholder for now
-    }
+      const loop: LoopEdge[] = [];
 
-    if (ang_vel.length > 1 && thetaUnwrapped.length > 1) {
-      const dTheta0 = thetaUnwrapped[1] - thetaUnwrapped[0];
-      if (Math.abs(dTheta0) > 1e-12) {
-        ang_vel[0] = Math.sign(dTheta0) * Math.abs(ang_vel[0]);
+      for (let i = 0; i < pathNodes.length - 1; i++) {
+        const x  = pathNodes[i];
+        const y  = pathNodes[i + 1];
+        const ei = parentEdge.get(y)!;
+        const e  = augEdges[ei];
+        loop.push({ idA: e.idA, idB: e.idB, direction: e.idA === x ? 1 : -1 });
       }
-    }
 
-    return { ang: ang_pos, vel: ang_vel, acc: ang_acc };
-  }
+      const be_e = augEdges[be.edgeIdx];
+      loop.push({ idA: be_e.idA, idB: be_e.idB, direction: be_e.idA === be.from ? 1 : -1 });
 
-  // Calculate unknown angular velocities of a 4 bar linkage // ω2k×r2+ω3k×r3−ω4k×r4=0
-  getAngularVelocities( r2: number, r3: number, r4: number, theta2: number, theta3: number, theta4: number, omega2: number ) {
-    // Build A matrix (2x2) for unknowns
-    const A = math.matrix([ [-r3 * Math.sin(theta3), r4 * Math.sin(theta4)], [ r3 * Math.cos(theta3), -r4 * Math.cos(theta4)], ]);
-    // Build right-hand side B (2x1)
-    const B = math.matrix([ [ r2 * omega2 * Math.sin(theta2) ], [-r2 * omega2 * Math.cos(theta2) ], ]);
+      loops.push(loop);
+    }
 
-    // Solve for unknowns (system of equations)
-    const sol = math.lusolve(A, B) as any;
+    return loops;
+  }
 
-    // get each row (0, 1) in sol matrix
-    const omega3 = sol.get([0, 0]) as number;
-    const omega4 = sol.get([1, 0]) as number;
-    return { omega2, omega3, omega4 };
+  /**
+   * Computes link angular velocuty and acceleration for a submechanism
+   * 1. clears previous angular results (in the caches)
+   * 2. runs loop solver for angular velocity, then acceleration
+   * 3. results are stored in the cache to be reused later so links don't need to be re-calculated
+   */
+  private computeVelocityLoopOmegas(solveOrder: SolveOrder): void {
+    this.linkAngularVelocityCache = new Map();
+    this.linkAngularAccelerationCache = new Map();
+    this.solveGeneralVelocityLoops(solveOrder);
+    this.solveGeneralAccelerationLoops(solveOrder);
   }
 
-  private findJointPair(
-    link: any,
-    subJoints: JointAnalysis[],
-    jointIDs: number[],
-    t: number
-  ): { idxA: number; idxB: number } | null {
+  /**
+   * Main function that solves link angular velocity
+   * Step 1: Convert mechanism into general graph where joints are nodes and links are edges
+   * allows multiple types of linkages to be solved
+   *
+   * Step 2: Find the independent closed loops of the mechanism from the graph to form the velocity equations
+   *
+   * Step 3: Classify each link in the mechanism as ground, input, or unknown. Ground links have zero angular velocity, input
+   * links use the known motor speed, and unknown links become the variables of the solver matrix
+   *
+   * Step 4: Loop through each timestep and build the linear system A x omega = B. Unknown links become the matrix
+   * columns and the input link is moved to the right-hand side
+   *
+   * Step 5: Solve the system using math.lusolve() and store the results in the cache
+   *
+   */
+  private solveGeneralVelocityLoops(solveOrder: SolveOrder): void {
+
+    // ----------------------- Steps 1 + 2: build mechanism graph and find loops -----------------------
+    const graph = this.buildLinkGraph(solveOrder);
+    const loops = this.findVelocityLoops(graph, solveOrder);
+    if (loops.length === 0) return;
+
+    // Input joint and motor speed
+    const inputJointId = solveOrder.order[0];
+    const inputSpeed   = solveOrder.prerequisites.get(inputJointId)!.jointToSolve.inputSpeed;
+    const omega2       = 2 * Math.PI * (inputSpeed / 60);
+
+    let crankEndId: number | null = null;
+    for (const id of solveOrder.order) {
+      if (solveOrder.prerequisites.get(id)!.solveType === SolveType.RevoluteInput) {
+        crankEndId = id;
+        break;
+      }
+    }
+    if (crankEndId === null) return;
 
-    const mech = this.stateService.getMechanism();
-    const allLinks = mech.getArrayOfLinks();
-    const degMap = this.buildJointDegreeMap(allLinks);
+    const numSteps = this.jointKinematics.get(inputJointId)?.positions.length ?? 0;
+    if (numSteps === 0) return;
 
-    const linkJointIds = Array.from(link.joints.keys()).map(j => Number(j));
+    // ----------------------- Step 3: classify links -----------------------
+    // classify each link as grounded, input, or unknown based on the mechanism graph
+    const nodes = graph.nodes;
+    const unknownKeys: string[] = [];
+    const seenKeys    = new Set<string>();
 
-    // Prefer joints that connect to other links (degree > 1)
-    let preferred = linkJointIds.filter(jid => (degMap.get(jid) ?? 0) > 1);
+    for (const loop of loops) {
+      for (const step of loop) {
+        const nA = nodes.get(step.idA)!;
+        const nB = nodes.get(step.idB)!;
 
-    // Fallback if we can't find two connection joints
-    if (preferred.length < 2) preferred = linkJointIds;
+        // skip ground link
+        if (nA.isGrounded && nB.isGrounded) continue;
 
-    // Map joint ids -> indices into subJoints
-    const idxs: number[] = [];
-    for (const jid of preferred) {
-      const idx = jointIDs.indexOf(jid);
-      if (idx >= 0) idxs.push(idx);
-    }
+        // skip input link
+        if ((nA.isGrounded && nA.isInput) || (nB.isGrounded && nB.isInput)) continue;
 
-    // Pick farthest pair among preferred candidates (stable + works well)
-    let bestI = -1, bestJ = -1, bestD2 = -Infinity;
-    for (let a = 0; a < idxs.length; a++) {
-      for (let b = a + 1; b < idxs.length; b++) {
-        const i = idxs[a], j = idxs[b];
-        const p = subJoints[i]?.positions?.[t];
-        const q = subJoints[j]?.positions?.[t];
-        if (!p || !q) continue;
-
-        const dx = q.x - p.x, dy = q.y - p.y;
-        const d2 = dx*dx + dy*dy;
-        if (d2 > bestD2) { bestD2 = d2; bestI = i; bestJ = j; }
+        // unknown links: each unknown becomes a column in the solver matrix
+        const k = this.linkKey(step.idA, step.idB); // make link key for unknown link
+        if (!seenKeys.has(k)) {
+          seenKeys.add(k);
+          unknownKeys.push(k);
+        }
       }
     }
 
-    if (bestI < 0 || bestJ < 0) return null;
-    return { idxA: bestI, idxB: bestJ };
-  }
+    const numLoops    = loops.length;
+    const numUnknowns = unknownKeys.length;
 
-  private identifyFourBarLinks(links: Link[]): {
-    inputLink?: Link;
-    couplerLink?: Link;
-    outputLink?: Link;
-    groundLink?: Link;
-    inputJoint?: Joint;
-  } {
-    const mech = this.stateService.getMechanism();
-    const joints = mech.getArrayOfJoints();
-    const inputJoint = joints.find(j => j.isInput);
-    const groundedJoints = joints.filter(j => j.isGrounded);
-
-    const isGroundLink = (link: Link) => {
-      const js = link.getJoints();
-      return js.length >= 2 && js.every(j => j.isGrounded);
-    };
+    const unknownCol = new Map<string, number>();
+    unknownKeys.forEach((k, i) => unknownCol.set(k, i));
 
-    const groundLink = links.find(isGroundLink);
-
-    let inputLink: Link | undefined;
-    let inputOther: Joint | undefined;
-    if (inputJoint) {
-      for (const l of links) {
-        if (!l.containsJoint(inputJoint.id)) continue;
-        const other = l.getJoints().find(j => j.id !== inputJoint.id);
-        if (other && !other.isGrounded) {
-          inputLink = l;
-          inputOther = other;
-          break;
+    const omegaArrays: number[][] = unknownKeys.map(() => []);
+    let lastSol: number[] = new Array(numUnknowns).fill(0);
+
+    // Store input link first (constant)
+    this.linkAngularVelocityCache.set(
+      this.linkKey(inputJointId, crankEndId),
+      new Array(numSteps).fill(omega2)
+    );
+
+    // ----------------------- Step 4 + 5: build matrix and store results  -----------------------
+    // loop through each timestep
+    for (let t = 0; t < numSteps; t++) {
+
+      // matA: coefficient matrix
+      const matA: number[][] = Array.from(
+        { length: 2 * numLoops },
+        () => new Array(numUnknowns).fill(0)
+      );
+      // right-hand side
+      const vecB: number[] = new Array(2 * numLoops).fill(0);
+
+      // loop through all loops
+      for (let li = 0; li < numLoops; li++) {
+        const rowX = 2 * li; // x equation
+        const rowY = 2 * li + 1; // y equation
+
+        // for each link in the loop
+        for (const step of loops[li]) {
+          const nA   = nodes.get(step.idA)!;
+          const nB   = nodes.get(step.idB)!;
+          const sign = step.direction;
+
+          // skip ground links
+          if (nA.isGrounded && nB.isGrounded) continue;
+
+          // link info at timestep
+          const posA  = this.jointKinematics.get(step.idA)!.positions[t];
+          const posB  = this.jointKinematics.get(step.idB)!.positions[t];
+          const dx    = posB.x - posA.x;
+          const dy    = posB.y - posA.y;
+          const theta = Math.atan2(dy, dx);
+          const r     = Math.hypot(dx, dy);
+
+          // input link known, not places in unknown matrix
+          if ((nA.isGrounded && nA.isInput) || (nB.isGrounded && nB.isInput)) {
+            vecB[rowX] += sign * r * Math.sin(theta) * omega2;
+            vecB[rowY] -= sign * r * Math.cos(theta) * omega2;
+            continue;
+          }
+
+          // populate matrix with unknown link
+          const col = unknownCol.get(this.linkKey(step.idA, step.idB))!;
+          matA[rowX][col] += sign * (-r * Math.sin(theta));
+          matA[rowY][col] += sign * ( r * Math.cos(theta));
         }
       }
-    }
 
-    let outputJoint: Joint | undefined;
-    if (inputJoint) {
-      outputJoint = groundedJoints.find(j => j.id !== inputJoint.id);
+      // Solve A · x = b using lusolve
+      try {
+        const rawSol = math.lusolve(matA, vecB) as number[][];
+        const sol = rawSol.map(row => row[0]);
+        lastSol = sol;
+        sol.forEach((v, i) => omegaArrays[i].push(v));
+      } catch {
+        lastSol.forEach((v, i) => omegaArrays[i].push(v));
+      }
     }
 
-    let outputLink: Link | undefined;
-    let outputOther: Joint | undefined;
-    if (outputJoint) {
-      for (const l of links) {
-        if (!l.containsJoint(outputJoint.id)) continue;
-        const other = l.getJoints().find(j => j.id !== outputJoint?.id);
-        if (other && !other.isGrounded) {
-          outputLink = l;
-          outputOther = other;
-          break;
+    // store results in cache
+    unknownKeys.forEach((k, i) => {
+      this.linkAngularVelocityCache.set(k, omegaArrays[i]);
+    });
+  }
+
+  /**
+   * Main function that solves link angular acceleration
+   * called after solveGeneralVelocityLoops() so that linkAngularVelocityCache is populated
+   *
+   * Step 1: Rebuild the general mechanism graph from the angular velocity solver
+   *
+   * Step 2: Find the independent closed loops of the mechanism from the graph
+   *
+   * Step 3: Classify links as ground, input, or unknown. Ground links have zero angular acceleration, the
+   * input link uses the known input acceleration, and unknown links become the variables of the solver matrix
+   *
+   * Step 4: Loop through each timestep and build the linear system A x omega = B. The coefficient matrix A is the same form as in
+   * the angular velocity solver, but the right-hand side now includes the centripetal terms computed from the angular velocities
+   * solved previously
+   *
+   * Step 5: Solve the system using math.lusolve() and store the results in the cache
+   */
+  private solveGeneralAccelerationLoops(solveOrder: SolveOrder): void {
+
+    const graph = this.buildLinkGraph(solveOrder);
+    const loops = this.findVelocityLoops(graph, solveOrder);
+    if (loops.length === 0) return;
+
+    const inputJointId = solveOrder.order[0];
+    const inputSpeed = solveOrder.prerequisites.get(inputJointId)!.jointToSolve.inputSpeed;
+    const omega2 = 2 * Math.PI * (inputSpeed / 60);
+    const alpha2 = 0; // input acceleration is 0 (constant)
+
+    let crankEndId: number | null = null;
+    for (const id of solveOrder.order) {
+      if (solveOrder.prerequisites.get(id)!.solveType === SolveType.RevoluteInput) {
+        crankEndId = id;
+        break;
+      }
+    }
+    if (crankEndId === null) return;
+
+    const numSteps = this.jointKinematics.get(inputJointId)?.positions.length ?? 0;
+    if (numSteps === 0) return;
+
+    const nodes = graph.nodes;
+    const unknownKeys: string[] = [];
+    const seenKeys = new Set<string>();
+
+    for (const loop of loops) {
+      for (const step of loop) {
+        const nA = nodes.get(step.idA)!;
+        const nB = nodes.get(step.idB)!;
+        if (nA.isGrounded && nB.isGrounded) continue;
+        if ((nA.isGrounded && nA.isInput) || (nB.isGrounded && nB.isInput)) continue;
+        const k = this.linkKey(step.idA, step.idB);
+        if (!seenKeys.has(k)) {
+          seenKeys.add(k);
+          unknownKeys.push(k);
         }
       }
     }
 
-    let couplerLink: Link | undefined;
-    if (inputOther && outputOther) {
-      const inputOtherId = inputOther.id;
-      const outputOtherId = outputOther.id;
-      couplerLink = links.find(l => l.containsJoint(inputOtherId) && l.containsJoint(outputOtherId));
-    }
-    if (!couplerLink) {
-      couplerLink = links.find(l =>
-        l !== inputLink &&
-        l !== outputLink &&
-        l !== groundLink &&
-        l.getJoints().every(j => !j.isGrounded)
+    const numLoops = loops.length;
+    const numUnknowns = unknownKeys.length;
+
+    const unknownCol = new Map<string, number>();
+    unknownKeys.forEach((k, i) => unknownCol.set(k, i));
+
+    const alphaArrays: number[][] = unknownKeys.map(() => []);
+    let lastSol: number[] = new Array(numUnknowns).fill(0);
+
+    this.linkAngularAccelerationCache.set(
+      this.linkKey(inputJointId, crankEndId),
+      new Array(numSteps).fill(alpha2)
+    );
+
+    for (let t = 0; t < numSteps; t++) {
+
+      const matA: number[][] = Array.from(
+        { length: 2 * numLoops },
+        () => new Array(numUnknowns).fill(0)
       );
-    }
+      const vecB: number[] = new Array(2 * numLoops).fill(0);
 
-    return { inputLink, couplerLink, outputLink, groundLink, inputJoint };
-  }
+      for (let li = 0; li < numLoops; li++) {
+        const rowX = 2 * li;
+        const rowY = 2 * li + 1;
+
+        for (const step of loops[li]) {
+          const nA = nodes.get(step.idA)!;
+          const nB = nodes.get(step.idB)!;
+          const sign = step.direction;
+
+          if (nA.isGrounded && nB.isGrounded) continue;
 
+          const posA = this.jointKinematics.get(step.idA)!.positions[t];
+          const posB = this.jointKinematics.get(step.idB)!.positions[t];
+          const dx = posB.x - posA.x;
+          const dy = posB.y - posA.y;
+          const theta = Math.atan2(dy, dx);
+          const r = Math.hypot(dx, dy);
 
-  private buildJointDegreeMap(links: any[]): Map<number, number> {
-    const deg = new Map<number, number>();
-    for (const link of links) {
-      for (const jid of link.joints.keys()) {
-        deg.set(Number(jid), (deg.get(Number(jid)) ?? 0) + 1);
+          const sinT = Math.sin(theta);
+          const cosT = Math.cos(theta);
+
+          const isCrank = (nA.isGrounded && nA.isInput) || (nB.isGrounded && nB.isInput);
+
+          // input crank moved into RHS
+          if (isCrank) {
+            vecB[rowX] += sign * r * omega2 * omega2 * cosT;
+            vecB[rowY] += sign * r * omega2 * omega2 * sinT;
+
+            if (alpha2 !== 0) {
+              vecB[rowX] += sign * r * alpha2 * sinT;
+              vecB[rowY] -= sign * r * alpha2 * cosT;
+            }
+            continue;
+          }
+
+          const omegaI = this.linkAngularVelocityCache.get(
+            this.linkKey(step.idA, step.idB)
+          )?.[t] ?? 0;
+
+          vecB[rowX] += sign * r * omegaI * omegaI * cosT;
+          vecB[rowY] += sign * r * omegaI * omegaI * sinT;
+
+          const col = unknownCol.get(this.linkKey(step.idA, step.idB))!;
+          matA[rowX][col] += sign * (-r * sinT);
+          matA[rowY][col] += sign * ( r * cosT);
+        }
+      }
+
+      try {
+        let sol: number[];
+        if (matA.length === numUnknowns) {
+          const rawSol = math.lusolve(matA, vecB) as number[][];
+          sol = rawSol.map(row => row[0]);
+        } else {
+          const matAT = math.transpose(matA) as number[][];
+          const matAT_A = math.multiply(matAT, matA) as number[][];
+          const vecAT_b = math.multiply(matAT, vecB) as number[];
+          const rawSol = math.lusolve(matAT_A, vecAT_b) as number[][];
+          sol = rawSol.map(row => row[0]);
+        }
+        lastSol = sol;
+        sol.forEach((v, i) => alphaArrays[i].push(v));
+      } catch {
+        lastSol.forEach((v, i) => alphaArrays[i].push(v));
       }
     }
-    return deg;
-  }
 
+    unknownKeys.forEach((k, i) => {
+      this.linkAngularAccelerationCache.set(k, alphaArrays[i]);
+    });
+  }
 
+  /**
+   * creates unique key for each physical link independent of joint order
+   * i.e. (2,5) is the same as (5,2)
+   */
+  private linkKey(a: number, b: number): string {
+    return a < b ? `${a}_${b}` : `${b}_${a}`;
+  }
 }
 

From 484eb4c7cdd568e8fa8df542f2745b5bc1145b09 Mon Sep 17 00:00:00 2001
From: mwalsh001 <matty71604@gmail.com>
Date: Mon, 23 Mar 2026 11:28:00 -0400
Subject: [PATCH 15/23] Link angular velocity and acceleration calculations and
 integration with side panel. Slider-crank TBD.

---
 src/app/services/analysis-solver.service.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/app/services/analysis-solver.service.ts b/src/app/services/analysis-solver.service.ts
index 24dc0cb9..93bc9642 100644
--- a/src/app/services/analysis-solver.service.ts
+++ b/src/app/services/analysis-solver.service.ts
@@ -199,6 +199,7 @@ export class AnalysisSolveService {
           accelerations.push(velocity_acceleration.acceleration);
           break;
         }
+
         case SolveType.CircleLine: {
           const knownIndex1 = solveOrder.order.indexOf(prereq.knownJointOne!.id);
           velocity_acceleration = this.solveCircleLineJointKinematics(index, knownIndex1, prereq, positions, velocities, accelerations)

From e871275d4b4c0d43273c102ecca260978f8d3508 Mon Sep 17 00:00:00 2001
From: mwalsh001 <matty71604@gmail.com>
Date: Fri, 27 Mar 2026 15:21:10 -0400
Subject: [PATCH 16/23] Initial slider-crank implementation.

---
 src/app/services/analysis-solver.service.ts | 214 +++++++++++++++-----
 1 file changed, 158 insertions(+), 56 deletions(-)

diff --git a/src/app/services/analysis-solver.service.ts b/src/app/services/analysis-solver.service.ts
index 93bc9642..d207dac3 100644
--- a/src/app/services/analysis-solver.service.ts
+++ b/src/app/services/analysis-solver.service.ts
@@ -94,6 +94,12 @@ export interface LoopEdge {
   direction: 1 | -1;
 }
 
+interface AugmentedLoopEdge {
+  idA: number;
+  idB: number;
+  isVirtualSlider: boolean;
+}
+
 
 @Injectable({
   providedIn: 'root'
@@ -420,8 +426,9 @@ export class AnalysisSolveService {
    * Calculates angular position, velocity, and acceleration for a link.
    *
    * Angle:    theta = atan2(yB - yA, xB - xA) using the first two joints at each timestep.
-   * Velocity: omega from the pre-computed velocity-loop cache (see computeVelocityLoopOmegas).
-   * Acceleration: prefers loop-solved alpha, otherwise 0.
+   * Velocity: omega from rigid-body relative velocity, ω = (r × v_rel) / |r|^2.
+   * Acceleration: alpha from rigid-body relative acceleration,
+   *               α = (r × a_rel) / |r|^2.
    *
    * @param subJoints - JointAnalysis objects for the joints on this link (at least 2).
    * @param jointIDs  - Corresponding joint IDs, used to look up the velocity-loop cache.
@@ -449,23 +456,28 @@ export class AnalysisSolveService {
       ));
     }
 
-    if (!jointIDs || jointIDs.length < 2) {
-      return {
-        ang,
-        vel: new Array(numSteps).fill(0),
-        acc: new Array(numSteps).fill(0),
-      };
-    }
+    const vel: number[] = [];
+    const acc: number[] = [];
 
-    const key = this.linkKey(jointIDs[0], jointIDs[1]);
+    for (let t = 0; t < numSteps; t++) {
+      const rx = j1.positions[t].x - j0.positions[t].x;
+      const ry = j1.positions[t].y - j0.positions[t].y;
+      const rSquared = rx * rx + ry * ry;
+
+      if (rSquared < 1e-12) {
+        vel.push(0);
+        acc.push(0);
+        continue;
+      }
 
-    const cachedOmega = this.linkAngularVelocityCache.get(key);
-    const vel: number[] = cachedOmega ?? new Array(numSteps).fill(0);
+      const vx = j1.velocities[t].x - j0.velocities[t].x;
+      const vy = j1.velocities[t].y - j0.velocities[t].y;
+      vel.push((rx * vy - ry * vx) / rSquared);
 
-    const cachedAlpha = this.linkAngularAccelerationCache.get(key);
-    const acc: number[] = (cachedAlpha && cachedAlpha.length === numSteps)
-      ? cachedAlpha
-      : new Array(numSteps).fill(0);
+      const ax = j1.accelerations[t].x - j0.accelerations[t].x;
+      const ay = j1.accelerations[t].y - j0.accelerations[t].y;
+      acc.push((rx * ay - ry * ax) / rSquared);
+    }
 
     return { ang, vel, acc };
   }
@@ -566,14 +578,29 @@ export class AnalysisSolveService {
       }
     }
 
-    // need ≥ 2 ground joints for a closing edge
-    if (groundIds.length < 2) return [];
-
     // create temporary edge between grounded joints to close paths for complete loops for the DFS to detect
-    interface AugEdge { idA: number; idB: number; }
-    const augEdges: AugEdge[] = graph.edges.map(e => ({ idA: e.idA, idB: e.idB }));
+    const augEdges: AugmentedLoopEdge[] = graph.edges.map(e => ({
+      idA: e.idA,
+      idB: e.idB,
+      isVirtualSlider: false,
+    }));
     for (let i = 0; i < groundIds.length - 1; i++) {
-      augEdges.push({ idA: groundIds[i], idB: groundIds[i + 1] });
+      augEdges.push({ idA: groundIds[i], idB: groundIds[i + 1], isVirtualSlider: false });
+    }
+
+    const groundReferenceId = groundIds[0];
+    if (groundReferenceId !== undefined) {
+      for (const id of solveOrder.order) {
+        const prereq = solveOrder.prerequisites.get(id)!;
+        if (prereq.solveType === SolveType.CircleLine) {
+          const hasExistingEdge = augEdges.some(edge =>
+            this.linkKey(edge.idA, edge.idB) === this.linkKey(groundReferenceId, id)
+          );
+          if (!hasExistingEdge) {
+            augEdges.push({ idA: groundReferenceId, idB: id, isVirtualSlider: true });
+          }
+        }
+      }
     }
 
     // build new adjacency list using the aug edges
@@ -674,16 +701,17 @@ export class AnalysisSolveService {
    */
   private solveGeneralVelocityLoops(solveOrder: SolveOrder): void {
 
-    // ----------------------- Steps 1 + 2: build mechanism graph and find loops -----------------------
+    // ── Steps 1 + 2: build mechanism graph and find independent loops ──────────
     const graph = this.buildLinkGraph(solveOrder);
     const loops = this.findVelocityLoops(graph, solveOrder);
     if (loops.length === 0) return;
 
-    // Input joint and motor speed
+    // Input joint / motor speed
     const inputJointId = solveOrder.order[0];
     const inputSpeed   = solveOrder.prerequisites.get(inputJointId)!.jointToSolve.inputSpeed;
     const omega2       = 2 * Math.PI * (inputSpeed / 60);
 
+    // Find the far end of the input crank (RevoluteInput joint)
     let crankEndId: number | null = null;
     for (const id of solveOrder.order) {
       if (solveOrder.prerequisites.get(id)!.solveType === SolveType.RevoluteInput) {
@@ -696,10 +724,15 @@ export class AnalysisSolveService {
     const numSteps = this.jointKinematics.get(inputJointId)?.positions.length ?? 0;
     if (numSteps === 0) return;
 
-    // ----------------------- Step 3: classify links -----------------------
-    // classify each link as grounded, input, or unknown based on the mechanism graph
-    const nodes = graph.nodes;
-    const unknownKeys: string[] = [];
+    // ── Step 3: classify every link encountered in all loops ──────────────────
+    //
+    //  ground   → zero ω, skip entirely
+    //  input    → known ω = omega2, move to RHS
+    //  revolute → unknown ω, add column  key = "A_B"
+    //  prismatic→ unknown ṡ, add column  key = "slider_A_B"
+    //
+    const nodes       = graph.nodes;
+    const unknownKeys : string[] = [];
     const seenKeys    = new Set<string>();
 
     for (const loop of loops) {
@@ -707,14 +740,19 @@ export class AnalysisSolveService {
         const nA = nodes.get(step.idA)!;
         const nB = nodes.get(step.idB)!;
 
-        // skip ground link
+        // ground–ground edge (closing ground link) → no DOF
         if (nA.isGrounded && nB.isGrounded) continue;
 
-        // skip input link
+        // input crank → known, will go to RHS
         if ((nA.isGrounded && nA.isInput) || (nB.isGrounded && nB.isInput)) continue;
 
-        // unknown links: each unknown becomes a column in the solver matrix
-        const k = this.linkKey(step.idA, step.idB); // make link key for unknown link
+        // determine whether the far (non-grounded) joint is prismatic
+        const isPrismatic = this.isPrismaticClosureStep(graph, solveOrder, step);
+
+        const k = isPrismatic
+          ? this.sliderKey(step.idA, step.idB)
+          : this.linkKey(step.idA, step.idB);
+
         if (!seenKeys.has(k)) {
           seenKeys.add(k);
           unknownKeys.push(k);
@@ -728,42 +766,37 @@ export class AnalysisSolveService {
     const unknownCol = new Map<string, number>();
     unknownKeys.forEach((k, i) => unknownCol.set(k, i));
 
-    const omegaArrays: number[][] = unknownKeys.map(() => []);
+    const resultArrays: number[][] = unknownKeys.map(() => []);
     let lastSol: number[] = new Array(numUnknowns).fill(0);
 
-    // Store input link first (constant)
+    // Store constant input-crank angular velocity
     this.linkAngularVelocityCache.set(
       this.linkKey(inputJointId, crankEndId),
       new Array(numSteps).fill(omega2)
     );
 
-    // ----------------------- Step 4 + 5: build matrix and store results  -----------------------
-    // loop through each timestep
+    // ── Steps 4 + 5: build A·x = b at every timestep and solve ───────────────
     for (let t = 0; t < numSteps; t++) {
 
-      // matA: coefficient matrix
       const matA: number[][] = Array.from(
         { length: 2 * numLoops },
         () => new Array(numUnknowns).fill(0)
       );
-      // right-hand side
       const vecB: number[] = new Array(2 * numLoops).fill(0);
 
-      // loop through all loops
       for (let li = 0; li < numLoops; li++) {
-        const rowX = 2 * li; // x equation
-        const rowY = 2 * li + 1; // y equation
+        const rowX = 2 * li;
+        const rowY = 2 * li + 1;
 
-        // for each link in the loop
         for (const step of loops[li]) {
           const nA   = nodes.get(step.idA)!;
           const nB   = nodes.get(step.idB)!;
           const sign = step.direction;
 
-          // skip ground links
+          // ground–ground closing edge
           if (nA.isGrounded && nB.isGrounded) continue;
 
-          // link info at timestep
+          // Joint positions and link geometry at this timestep
           const posA  = this.jointKinematics.get(step.idA)!.positions[t];
           const posB  = this.jointKinematics.get(step.idB)!.positions[t];
           const dx    = posB.x - posA.x;
@@ -771,34 +804,55 @@ export class AnalysisSolveService {
           const theta = Math.atan2(dy, dx);
           const r     = Math.hypot(dx, dy);
 
-          // input link known, not places in unknown matrix
+          // input crank (known ω = omega2) → RHS
           if ((nA.isGrounded && nA.isInput) || (nB.isGrounded && nB.isInput)) {
             vecB[rowX] += sign * r * Math.sin(theta) * omega2;
             vecB[rowY] -= sign * r * Math.cos(theta) * omega2;
             continue;
           }
 
-          // populate matrix with unknown link
-          const col = unknownCol.get(this.linkKey(step.idA, step.idB))!;
-          matA[rowX][col] += sign * (-r * Math.sin(theta));
-          matA[rowY][col] += sign * ( r * Math.cos(theta));
+          // determine if this link is prismatic
+          const isPrismatic = this.isPrismaticClosureStep(graph, solveOrder, step);
+
+          if (isPrismatic) {
+            // Prismatic contribution
+            // θ_slide is the guide angle stored on the slider joint
+            const slideJointId = this.getPrismaticClosureJointId(solveOrder, step);
+            const slideAngle = solveOrder.prerequisites.get(slideJointId)!.jointToSolve.angle;
+            const col = unknownCol.get(this.sliderKey(step.idA, step.idB))!;
+            matA[rowX][col] += sign * Math.cos(slideAngle);
+            matA[rowY][col] += sign * Math.sin(slideAngle);
+
+          } else {
+            const col = unknownCol.get(this.linkKey(step.idA, step.idB))!;
+            matA[rowX][col] += sign * (-r * Math.sin(theta));
+            matA[rowY][col] += sign * ( r * Math.cos(theta));
+          }
         }
       }
 
-      // Solve A · x = b using lusolve
+      // Solve A · x = b
       try {
         const rawSol = math.lusolve(matA, vecB) as number[][];
-        const sol = rawSol.map(row => row[0]);
+        const sol    = rawSol.map(row => row[0]);
         lastSol = sol;
-        sol.forEach((v, i) => omegaArrays[i].push(v));
+        sol.forEach((v, i) => resultArrays[i].push(v));
       } catch {
-        lastSol.forEach((v, i) => omegaArrays[i].push(v));
+        lastSol.forEach((v, i) => resultArrays[i].push(v));
       }
     }
 
-    // store results in cache
+    // Angular velocities go into linkAngularVelocityCache under the revolute key.
+    // Slider velocities are stored under the sliderKey — callers can retrieve
+    // them via getSliderVelocity(idA, idB) if needed, but they don't affect the
+    // link angular-velocity display which only reads the revolute key.
     unknownKeys.forEach((k, i) => {
-      this.linkAngularVelocityCache.set(k, omegaArrays[i]);
+      if (k.startsWith('slider_')) {
+        // Store slider velocity separately (available for future use / CSV export)
+        this.linkAngularVelocityCache.set(k, resultArrays[i]);
+      } else {
+        this.linkAngularVelocityCache.set(k, resultArrays[i]);
+      }
     });
   }
 
@@ -852,7 +906,9 @@ export class AnalysisSolveService {
         const nB = nodes.get(step.idB)!;
         if (nA.isGrounded && nB.isGrounded) continue;
         if ((nA.isGrounded && nA.isInput) || (nB.isGrounded && nB.isInput)) continue;
-        const k = this.linkKey(step.idA, step.idB);
+        const k = this.isPrismaticClosureStep(graph, solveOrder, step)
+          ? this.sliderKey(step.idA, step.idB)
+          : this.linkKey(step.idA, step.idB);
         if (!seenKeys.has(k)) {
           seenKeys.add(k);
           unknownKeys.push(k);
@@ -917,6 +973,16 @@ export class AnalysisSolveService {
             continue;
           }
 
+          const isPrismatic = this.isPrismaticClosureStep(graph, solveOrder, step);
+          if (isPrismatic) {
+            const slideJointId = this.getPrismaticClosureJointId(solveOrder, step);
+            const slideAngle = solveOrder.prerequisites.get(slideJointId)!.jointToSolve.angle;
+            const col = unknownCol.get(this.sliderKey(step.idA, step.idB))!;
+            matA[rowX][col] += sign * Math.cos(slideAngle);
+            matA[rowY][col] += sign * Math.sin(slideAngle);
+            continue;
+          }
+
           const omegaI = this.linkAngularVelocityCache.get(
             this.linkKey(step.idA, step.idB)
           )?.[t] ?? 0;
@@ -961,5 +1027,41 @@ export class AnalysisSolveService {
   private linkKey(a: number, b: number): string {
     return a < b ? `${a}_${b}` : `${b}_${a}`;
   }
+
+  /**
+   * creates unique key for each slider link independent of joint order
+   * i.e. (2,5) is the same as (5,2)
+   */
+  private sliderKey(a: number, b: number): string {
+    return `slider_${this.linkKey(a, b)}`;
+  }
+
+  private hasPhysicalLink(graph: LinkGraph, a: number, b: number): boolean {
+    const key = this.linkKey(a, b);
+    return graph.edges.some(edge => this.linkKey(edge.idA, edge.idB) === key);
+  }
+
+  private isPrismaticClosureStep(graph: LinkGraph, solveOrder: SolveOrder, step: LoopEdge): boolean {
+    if (this.hasPhysicalLink(graph, step.idA, step.idB)) {
+      return false;
+    }
+
+    const jointAType = solveOrder.prerequisites.get(step.idA)?.solveType;
+    const jointBType = solveOrder.prerequisites.get(step.idB)?.solveType;
+
+    return jointAType === SolveType.CircleLine ||
+      jointAType === SolveType.PrismaticInput ||
+      jointBType === SolveType.CircleLine ||
+      jointBType === SolveType.PrismaticInput;
+  }
+
+  private getPrismaticClosureJointId(solveOrder: SolveOrder, step: LoopEdge): number {
+    const jointAType = solveOrder.prerequisites.get(step.idA)?.solveType;
+    if (jointAType === SolveType.CircleLine || jointAType === SolveType.PrismaticInput) {
+      return step.idA;
+    }
+
+    return step.idB;
+  }
 }
 

From e14fa91658e4aa76bf842741078082bc001e4d87 Mon Sep 17 00:00:00 2001
From: mwalsh001 <matty71604@gmail.com>
Date: Wed, 1 Apr 2026 20:29:17 -0400
Subject: [PATCH 17/23] Slider-crank angular velocity and acceleration.

---
 src/app/services/analysis-solver.service.ts | 249 ++++++++++++++------
 1 file changed, 172 insertions(+), 77 deletions(-)

diff --git a/src/app/services/analysis-solver.service.ts b/src/app/services/analysis-solver.service.ts
index d207dac3..3dd38713 100644
--- a/src/app/services/analysis-solver.service.ts
+++ b/src/app/services/analysis-solver.service.ts
@@ -34,10 +34,6 @@ export interface LinkGraphNode {
 
 /**
  * One link (undirected edge) connecting joints idA and idB.
- * The canonical traversal direction is idA → idB.
- * aGrounded / bGrounded / aIsInput / bIsInput mirror the corresponding
- * node flags and are stored here so the loop solver never has to look
- * them up again.
  */
 export interface LinkGraphEdge {
   idA:       number;
@@ -50,11 +46,6 @@ export interface LinkGraphEdge {
 
 /**
  * Undirected adjacency graph for one submechanism.
- *
- * NOTE: this graph contains only the links that are explicit in the
- * SolveOrder prerequisites (crank, couplers, followers).
- * Ground-to-ground closing edges and prismatic-closing edges are
- * NOT added here — that is Step 2 (spanning tree + loop detection).
  */
 export interface LinkGraph {
   /** Joint-id → node metadata. */
@@ -70,33 +61,18 @@ export interface LinkGraph {
   adj: Map<number, Array<{ neighbor: number; edgeIndex: number }>>;
 }
 
-/**
- * One directed step within a velocity loop.
- *
- * idA / idB are the canonical endpoints of the underlying physical link
- * exactly as stored in the augmented edge list (graph edges + ground-chain
- * closing edges).  The direction flag records which way the loop walks
- * across that link:
- *
- *   direction = +1  →  step traverses the link idA → idB (canonical)
- *   direction = −1  →  step traverses the link idB → idA (reversed)
- *
- * Sign convention for matrix assembly (Step 4):
- *   revolute link:  X += direction * (−r sinθ) * ω
- *                   Y += direction * ( r cosθ) * ω
- *   prismatic link: X += direction * cosθ_slide * ṡ
- *                   Y += direction * sinθ_slide * ṡ
- * where θ is always atan2(idB.pos − idA.pos) regardless of direction.
- */
 export interface LoopEdge {
   idA:       number;
   idB:       number;
   direction: 1 | -1;
+  // True when the loop step comes from a synthesized slider closure rather than a physical link.
+  isVirtualSlider: boolean;
 }
 
 interface AugmentedLoopEdge {
   idA: number;
   idB: number;
+  // Marks slider edges added only so the loop finder can close a prismatic chain
   isVirtualSlider: boolean;
 }
 
@@ -110,20 +86,23 @@ export class AnalysisSolveService {
   private jointPositions: AnimationPositions[] = [];
   private jointKinematics: Map<number, JointAnalysis> = new Map();
 
-  // Cache of link angular velocities keyed by sorted joint-ID pair, e.g. "2_5".
-  // Populated by computeVelocityLoopOmegas() after each submechanism is solved.
+  // Cache of link angular velocities keyed by sorted joint-ID pair, "2_5"
+  // Populated by computeVelocityLoopOmegas() after each submechanism is solved
   private linkAngularVelocityCache: Map<string, number[]> = new Map();
   // Cache of link angular accelerations keyed by sorted joint-ID pair.
   private linkAngularAccelerationCache: Map<string, number[]> = new Map();
 
-  // Most-recently solved SolveOrder, retained so exportLinkKinematicsCSV() can be
-  // called on demand without needing a parameter.
   private lastSolveOrder: SolveOrder | null = null;
 
   constructor(private positionSolver: PositionSolverService, private stateService: StateService) {
 
   }
 
+  // Converts stored joint angles from degrees to radians before operations
+  private angleDegToRad(angleDeg: number): number {
+    return angleDeg * Math.PI / 180;
+  }
+
   // Updates kinematic data by fetching solve orders and joint positions, then solving submechanism kinematics.
   updateKinematics() {
     /**Order of operations
@@ -250,7 +229,8 @@ export class AnalysisSolveService {
   // Calculates velocity and acceleration for a prismatic input joint from its prerequisites.
   solvePrisInputJointKinematics(prereq: SolvePrerequisite): { velocity: Coord, acceleration: Coord } {
     const velocityMag = prereq.jointToSolve.inputSpeed * (0.05 * 6) //Kinematic solver generates frames for 0.05m increments, and animator uses Rev-Input timeInterval calculation
-    const velocityTheta = prereq.jointToSolve.angle;
+    // Slider angles are stored in degrees in the joint model.
+    const velocityTheta = this.angleDegToRad(prereq.jointToSolve.angle);
     const deltaX: number = Math.cos(velocityTheta) * velocityMag;
     const deltaY: number = Math.sin(velocityTheta) * velocityMag;
     const jointVelocity: Coord = new Coord(deltaX, deltaY);
@@ -286,12 +266,14 @@ export class AnalysisSolveService {
     const v_k1: Coord = velocities[known1Index];
     const diff_jk1: Coord = new Coord(positions[jointIndex].x - positions[known1Index].x, positions[jointIndex].y - positions[known1Index].y);
     const perp_angle_jk1: number = Math.atan2(diff_jk1.y, diff_jk1.x) + Math.PI / 2;
-    const jointVelocity: Coord = this.parametricLineIntersection(v_k1, perp_angle_jk1, new Coord(0, 0), prereq.jointToSolve.angle);
+    // The line constraint follows the slider guide angle stored on the joint in degrees.
+    const slideAngle = this.angleDegToRad(prereq.jointToSolve.angle);
+    const jointVelocity: Coord = this.parametricLineIntersection(v_k1, perp_angle_jk1, new Coord(0, 0), slideAngle);
     //acceleration
     const x_centripetal_accel_jk1: number = accelerations[known1Index].x + Math.pow(jointVelocity.x, 2) / (-diff_jk1.x);
     const y_centripetal_accel_jk1: number = accelerations[known1Index].y + Math.pow(jointVelocity.y, 2) / (-diff_jk1.y);
     const centripetal_accel_jk1: Coord = new Coord(x_centripetal_accel_jk1, y_centripetal_accel_jk1);
-    const jointAcceleration: Coord = this.parametricLineIntersection(centripetal_accel_jk1, perp_angle_jk1, new Coord(0, 0), prereq.jointToSolve.angle);
+    const jointAcceleration: Coord = this.parametricLineIntersection(centripetal_accel_jk1, perp_angle_jk1, new Coord(0, 0), slideAngle);
     return { velocity: jointVelocity, acceleration: jointAcceleration };
   }
   // Finds the intersection point of two parametric lines defined by starting coordinates and angles.
@@ -459,6 +441,14 @@ export class AnalysisSolveService {
     const vel: number[] = [];
     const acc: number[] = [];
 
+    if (jointIDs && jointIDs.length >= 2) {
+      // Crank-slider links may already have a solved angular series in the loop caches.
+      const cachedSeries = this.getCachedLinkSeries(jointIDs);
+      if (cachedSeries) {
+        return { ang, vel: cachedSeries.vel, acc: cachedSeries.acc };
+      }
+    }
+
     for (let t = 0; t < numSteps; t++) {
       const rx = j1.positions[t].x - j0.positions[t].x;
       const ry = j1.positions[t].y - j0.positions[t].y;
@@ -658,11 +648,21 @@ export class AnalysisSolveService {
         const y  = pathNodes[i + 1];
         const ei = parentEdge.get(y)!;
         const e  = augEdges[ei];
-        loop.push({ idA: e.idA, idB: e.idB, direction: e.idA === x ? 1 : -1 });
+        loop.push({
+          idA: e.idA,
+          idB: e.idB,
+          direction: e.idA === x ? 1 : -1,
+          isVirtualSlider: e.isVirtualSlider,
+        });
       }
 
       const be_e = augEdges[be.edgeIdx];
-      loop.push({ idA: be_e.idA, idB: be_e.idB, direction: be_e.idA === be.from ? 1 : -1 });
+      loop.push({
+        idA: be_e.idA,
+        idB: be_e.idB,
+        direction: be_e.idA === be.from ? 1 : -1,
+        isVirtualSlider: be_e.isVirtualSlider,
+      });
 
       loops.push(loop);
     }
@@ -726,10 +726,10 @@ export class AnalysisSolveService {
 
     // ── Step 3: classify every link encountered in all loops ──────────────────
     //
-    //  ground   → zero ω, skip entirely
-    //  input    → known ω = omega2, move to RHS
-    //  revolute → unknown ω, add column  key = "A_B"
-    //  prismatic→ unknown ṡ, add column  key = "slider_A_B"
+    //  ground   → zero, skip entirely
+    //  input    → known = omega2, move to RHS
+    //  revolute → unknown, add column  key = "A_B"
+    //  prismatic→ unknown, add column  key = "slider_A_B"
     //
     const nodes       = graph.nodes;
     const unknownKeys : string[] = [];
@@ -739,16 +739,15 @@ export class AnalysisSolveService {
       for (const step of loop) {
         const nA = nodes.get(step.idA)!;
         const nB = nodes.get(step.idB)!;
+        const isPrismatic = this.isPrismaticClosureStep(graph, solveOrder, step);
 
         // ground–ground edge (closing ground link) → no DOF
-        if (nA.isGrounded && nB.isGrounded) continue;
+        if (nA.isGrounded && nB.isGrounded && !isPrismatic) continue;
 
         // input crank → known, will go to RHS
-        if ((nA.isGrounded && nA.isInput) || (nB.isGrounded && nB.isInput)) continue;
+        if (!isPrismatic && ((nA.isGrounded && nA.isInput) || (nB.isGrounded && nB.isInput))) continue;
 
         // determine whether the far (non-grounded) joint is prismatic
-        const isPrismatic = this.isPrismaticClosureStep(graph, solveOrder, step);
-
         const k = isPrismatic
           ? this.sliderKey(step.idA, step.idB)
           : this.linkKey(step.idA, step.idB);
@@ -792,9 +791,10 @@ export class AnalysisSolveService {
           const nA   = nodes.get(step.idA)!;
           const nB   = nodes.get(step.idB)!;
           const sign = step.direction;
+          const isPrismatic = this.isPrismaticClosureStep(graph, solveOrder, step);
 
           // ground–ground closing edge
-          if (nA.isGrounded && nB.isGrounded) continue;
+          if (nA.isGrounded && nB.isGrounded && !isPrismatic) continue;
 
           // Joint positions and link geometry at this timestep
           const posA  = this.jointKinematics.get(step.idA)!.positions[t];
@@ -805,20 +805,20 @@ export class AnalysisSolveService {
           const r     = Math.hypot(dx, dy);
 
           // input crank (known ω = omega2) → RHS
-          if ((nA.isGrounded && nA.isInput) || (nB.isGrounded && nB.isInput)) {
+          if (!isPrismatic && ((nA.isGrounded && nA.isInput) || (nB.isGrounded && nB.isInput))) {
             vecB[rowX] += sign * r * Math.sin(theta) * omega2;
             vecB[rowY] -= sign * r * Math.cos(theta) * omega2;
             continue;
           }
 
           // determine if this link is prismatic
-          const isPrismatic = this.isPrismaticClosureStep(graph, solveOrder, step);
-
           if (isPrismatic) {
             // Prismatic contribution
             // θ_slide is the guide angle stored on the slider joint
             const slideJointId = this.getPrismaticClosureJointId(solveOrder, step);
-            const slideAngle = solveOrder.prerequisites.get(slideJointId)!.jointToSolve.angle;
+            const slideAngle = this.angleDegToRad(
+              solveOrder.prerequisites.get(slideJointId)!.jointToSolve.angle
+            );
             const col = unknownCol.get(this.sliderKey(step.idA, step.idB))!;
             matA[rowX][col] += sign * Math.cos(slideAngle);
             matA[rowY][col] += sign * Math.sin(slideAngle);
@@ -874,15 +874,30 @@ export class AnalysisSolveService {
    * Step 5: Solve the system using math.lusolve() and store the results in the cache
    */
   private solveGeneralAccelerationLoops(solveOrder: SolveOrder): void {
-
     const graph = this.buildLinkGraph(solveOrder);
     const loops = this.findVelocityLoops(graph, solveOrder);
     if (loops.length === 0) return;
 
     const inputJointId = solveOrder.order[0];
+    const numSteps = this.jointKinematics.get(inputJointId)?.positions.length ?? 0;
+    if (numSteps === 0) return;
+    const dt = this.jointKinematics.get(inputJointId)?.timeIncrement ?? 0;
+    if (dt <= 0) return;
+
+    const hasVirtualSliderLoop = loops.some(loop => loop.some(step => step.isVirtualSlider));
+    if (hasVirtualSliderLoop) {
+      // For virtual slider closures, differentiate the solved omega series instead of using the general acceleration solver
+      this.linkAngularAccelerationCache = new Map();
+      for (const [key, omegaArray] of this.linkAngularVelocityCache.entries()) {
+        const alphaArray = this.differentiateSeries(omegaArray, dt);
+        this.linkAngularAccelerationCache.set(key, alphaArray);
+      }
+      return;
+    }
+
     const inputSpeed = solveOrder.prerequisites.get(inputJointId)!.jointToSolve.inputSpeed;
     const omega2 = 2 * Math.PI * (inputSpeed / 60);
-    const alpha2 = 0; // input acceleration is 0 (constant)
+    const alpha2 = 0;
 
     let crankEndId: number | null = null;
     for (const id of solveOrder.order) {
@@ -893,9 +908,6 @@ export class AnalysisSolveService {
     }
     if (crankEndId === null) return;
 
-    const numSteps = this.jointKinematics.get(inputJointId)?.positions.length ?? 0;
-    if (numSteps === 0) return;
-
     const nodes = graph.nodes;
     const unknownKeys: string[] = [];
     const seenKeys = new Set<string>();
@@ -904,11 +916,15 @@ export class AnalysisSolveService {
       for (const step of loop) {
         const nA = nodes.get(step.idA)!;
         const nB = nodes.get(step.idB)!;
-        if (nA.isGrounded && nB.isGrounded) continue;
+        const isPrismatic = this.isPrismaticClosureStep(graph, solveOrder, step);
+
+        if (nA.isGrounded && nB.isGrounded && !isPrismatic) continue;
         if ((nA.isGrounded && nA.isInput) || (nB.isGrounded && nB.isInput)) continue;
-        const k = this.isPrismaticClosureStep(graph, solveOrder, step)
+
+        const k = isPrismatic
           ? this.sliderKey(step.idA, step.idB)
           : this.linkKey(step.idA, step.idB);
+
         if (!seenKeys.has(k)) {
           seenKeys.add(k);
           unknownKeys.push(k);
@@ -918,20 +934,19 @@ export class AnalysisSolveService {
 
     const numLoops = loops.length;
     const numUnknowns = unknownKeys.length;
-
     const unknownCol = new Map<string, number>();
     unknownKeys.forEach((k, i) => unknownCol.set(k, i));
 
     const alphaArrays: number[][] = unknownKeys.map(() => []);
     let lastSol: number[] = new Array(numUnknowns).fill(0);
 
+    this.linkAngularAccelerationCache = new Map();
     this.linkAngularAccelerationCache.set(
       this.linkKey(inputJointId, crankEndId),
       new Array(numSteps).fill(alpha2)
     );
 
     for (let t = 0; t < numSteps; t++) {
-
       const matA: number[][] = Array.from(
         { length: 2 * numLoops },
         () => new Array(numUnknowns).fill(0)
@@ -946,8 +961,9 @@ export class AnalysisSolveService {
           const nA = nodes.get(step.idA)!;
           const nB = nodes.get(step.idB)!;
           const sign = step.direction;
+          const isPrismatic = this.isPrismaticClosureStep(graph, solveOrder, step);
 
-          if (nA.isGrounded && nB.isGrounded) continue;
+          if (nA.isGrounded && nB.isGrounded && !isPrismatic) continue;
 
           const posA = this.jointKinematics.get(step.idA)!.positions[t];
           const posB = this.jointKinematics.get(step.idB)!.positions[t];
@@ -959,10 +975,7 @@ export class AnalysisSolveService {
           const sinT = Math.sin(theta);
           const cosT = Math.cos(theta);
 
-          const isCrank = (nA.isGrounded && nA.isInput) || (nB.isGrounded && nB.isInput);
-
-          // input crank moved into RHS
-          if (isCrank) {
+          if ((nA.isGrounded && nA.isInput) || (nB.isGrounded && nB.isInput)) {
             vecB[rowX] += sign * r * omega2 * omega2 * cosT;
             vecB[rowY] += sign * r * omega2 * omega2 * sinT;
 
@@ -973,10 +986,11 @@ export class AnalysisSolveService {
             continue;
           }
 
-          const isPrismatic = this.isPrismaticClosureStep(graph, solveOrder, step);
           if (isPrismatic) {
             const slideJointId = this.getPrismaticClosureJointId(solveOrder, step);
-            const slideAngle = solveOrder.prerequisites.get(slideJointId)!.jointToSolve.angle;
+            const slideAngle = this.angleDegToRad(
+              solveOrder.prerequisites.get(slideJointId)!.jointToSolve.angle
+            );
             const col = unknownCol.get(this.sliderKey(step.idA, step.idB))!;
             matA[rowX][col] += sign * Math.cos(slideAngle);
             matA[rowY][col] += sign * Math.sin(slideAngle);
@@ -992,22 +1006,12 @@ export class AnalysisSolveService {
 
           const col = unknownCol.get(this.linkKey(step.idA, step.idB))!;
           matA[rowX][col] += sign * (-r * sinT);
-          matA[rowY][col] += sign * ( r * cosT);
+          matA[rowY][col] += sign * (r * cosT);
         }
       }
 
       try {
-        let sol: number[];
-        if (matA.length === numUnknowns) {
-          const rawSol = math.lusolve(matA, vecB) as number[][];
-          sol = rawSol.map(row => row[0]);
-        } else {
-          const matAT = math.transpose(matA) as number[][];
-          const matAT_A = math.multiply(matAT, matA) as number[][];
-          const vecAT_b = math.multiply(matAT, vecB) as number[];
-          const rawSol = math.lusolve(matAT_A, vecAT_b) as number[][];
-          sol = rawSol.map(row => row[0]);
-        }
+        const sol = this.solveAccelerationSystem(matA, vecB, numUnknowns);
         lastSol = sol;
         sol.forEach((v, i) => alphaArrays[i].push(v));
       } catch {
@@ -1036,12 +1040,103 @@ export class AnalysisSolveService {
     return `slider_${this.linkKey(a, b)}`;
   }
 
+  // Numerically differentiates a time series with forward/backward ends and centered interior samples.
+  private differentiateSeries(values: number[], dt: number): number[] {
+    if (values.length === 0) return [];
+    if (values.length === 1) return [0];
+
+    const derivative = new Array(values.length).fill(0);
+    derivative[0] = (values[1] - values[0]) / dt;
+
+    for (let i = 1; i < values.length - 1; i++) {
+      derivative[i] = (values[i + 1] - values[i - 1]) / (2 * dt);
+    }
+
+    derivative[values.length - 1] =
+      (values[values.length - 1] - values[values.length - 2]) / dt;
+
+    return derivative;
+  }
+
+  // Solves the acceleration system, using direct 2x2 algebra first and least-squares when A is not square.
+  private solveAccelerationSystem(matA: number[][], vecB: number[], numUnknowns: number): number[] {
+    if (numUnknowns === 2 && matA.length === 2) {
+      const [[a, b], [c, d]] = matA;
+      const det = a * d - b * c;
+      if (Math.abs(det) > 1e-12) {
+        return [
+          (vecB[0] * d - b * vecB[1]) / det,
+          (a * vecB[1] - vecB[0] * c) / det,
+        ];
+      }
+    }
+
+    if (matA.length === numUnknowns) {
+      try {
+        const rawSol = math.lusolve(matA, vecB) as number[][];
+        return rawSol.map(row => row[0]);
+      } catch {
+      }
+    }
+
+    const matAT = math.transpose(matA) as number[][];
+    const matAT_A = math.multiply(matAT, matA) as number[][];
+    const vecAT_b = math.multiply(matAT, vecB) as number[];
+    const rawSol = math.lusolve(matAT_A, vecAT_b) as number[][];
+    return rawSol.map(row => row[0]);
+  }
+
+  // Returns the cached angular series for the most representative joint pair on a compound link.
+  private getCachedLinkSeries(jointIDs: number[]): { vel: number[], acc: number[] } | null {
+    let fallback: { vel: number[], acc: number[] } | null = null;
+    let best: { vel: number[], acc: number[] } | null = null;
+    let bestScore = -Infinity;
+
+    for (let i = 0; i < jointIDs.length - 1; i++) {
+      for (let j = i + 1; j < jointIDs.length; j++) {
+        const key = this.linkKey(jointIDs[i], jointIDs[j]);
+        const vel = this.linkAngularVelocityCache.get(key);
+        const acc = this.linkAngularAccelerationCache.get(key);
+
+        if (!vel || !acc) continue;
+        if (!fallback) fallback = { vel, acc };
+
+        const score = this.seriesVariationScore(vel);
+        if (score > bestScore) {
+          bestScore = score;
+          best = { vel, acc };
+        }
+      }
+    }
+
+    return best ?? fallback;
+  }
+
+  // Prefers the pair whose angular velocity varies the most
+  private seriesVariationScore(values: number[]): number {
+    if (values.length === 0) return -Infinity;
+
+    let min = values[0];
+    let max = values[0];
+    for (const value of values) {
+      if (value < min) min = value;
+      if (value > max) max = value;
+    }
+
+    return max - min;
+  }
+
   private hasPhysicalLink(graph: LinkGraph, a: number, b: number): boolean {
     const key = this.linkKey(a, b);
     return graph.edges.some(edge => this.linkKey(edge.idA, edge.idB) === key);
   }
 
   private isPrismaticClosureStep(graph: LinkGraph, solveOrder: SolveOrder, step: LoopEdge): boolean {
+    if (step.isVirtualSlider) {
+      // Virtual slider edges are always prismatic, even though they do not exist in the physical link graph.
+      return true;
+    }
+
     if (this.hasPhysicalLink(graph, step.idA, step.idB)) {
       return false;
     }

From 725cef63d9d28a53ee37268c67365e6903e3b5d0 Mon Sep 17 00:00:00 2001
From: mwalsh001 <matty71604@gmail.com>
Date: Wed, 1 Apr 2026 22:08:21 -0400
Subject: [PATCH 18/23] Slider-crank angular velocity and acceleration.

---
 src/app/services/analysis-solver.service.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/app/services/analysis-solver.service.ts b/src/app/services/analysis-solver.service.ts
index 3dd38713..f8206bd5 100644
--- a/src/app/services/analysis-solver.service.ts
+++ b/src/app/services/analysis-solver.service.ts
@@ -1040,7 +1040,7 @@ export class AnalysisSolveService {
     return `slider_${this.linkKey(a, b)}`;
   }
 
-  // Numerically differentiates a time series with forward/backward ends and centered interior samples.
+  // Numerically differentiates a series
   private differentiateSeries(values: number[], dt: number): number[] {
     if (values.length === 0) return [];
     if (values.length === 1) return [0];

From 6338069f42680498447268de637d90b4b238d364 Mon Sep 17 00:00:00 2001
From: mwalsh001 <matty71604@gmail.com>
Date: Wed, 1 Apr 2026 22:08:48 -0400
Subject: [PATCH 19/23] Delete unused file.

---
 .../services/analysis-solver.service.spec.ts  | 55 -------------------
 1 file changed, 55 deletions(-)
 delete mode 100644 src/app/services/analysis-solver.service.spec.ts

diff --git a/src/app/services/analysis-solver.service.spec.ts b/src/app/services/analysis-solver.service.spec.ts
deleted file mode 100644
index f64316a1..00000000
--- a/src/app/services/analysis-solver.service.spec.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import {AnalysisSolveService, JointAnalysis} from './analysis-solver.service';
-import { PositionSolverService } from './kinematic-solver.service';
-import { create, all } from 'mathjs';
-
-const math = create(all, {});
-
-describe('AnalysisSolveService getAngularVelocities', () => {
-  let service: AnalysisSolveService;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [
-        { provide: PositionSolverService, useValue: {} },
-        AnalysisSolveService,
-      ],
-    });
-
-    service = TestBed.inject(AnalysisSolveService);
-  });
-
-  const deg2rad = (deg: number) => deg * Math.PI / 180;
-
-  const r2 = 2.954;  // AB
-  const r3 = 5.752;  // BC
-  const r4 = 3.745;  // CD
-
-  it('computes correct ω3 and ω4 for time = 0', () => {
-    // Row:
-    // 0   80.0594   1.0472   -168.1626   -0.1401   95.0559   0.7726
-
-    const theta2 = deg2rad(80.0594);    // AB angle
-    const theta3 = deg2rad(-168.1626);  // CB angle
-    const theta4 = deg2rad(95.0559);    // DC angle
-    console.log('theta2: ' +theta2);
-    console.log('theta3: ' +theta3);
-    console.log('theta4: ' +theta4);
-    const omega2 = 1.0472;
-
-    const [omega3, omega4] = service.getAngularVelocities(
-      r2, r3, r4,
-      theta2, theta3, theta4,
-
-      omega2
-    );
-
-    console.log('t=0  ω3, ω4 =', omega3, omega4);
-
-    // From table: CB = -0.1401 rad/s, DC = 0.7726 rad/s
-    expect(omega3).toBeCloseTo(-0.1401, 4);
-    expect(omega4).toBeCloseTo(0.7726, 4);
-  });
-
-
-});

From 03cc2dc9a56b19e759d372609a8dee80cfd1eb92 Mon Sep 17 00:00:00 2001
From: mwalsh001 <matty71604@gmail.com>
Date: Mon, 13 Apr 2026 09:36:52 -0400
Subject: [PATCH 20/23] Integrate kinematic values into side panel in place of
 "N/A" placeholders. Synced with global units.

---
 .../link-analysis-panel.component.html        |   9 +-
 .../link-analysis-panel.component.ts          | 140 ++++++++++++++----
 2 files changed, 119 insertions(+), 30 deletions(-)

diff --git a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.html b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.html
index 2eb886a2..e74db4d6 100644
--- a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.html
+++ b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.html
@@ -20,7 +20,7 @@
                              [btn1Action]="toggleGraph.bind(this, GraphType.referenceJointAngle)"
                              [graphText]= "currentGraphType === GraphType.referenceJointAngle ? 'Close Graph' : 'Show Graph'"></analysis-graph-button>
 
-      <p style="margin-left: 10px; margin-top: 1px;">θ: {{getCurrentLink().angle}} rad</p>
+      <p style="margin-left: 10px; margin-top: 1px;">Theta: {{getCurrentLink().angle}} rad</p>
 
       <ng-container *ngIf="currentGraphType === GraphType.referenceJointAngle">
           <div class="modal" (keyup.escape)="closeAnalysisGraph()">
@@ -39,8 +39,8 @@
                              [btn1Action]="toggleGraph.bind(this, GraphType.referenceJointAngularVelocity)"
                              [graphText]= "currentGraphType === GraphType.referenceJointAngularVelocity ? 'Close Graph' : 'Show Graph'">></analysis-graph-button>
 
-      <p style="margin-left: 10px; margin-top: 1px;">ω: {{ "N/A" }} rad/s</p>
-<!--      getCurrentLinkAnalysis()-->
+      <p style="margin-left: 10px; margin-top: 1px;">ω: {{ getCurrentAngularVelocity() }}</p>
+      <!--      getCurrentLinkAnalysis()-->
       <ng-container *ngIf="currentGraphType === GraphType.referenceJointAngularVelocity">
           <div class="modal" (keyup.escape)="closeAnalysisGraph()">
             <app-analysis-graph-block class="large-graph"
@@ -57,7 +57,7 @@
                              [explainText]="'Link Angular Acceleration'"
                              [btn1Action]="toggleGraph.bind(this, GraphType.referenceJointAngularAcceleration)"
                              [graphText]= "currentGraphType === GraphType.referenceJointAngularAcceleration ? 'Close Graph' : 'Show Graph'">></analysis-graph-button>
-      <p style="margin-left: 10px; margin-top: 1px;">ω: N/A rad/s<sup>2</sup></p>
+      <p style="margin-left: 10px; margin-top: 1px;">α: {{ getCurrentAngularAcceleration() }}</p>
       <ng-container *ngIf="currentGraphType === GraphType.referenceJointAngularAcceleration">
           <div class="modal" (keyup.escape)="closeAnalysisGraph()">
             <app-analysis-graph-block class="large-graph"
@@ -255,4 +255,3 @@
 
 
 </div>
-
diff --git a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
index 6a2f84f6..86fe8c2b 100644
--- a/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
+++ b/src/app/components/SideNav/Analysis/link-analysis-panel/link-analysis-panel.component.ts
@@ -1,10 +1,12 @@
-import {Component} from '@angular/core'
+import {Component, OnDestroy} from '@angular/core'
+import {Subscription} from 'rxjs';
 import {StateService} from "src/app/services/state.service";
 import {InteractionService} from "src/app/services/interaction.service";
 import {Mechanism} from "src/app/model/mechanism";
 import {LinkInteractor} from "src/app/controllers/link-interactor";
 import {Joint} from "src/app/model/joint";
 import {AnalysisSolveService, JointAnalysis, LinkAnalysis} from "src/app/services/analysis-solver.service";
+import {AnimationService} from "src/app/services/animation.service";
 
 // enum contains every kind of graph this panel can open.
 export enum GraphType {
@@ -24,23 +26,33 @@ export enum GraphType {
 
 })
 
-export class LinkAnalysisPanelComponent {
+export class LinkAnalysisPanelComponent implements OnDestroy {
 
   currentGraphType: GraphType | null = null;
   referenceJoint: Joint = this.getCurrentLink().joints.get(0) as Joint;
   currentGlobalUSuffix: any;
   currentGlobalAngleSuffix: any;
+  currentFrameIndex = 0;
+  private readonly subscriptions = new Subscription();
   constructor(private stateService: StateService, private interactorService: InteractionService,
-              private analysisSolverService: AnalysisSolveService){
-    this.stateService.globalUSuffixCurrent.subscribe(value => {
+              private analysisSolverService: AnalysisSolveService,
+              private animationService: AnimationService){
+    this.subscriptions.add(this.stateService.globalUSuffixCurrent.subscribe(value => {
       this.currentGlobalUSuffix = value;
-    });
-    this.stateService.globalASuffixCurrent.subscribe(value => {
+    }));
+    this.subscriptions.add(this.stateService.globalASuffixCurrent.subscribe(value => {
       this.currentGlobalAngleSuffix = value;
-    });
+    }));
+    this.subscriptions.add(this.animationService.currentFrameIndex$.subscribe(frameIndex => {
+      this.currentFrameIndex = frameIndex;
+    }));
 
   }
 
+  ngOnDestroy(): void {
+    this.subscriptions.unsubscribe();
+  }
+
   getMechanism(): Mechanism {return this.stateService.getMechanism();}
   getCurrentLink(){
     let currentLinkInteractor = this.interactorService.getSelectedObject();
@@ -51,6 +63,17 @@ export class LinkAnalysisPanelComponent {
 // get x coord and y coord return the number of the center of mass
   getCOMXCoord(): number {return this.getCurrentLink()?.centerOfMass.x.toFixed(3) as unknown as number;}
   getCOMYCoord(): number {return this.getCurrentLink()?.centerOfMass.y.toFixed(3) as unknown as number;}
+
+  getCurrentAngularVelocity(): string {
+    const value = this.getCurrentLinkKinematicValue('velocity');
+    return value === null ? 'N/A' : `${value} ${this.getAngularRateUnit()}`;
+  }
+
+  getCurrentAngularAcceleration(): string {
+    const value = this.getCurrentLinkKinematicValue('acceleration');
+    return value === null ? 'N/A' : `${value} ${this.getAngularAccelerationUnit()}`;
+  }
+
   openAnalysisGraph(graphType: GraphType): void {
     this.currentGraphType = graphType;
     if(this.currentGraphType == GraphType.CoMPosition ||
@@ -85,13 +108,13 @@ export class LinkAnalysisPanelComponent {
       case GraphType.CoMVelocity:
         return 'Center of Mass Velocity (' + this.currentGlobalUSuffix + '/s)';
       case GraphType.CoMAcceleration:
-        return 'Center of Mass Acceleration(' + this.currentGlobalUSuffix + '/s²)';
+        return 'Center of Mass Acceleration(' + this.currentGlobalUSuffix + '/s²)';
       case GraphType.referenceJointAngle:
         return 'Reference Joint Angle(' + this.currentGlobalAngleSuffix + ')';
       case GraphType.referenceJointAngularVelocity:
         return 'Reference Joint Angular Velocity(' + this.currentGlobalAngleSuffix + '/s)';
       case GraphType.referenceJointAngularAcceleration:
-        return 'Reference Joint Angular Acceleration(' + this.currentGlobalAngleSuffix + '/s²)';
+        return 'Reference Joint Angular Acceleration(' + this.currentGlobalAngleSuffix + '/s²)';
       // Add more cases as needed
       default:
         return ''; // Handle unknown cases or add a default value
@@ -206,6 +229,54 @@ export class LinkAnalysisPanelComponent {
   }
   public GraphType = GraphType;
 
+  private getCurrentLinkAnalysis(): LinkAnalysis | null {
+    const joints = this.getCurrentLink().getJoints();
+    if (joints.length < 2 || this.animationService.isInvalid()) {
+      return null;
+    }
+
+    this.analysisSolverService.updateKinematics();
+    return this.analysisSolverService.getLinkKinematics(joints.map(joint => joint.id));
+  }
+
+  private getCurrentLinkKinematicValue(type: 'velocity' | 'acceleration'): string | null {
+    const analysis = this.getCurrentLinkAnalysis();
+    if (!analysis) {
+      return null;
+    }
+
+    const series = type === 'velocity'
+      ? analysis.angularVelocity
+      : analysis.angularAcceleration;
+    if (series.length === 0) {
+      return null;
+    }
+
+    const frameIndex = Math.min(this.currentFrameIndex, series.length - 1);
+    const value = this.convertAngularDisplayValue(series[frameIndex]);
+    return value.toFixed(3);
+  }
+
+  private getAngularRateUnit(): string {
+    return `${this.getAngleDisplayUnit()}/s`;
+  }
+
+  private getAngularAccelerationUnit(): string {
+    return `${this.getAngleDisplayUnit()}/s^2`;
+  }
+
+  private convertAngularDisplayValue(valueInRadians: number): number {
+    if (this.currentGlobalAngleSuffix === 'rad') {
+      return valueInRadians;
+    }
+
+    return valueInRadians * 180 / Math.PI;
+  }
+
+  private getAngleDisplayUnit(): 'rad' | 'deg' {
+    return this.currentGlobalAngleSuffix === 'rad' ? 'rad' : 'deg';
+  }
+
   downloadCSV() {
     const table = document.querySelector(".table-auto");
     if (!table) return;
@@ -298,25 +369,27 @@ export class LinkAnalysisPanelComponent {
     jointAnalyses: Array<{joint: Joint, analysis: JointAnalysis}>,
     parameters: string[]
   ): void {
+    const linearUnit = this.getLinearDisplayUnit();
+
     for (const {joint, analysis} of jointAnalyses) {
       for (const parameter of parameters) {
         switch (parameter) {
           case "position":
             series.push(
-              {header: `joint_${joint.id}_x`, values: analysis.positions.map(coord => coord.x)},
-              {header: `joint_${joint.id}_y`, values: analysis.positions.map(coord => coord.y)}
+              {header: `joint_${joint.id}_x_${linearUnit}`, values: analysis.positions.map(coord => coord.x)},
+              {header: `joint_${joint.id}_y_${linearUnit}`, values: analysis.positions.map(coord => coord.y)}
             );
             break;
           case "velocity":
             series.push(
-              {header: `joint_${joint.id}_vx`, values: analysis.velocities.map(coord => coord.x)},
-              {header: `joint_${joint.id}_vy`, values: analysis.velocities.map(coord => coord.y)}
+              {header: `joint_${joint.id}_vx_${linearUnit}_s`, values: analysis.velocities.map(coord => coord.x)},
+              {header: `joint_${joint.id}_vy_${linearUnit}_s`, values: analysis.velocities.map(coord => coord.y)}
             );
             break;
           case "acceleration":
             series.push(
-              {header: `joint_${joint.id}_ax`, values: analysis.accelerations.map(coord => coord.x)},
-              {header: `joint_${joint.id}_ay`, values: analysis.accelerations.map(coord => coord.y)}
+              {header: `joint_${joint.id}_ax_${linearUnit}_s2`, values: analysis.accelerations.map(coord => coord.x)},
+              {header: `joint_${joint.id}_ay_${linearUnit}_s2`, values: analysis.accelerations.map(coord => coord.y)}
             );
             break;
         }
@@ -330,33 +403,50 @@ export class LinkAnalysisPanelComponent {
     linkKinematics: LinkAnalysis,
     parameters: string[]
   ): void {
+    const angleUnit = this.getAngleDisplayUnit();
+
     for (const parameter of parameters) {
       switch (parameter) {
         case "position":
           series.push(
             {
-              header: `link_${linkName}_angle_deg`,
-              values: linkKinematics.angle.map(angle => {
-                let normalizedAngle = angle % (2 * Math.PI);
-                if (normalizedAngle < 0) {
-                  normalizedAngle += 2 * Math.PI;
-                }
-                return normalizedAngle * 180 / Math.PI;
-              })
+              header: `link_${linkName}_angle_${angleUnit}`,
+              values: linkKinematics.angle.map(angle => this.convertAngleSeriesValue(angle))
             }
           );
           break;
         case "velocity":
           series.push(
-            {header: `link_${linkName}_omega_rad_s`, values: linkKinematics.angularVelocity}
+            {
+              header: `link_${linkName}_omega_${angleUnit}_s`,
+              values: linkKinematics.angularVelocity.map(value => this.convertAngularDisplayValue(value))
+            }
           );
           break;
         case "acceleration":
           series.push(
-            {header: `link_${linkName}_alpha_rad_s2`, values: linkKinematics.angularAcceleration}
+            {
+              header: `link_${linkName}_alpha_${angleUnit}_s2`,
+              values: linkKinematics.angularAcceleration.map(value => this.convertAngularDisplayValue(value))
+            }
           );
           break;
       }
     }
   }
+
+  private convertAngleSeriesValue(valueInRadians: number): number {
+    let normalizedAngle = valueInRadians % (2 * Math.PI);
+    if (normalizedAngle < 0) {
+      normalizedAngle += 2 * Math.PI;
+    }
+
+    return this.currentGlobalAngleSuffix === 'rad'
+      ? normalizedAngle
+      : normalizedAngle * 180 / Math.PI;
+  }
+
+  private getLinearDisplayUnit(): string {
+    return this.currentGlobalUSuffix || 'cm';
+  }
 }

From 9792c6747b4967813f82fe740a0065438719e320 Mon Sep 17 00:00:00 2001
From: mwalsh001 <matty71604@gmail.com>
Date: Tue, 14 Apr 2026 14:32:40 -0400
Subject: [PATCH 21/23] Fixed issue with RPM speed not changing and CCW/CW.

---
 src/app/model/joint.ts                      |  2 ++
 src/app/services/analysis-solver.service.ts | 32 ++++++++++++++++-----
 2 files changed, 27 insertions(+), 7 deletions(-)

diff --git a/src/app/model/joint.ts b/src/app/model/joint.ts
index d185cc20..c4282c95 100644
--- a/src/app/model/joint.ts
+++ b/src/app/model/joint.ts
@@ -147,6 +147,7 @@ export class Joint {
 
   set speed(newSpeed: number) {
     this._inputSpeed = newSpeed;
+    this._rpmSpeed = newSpeed;
   }
 
   set locked(value: boolean) {
@@ -161,6 +162,7 @@ export class Joint {
 
   set rpmSpeed(newSpeed: number) {
     this._rpmSpeed = newSpeed;
+    this._inputSpeed = newSpeed;
   }
 
   set hidden(val: boolean) {
diff --git a/src/app/services/analysis-solver.service.ts b/src/app/services/analysis-solver.service.ts
index f8206bd5..0a896814 100644
--- a/src/app/services/analysis-solver.service.ts
+++ b/src/app/services/analysis-solver.service.ts
@@ -3,6 +3,7 @@ import { Coord } from '../model/coord';
 import { PositionSolverService, SolveOrder, SolvePrerequisite, SolveType } from './kinematic-solver.service';
 import { AnimationPositions } from './kinematic-solver.service';
 import { StateService } from './state.service';
+import { AnimationService } from './animation.service';
 import { create, all, MathJsInstance } from 'mathjs';
 const math: MathJsInstance = create(all, {});
 
@@ -94,7 +95,11 @@ export class AnalysisSolveService {
 
   private lastSolveOrder: SolveOrder | null = null;
 
-  constructor(private positionSolver: PositionSolverService, private stateService: StateService) {
+  constructor(
+    private positionSolver: PositionSolverService,
+    private stateService: StateService,
+    private animationService: AnimationService
+  ) {
 
   }
 
@@ -103,6 +108,18 @@ export class AnalysisSolveService {
     return angleDeg * Math.PI / 180;
   }
 
+  private getInputDirectionSign(): 1 | -1 {
+    return this.animationService.startDirectionCounterclockwise ? 1 : -1;
+  }
+
+  private getSignedInputSpeed(inputSpeed: number): number {
+    return Math.abs(inputSpeed) * this.getInputDirectionSign();
+  }
+
+  private getSignedInputOmega(inputSpeed: number): number {
+    return 2 * Math.PI * (this.getSignedInputSpeed(inputSpeed) / 60);
+  }
+
   // Updates kinematic data by fetching solve orders and joint positions, then solving submechanism kinematics.
   updateKinematics() {
     /**Order of operations
@@ -137,8 +154,9 @@ export class AnalysisSolveService {
     }
     const arrayColumn = (array: Coord[][], columnIndex: number) => array.map(row => row[columnIndex])
     this.jointKinematics = new Map();
-    let inputspeed: number = solveOrder.prerequisites.get(solveOrder.order[0])!.jointToSolve.inputSpeed;
-    let timeIncrement: number = 60 / (inputspeed * 360);
+    const inputspeed: number = solveOrder.prerequisites.get(solveOrder.order[0])!.jointToSolve.inputSpeed;
+    const inputspeedMagnitude = Math.abs(inputspeed);
+    let timeIncrement: number = inputspeedMagnitude > 0 ? 60 / (inputspeedMagnitude * 360) : 0;
     for (let i = 0; i < solveOrder.order.length; i++) {
       let accelerations = arrayColumn(mechanismAccelerations, i);
       let velocities = arrayColumn(mechanismVelocities, i);
@@ -210,7 +228,7 @@ export class AnalysisSolveService {
     const xDifference = positions[jointIndex].x - positions[0].x;
     const yDifference = positions[jointIndex].y - positions[0].y;
     const angleToInput: number = Math.atan2(yDifference, xDifference);
-    const omega: number = 2 * Math.PI * (prereq.knownJointOne!.inputSpeed / 60); //Angular Velocity of Link in Radians
+    const omega: number = this.getSignedInputOmega(prereq.knownJointOne!.inputSpeed); //Angular Velocity of Link in Radians
     const r: number = prereq.distFromKnownJointOne!;
 
     //velocity
@@ -228,7 +246,7 @@ export class AnalysisSolveService {
 
   // Calculates velocity and acceleration for a prismatic input joint from its prerequisites.
   solvePrisInputJointKinematics(prereq: SolvePrerequisite): { velocity: Coord, acceleration: Coord } {
-    const velocityMag = prereq.jointToSolve.inputSpeed * (0.05 * 6) //Kinematic solver generates frames for 0.05m increments, and animator uses Rev-Input timeInterval calculation
+    const velocityMag = this.getSignedInputSpeed(prereq.jointToSolve.inputSpeed) * (0.05 * 6) //Kinematic solver generates frames for 0.05m increments, and animator uses Rev-Input timeInterval calculation
     // Slider angles are stored in degrees in the joint model.
     const velocityTheta = this.angleDegToRad(prereq.jointToSolve.angle);
     const deltaX: number = Math.cos(velocityTheta) * velocityMag;
@@ -709,7 +727,7 @@ export class AnalysisSolveService {
     // Input joint / motor speed
     const inputJointId = solveOrder.order[0];
     const inputSpeed   = solveOrder.prerequisites.get(inputJointId)!.jointToSolve.inputSpeed;
-    const omega2       = 2 * Math.PI * (inputSpeed / 60);
+    const omega2       = this.getSignedInputOmega(inputSpeed);
 
     // Find the far end of the input crank (RevoluteInput joint)
     let crankEndId: number | null = null;
@@ -896,7 +914,7 @@ export class AnalysisSolveService {
     }
 
     const inputSpeed = solveOrder.prerequisites.get(inputJointId)!.jointToSolve.inputSpeed;
-    const omega2 = 2 * Math.PI * (inputSpeed / 60);
+    const omega2 = this.getSignedInputOmega(inputSpeed);
     const alpha2 = 0;
 
     let crankEndId: number | null = null;

From 29d67d94b7cf2610c0f844444ed2fd9647abad6a Mon Sep 17 00:00:00 2001
From: mwalsh001 <matty71604@gmail.com>
Date: Tue, 14 Apr 2026 15:07:02 -0400
Subject: [PATCH 22/23] Unmerged main - caused issues with data display of
 kinematics.

---
 src/app/services/decoder.service.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/app/services/decoder.service.ts b/src/app/services/decoder.service.ts
index 29355727..7d17dbc3 100644
--- a/src/app/services/decoder.service.ts
+++ b/src/app/services/decoder.service.ts
@@ -65,8 +65,12 @@ export class DecoderService {
         .replaceAll('~', '","');
       console.log(decompressedJSON);
 
+
       const compactData = JSON.parse(decompressedJSON, (key, value) => {
         if (typeof value === 'string') {
+          if (/^[0-9a-f]+$/i.test(value)) {
+            return parseInt(value, 16);
+          }
           if (value === 'y') return true;
           if (value === 'n') return false;
         }

From 517f2eebba84fd561c9be3517d1c036bc2d4513b Mon Sep 17 00:00:00 2001
From: mwalsh001 <matty71604@gmail.com>
Date: Tue, 14 Apr 2026 15:24:01 -0400
Subject: [PATCH 23/23] Added back hex decoding for numeric fields during URL
 import without globally parsing all strings. This fixes input speeds, IDs,
 and angles being decoded as strings, which caused   omega/acceleration
 calculations to become NaN as they attempted to calculate using strings not
 numbers.

---
 src/app/services/decoder.service.ts | 24 ++++++++++++++++++------
 1 file changed, 18 insertions(+), 6 deletions(-)

diff --git a/src/app/services/decoder.service.ts b/src/app/services/decoder.service.ts
index 7d17dbc3..cb529289 100644
--- a/src/app/services/decoder.service.ts
+++ b/src/app/services/decoder.service.ts
@@ -65,12 +65,8 @@ export class DecoderService {
         .replaceAll('~', '","');
       console.log(decompressedJSON);
 
-
       const compactData = JSON.parse(decompressedJSON, (key, value) => {
         if (typeof value === 'string') {
-          if (/^[0-9a-f]+$/i.test(value)) {
-            return parseInt(value, 16);
-          }
           if (value === 'y') return true;
           if (value === 'n') return false;
         }
@@ -80,7 +76,7 @@ export class DecoderService {
       // Expand the compact data into full objects.
       console.log('compactData');
       console.log(compactData);
-      const fullData = this.expandMechanismData(compactData);
+      const fullData = this.expandMechanismData(compactData, true);
 
       if (compactData.z && compactData.z[0][0]) {
         const zoom = parseFloat(compactData.z[0][0]);
@@ -300,7 +296,23 @@ export class DecoderService {
     value: any,
     useDecoding: boolean = true
   ): number {
-    return useDecoding && Number.isInteger(value) ? parseInt(value, 16) : value;
+    if (!useDecoding) {
+      return Number(value);
+    }
+
+    if (typeof value === 'number') {
+      return value;
+    }
+
+    if (typeof value === 'string') {
+      if (/^-?[0-9a-f]+$/i.test(value)) {
+        return parseInt(value, 16);
+      }
+
+      return Number(value);
+    }
+
+    return Number(value);
   }
 
   /**