GMEG Engineering Simulator

⚡ Grid Supply:

Grid Templates Dashboard

▼ 1. MASTER GRID SETTINGS
☰	$ T_{seg} $	GRID Target Segments		View Help Guide Purpose: Sets the number of segments to display in the grid view Logic: Manually adjust the numbers of segments to interrogate Type: Manual Entry Render on Grids: None Mathematical Formula: $\text{User Input}$ Python Logic: `N/A` Live Evaluation: N/A (Input Variable)
☰	$ N_{\text{enablers}} $	GRID Enablers Per Segment	7.00	View Help Guide Purpose: Details the number of enablers used in the GMEG Logic: Pulls the number of enablers directly from the GMEG settings Type: Calculated (Math Output) Render on Grids: None Mathematical Formula: $N_{\text{enablers}} = N_{\text{enablers}}$ Python Logic: `v["Number of Gravity Enablers"]` Live Evaluation: [ROUTE: GRID] 7.0000 = 7.0000
☰	$ G_{\text{hz}} $	GRID Operating Frequency Hz	60.00	View Help Guide Purpose: States the operational interrogation frequency Logic: Changing the track slant impacts the operating frequency Type: Calculated (Math Output) Render on Grids: None Mathematical Formula: $G_{\text{hz}} = \theta_{\text{tilt}} \times 2$ Python Logic: `v["Angle tilt (degrees)"]2` Live Evaluation:* [ROUTE: GRID] 30.0000*2 = 60.0000
▼ 3. SPATIAL BLUEPRINTS - S1 E1 Base
☰	$ d_{track} $	Distance on track (m)	0.77	View Help Guide Purpose: Tracking where each individual enabler is on the physical track layout while making sure it resets cleanly to zero once it finishes a complete lap. Logic: Establishes the absolute zero starting point for the master train sequence in the simulation. Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque Mathematical Formula: $d_{track} = ( L_{\text{run}} + R_{z1, start} ) - ( L_{\text{seg}} + ( ( ( N_{\text{enablers}} -1 ) / 2 ) \times L_{\text{gap}} ) ) if R_{z1, start} - L_{\text{seg}} - ( ( ( N_{\text{enablers}} -1 ) / 2 ) \times L_{\text{gap}} ) < 0 else R_{z1, start} - L_{\text{seg}} - ( ( ( N_{\text{enablers}} -1 ) / 2 ) \times L_{\text{gap}} )$ Python Logic: ( v["Track full run length (m)"] + v["RotZone1 Start (m)"] ) - ( v["Distance travelled per segment (m)"] + ( ( ( v["Number of Gravity Enablers"] -1 ) / 2 ) * v["Enabler gap length (m)"] ) ) if v["RotZone1 Start (m)"] - v["Distance travelled per segment (m)"] - ( ( ( v["Number of Gravity Enablers"] -1 ) / 2 ) * v["Enabler gap length (m)"] ) < 0 else v["RotZone1 Start (m)"] - v["Distance travelled per segment (m)"] - ( ( ( v["Number of Gravity Enablers"] -1 ) / 2 ) * v["Enabler gap length (m)"] ) Live Evaluation: [ROUTE: GRID] ( 20.0000 + 3.4000 ) - ( 0.1200 + ( ( ( 7.0000 -1 ) / 2 ) * 0.8354 ) ) if 3.4000 - 0.1200 - ( ( ( 7.0000 -1 ) / 2 ) * 0.8354 ) < 0 else 3.4000 - 0.1200 - ( ( ( 7.0000 -1 ) / 2 ) * 0.8354 ) = 0.7739
☰	$ d_{ce} $	Centre Enabler Distance (m)	3.28	View Help Guide Purpose: Pulling the exact track distance of the center enabler for the current segment to use as our master structural baseline. Logic: Uses SUMIFS to target and isolate the specific track position of the "Centre" enabler from the Rotational Torque sheet. Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque Mathematical Formula: $d_{ce} = R_{z1, start} - L_{\text{seg}}$ Python Logic: `v["RotZone1 Start (m)"] - v["Distance travelled per segment (m)"]` Live Evaluation: [ROUTE: GRID] 3.4000 - 0.1200 = 3.2800
☰	$ \Delta d_{ce} $	Centre Enabler Difference (m)	0.12	View Help Guide Purpose: Calculating the master spatial step size based directly on the velocity and track slant gear ratio. Logic: Divides the operational velocity by the track slant gear ratio to determine exactly how far the train moves per simulation tick. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $\Delta d_{ce} = L_{\text{seg}} if d_{ce} == 0 else (R_{z1, start} - d_{ce} if (d_{ce} + L_{\text{seg}}) > R_{z1, start} else L_{\text{seg}}) if d_{ce} < (R_{z1, start} - 0.0001) else (R_{z1, end} - d_{ce} if (d_{ce} + L_{\text{seg}}) > R_{z1, end} else L_{\text{seg}}) if d_{ce} < (R_{z1, end} - 0.0001) else (R_{z2, start} - d_{ce} if (d_{ce} + L_{\text{seg}}) > R_{z2, start} else L_{\text{seg}}) if d_{ce} < (R_{z2, start} - 0.0001) else (R_{z2, end} - d_{ce} if (d_{ce} + L_{\text{seg}}) > R_{z2, end} else L_{\text{seg}}) if d_{ce} < (R_{z2, end} - 0.0001) else L_{\text{seg}}$ Python Logic: v["Distance travelled per segment (m)"] if v["Centre Enabler Distance (m)"] == 0 else (v["RotZone1 Start (m)"] - v["Centre Enabler Distance (m)"] if (v["Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone1 Start (m)"] else v["Distance travelled per segment (m)"]) if v["Centre Enabler Distance (m)"] < (v["RotZone1 Start (m)"] - 0.0001) else (v["RotZone1 End (m)"] - v["Centre Enabler Distance (m)"] if (v["Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone1 End (m)"] else v["Distance travelled per segment (m)"]) if v["Centre Enabler Distance (m)"] < (v["RotZone1 End (m)"] - 0.0001) else (v["RotZone2 Start (m)"] - v["Centre Enabler Distance (m)"] if (v["Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone2 Start (m)"] else v["Distance travelled per segment (m)"]) if v["Centre Enabler Distance (m)"] < (v["RotZone2 Start (m)"] - 0.0001) else (v["RotZone2 End (m)"] - v["Centre Enabler Distance (m)"] if (v["Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone2 End (m)"] else v["Distance travelled per segment (m)"]) if v["Centre Enabler Distance (m)"] < (v["RotZone2 End (m)"] - 0.0001) else v["Distance travelled per segment (m)"] Live Evaluation: [ROUTE: GRID] 0.1200 if 2.5061 == 0 else (3.4000 - 2.5061 if (2.5061 + 0.1200) > 3.4000 else 0.1200) if 2.5061 < (3.4000 - 0.0001) else (10.6000 - 2.5061 if (2.5061 + 0.1200) > 10.6000 else 0.1200) if 2.5061 < (10.6000 - 0.0001) else (13.4000 - 2.5061 if (2.5061 + 0.1200) > 13.4000 else 0.1200) if 2.5061 < (13.4000 - 0.0001) else (20.6000 - 2.5061 if (2.5061 + 0.1200) > 20.6000 else 0.1200) if 2.5061 < (20.6000 - 0.0001) else 0.1200 = 0.1200
☰	$ P_{trans} $	Transformed Enabler Distance (m)	0.12	View Help Guide Purpose: Figuring out the new position of the enabler after it takes a step, making sure it cleanly wraps around the finish line back to the start if it overshoots. Logic: Adds the step difference to the current distance, using an IF statement to subtract the total track length if it exceeds the finish line, ensuring an infinite mathematical loop. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $P_{trans} = d_{track}+\Delta d_{ce} - L_{c2} if d_{track}+\Delta d_{ce} > L_{c2} else d_{track}+\Delta d_{ce}$ Python Logic: `v["Distance on track (m)"]+v["Centre Enabler Difference (m)"] - v["Physical End Corner2 (m)"] if v["Distance on track (m)"]+v["Centre Enabler Difference (m)"] > v["Physical End Corner2 (m)"] else v["Distance on track (m)"]+v["Centre Enabler Difference (m)"]` Live Evaluation: [ROUTE: GRID] 0.0000+0.1200 - 20.0000 if 0.0000+0.1200 > 20.0000 else 0.0000+0.1200 = 0.1200
☰	$ d_{track} $	TAR Distance on track (m)	0.77	View Help Guide Purpose: Establishing the baseline distance on the track specifically for the TAR sandbox calculations. Logic: Mirrors the master track distance to identically initialize the isolated Track Arc Rotation (TAR) physics sandbox. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $d_{track} = ( L_{\text{run}} + R_{z1, start} ) - ( L_{\text{seg}} + ( ( ( N_{\text{enablers}} -1 ) / 2 ) \times L_{\text{gap}} ) ) if R_{z1, start} - L_{\text{seg}} - ( ( ( N_{\text{enablers}} -1 ) / 2 ) \times L_{\text{gap}} ) < 0 else R_{z1, start} - L_{\text{seg}} - ( ( ( N_{\text{enablers}} -1 ) / 2 ) \times L_{\text{gap}} )$ Python Logic: ( v["Track full run length (m)"] + v["RotZone1 Start (m)"] ) - ( v["Distance travelled per segment (m)"] + ( ( ( v["Number of Gravity Enablers"] -1 ) / 2 ) * v["Enabler gap length (m)"] ) ) if v["RotZone1 Start (m)"] - v["Distance travelled per segment (m)"] - ( ( ( v["Number of Gravity Enablers"] -1 ) / 2 ) * v["Enabler gap length (m)"] ) < 0 else v["RotZone1 Start (m)"] - v["Distance travelled per segment (m)"] - ( ( ( v["Number of Gravity Enablers"] -1 ) / 2 ) * v["Enabler gap length (m)"] ) Live Evaluation: [ROUTE: GRID] ( 20.0000 + 3.4000 ) - ( 0.1200 + ( ( ( 7.0000 -1 ) / 2 ) * 0.8354 ) ) if 3.4000 - 0.1200 - ( ( ( 7.0000 -1 ) / 2 ) * 0.8354 ) < 0 else 3.4000 - 0.1200 - ( ( ( 7.0000 -1 ) / 2 ) * 0.8354 ) = 0.7739
☰	$ P_{TAR,ce} $	TAR Centre Enabler Distance (m)	3.28	View Help Guide Purpose: Isolating the exact position of the center enabler inside the TAR tracking loop to manage our process boundaries. Logic: Pulls the "Centre" enabler's sandbox position to serve as the local spatial anchor for TAR logic. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $P_{TAR,ce} = R_{z1, start} - L_{\text{seg}}$ Python Logic: `v["RotZone1 Start (m)"] - v["Distance travelled per segment (m)"]` Live Evaluation: [ROUTE: GRID] 3.4000 - 0.1200 = 3.2800
☰	$ \Delta d_{TAR} $	TAR Difference (m)	0.12	View Help Guide Purpose: Setting the step size for the TAR tracker, locking it perfectly in sync with our master track step. Logic: Inherits the master step size so the TAR sandbox moves at the exact same velocity as the primary simulation. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $\Delta d_{TAR} = L_{\text{seg}} if d_{ce} == 0 else (R_{z1, start} - d_{ce} if (d_{ce} + L_{\text{seg}}) > R_{z1, start} else L_{\text{seg}}) if d_{ce} < (R_{z1, start} - 0.0001) else (R_{z1, end} - d_{ce} if (d_{ce} + L_{\text{seg}}) > R_{z1, end} else L_{\text{seg}}) if d_{ce} < (R_{z1, end} - 0.0001) else (R_{z2, start} - d_{ce} if (d_{ce} + L_{\text{seg}}) > R_{z2, start} else L_{\text{seg}}) if d_{ce} < (R_{z2, start} - 0.0001) else (R_{z2, end} - d_{ce} if (d_{ce} + L_{\text{seg}}) > R_{z2, end} else L_{\text{seg}}) if d_{ce} < (R_{z2, end} - 0.0001) else L_{\text{seg}}$ Python Logic: v["Distance travelled per segment (m)"] if v["Centre Enabler Distance (m)"] == 0 else (v["RotZone1 Start (m)"] - v["Centre Enabler Distance (m)"] if (v["Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone1 Start (m)"] else v["Distance travelled per segment (m)"]) if v["Centre Enabler Distance (m)"] < (v["RotZone1 Start (m)"] - 0.0001) else (v["RotZone1 End (m)"] - v["Centre Enabler Distance (m)"] if (v["Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone1 End (m)"] else v["Distance travelled per segment (m)"]) if v["Centre Enabler Distance (m)"] < (v["RotZone1 End (m)"] - 0.0001) else (v["RotZone2 Start (m)"] - v["Centre Enabler Distance (m)"] if (v["Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone2 Start (m)"] else v["Distance travelled per segment (m)"]) if v["Centre Enabler Distance (m)"] < (v["RotZone2 Start (m)"] - 0.0001) else (v["RotZone2 End (m)"] - v["Centre Enabler Distance (m)"] if (v["Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone2 End (m)"] else v["Distance travelled per segment (m)"]) if v["Centre Enabler Distance (m)"] < (v["RotZone2 End (m)"] - 0.0001) else v["Distance travelled per segment (m)"] Live Evaluation: [ROUTE: GRID] 0.1200 if 2.5061 == 0 else (3.4000 - 2.5061 if (2.5061 + 0.1200) > 3.4000 else 0.1200) if 2.5061 < (3.4000 - 0.0001) else (10.6000 - 2.5061 if (2.5061 + 0.1200) > 10.6000 else 0.1200) if 2.5061 < (10.6000 - 0.0001) else (13.4000 - 2.5061 if (2.5061 + 0.1200) > 13.4000 else 0.1200) if 2.5061 < (13.4000 - 0.0001) else (20.6000 - 2.5061 if (2.5061 + 0.1200) > 20.6000 else 0.1200) if 2.5061 < (20.6000 - 0.0001) else 0.1200 = 0.1200
☰	$ P_{trans} $	TAR Transformed Enabler Distance (m)	0.12	View Help Guide Purpose: Moving the TAR tracker forward by one step and executing our critical structural overshoot adjustment at the end of TAR 2 to keep the degrees perfect. Logic: Advances the sandbox position and triggers a geometric correction if the enabler overshoots the final rotation zone, keeping the structural degrees perfectly aligned. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $P_{trans} = d_{track} + \Delta d_{ce} - R_{z2, end} if d_{track} + \Delta d_{ce} > R_{z2, end} else d_{track} + \Delta d_{ce}$ Python Logic: `v["TAR Distance on track (m)"] + v["Centre Enabler Difference (m)"] - v["RotZone2 End (m)"] if v["TAR Distance on track (m)"] + v["Centre Enabler Difference (m)"] > v["RotZone2 End (m)"] else v["TAR Distance on track (m)"] + v["Centre Enabler Difference (m)"]` Live Evaluation: [ROUTE: GRID] 0.0000 + 0.1200 - 20.6000 if 0.0000 + 0.1200 > 20.6000 else 0.0000 + 0.1200 = 0.1200
▼ 3. SPATIAL BLUEPRINTS - S1 E2 Loop
☰	$ d_{track} $	Distance on track (m)	0.84	View Help Guide Purpose: Tracking where each individual enabler is on the physical track layout while making sure it resets cleanly to zero once it finishes a complete lap. Logic: Pulls the absolute starting position for Enabler 2 from the master sheet, which inherently accounts for the physical gap between the enablers. Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque Mathematical Formula: $d_{track} = v_pred_{track} + L_{\text{gap}} - L_{c2} if v_pred_{track} + L_{\text{gap}} > L_{c2} else v_pred_{track}+L_{\text{gap}}$ Python Logic: `v_prev["Distance on track (m)"] + v["Enabler gap length (m)"] - v["Physical End Corner2 (m)"] if v_prev["Distance on track (m)"] + v["Enabler gap length (m)"] > v["Physical End Corner2 (m)"] else v_prev["Distance on track (m)"]+v["Enabler gap length (m)"]` Live Evaluation: [ROUTE: GRID] 0.0000 + 0.8354 - 20.0000 if 0.0000 + 0.8354 > 20.0000 else 0.0000+0.8354 = 0.8354
☰	$ d_{ce} $	Centre Enabler Distance (m)	2.51	View Help Guide Purpose: Pulling the exact track distance of the center enabler for the current segment to use as our master structural baseline. Logic: Uses SUMIFS to target and isolate the specific track position of the "Centre" enabler from the Rotational Torque sheet. Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque Mathematical Formula: $d_{ce} = v_pred_{ce}$ Python Logic: `v_prev["Centre Enabler Distance (m)"]` Live Evaluation: [ROUTE: GRID] 2.5061 = 2.5061
☰	$ \Delta d_{ce} $	Centre Enabler Difference (m)	0.12	View Help Guide Purpose: Calculating the master spatial step size based directly on the velocity and track slant gear ratio. Logic: Directly points to the Enabler 1 step size, mathematically guaranteeing the entire train moves in perfect unison as a single rigid body. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $\Delta d_{ce} = v_pre\Delta d_{ce}$ Python Logic: `v_prev["Centre Enabler Difference (m)"]` Live Evaluation: [ROUTE: GRID] 0.1200 = 0.1200
☰	$ P_{trans} $	Transformed Enabler Distance (m)	0.96	View Help Guide Purpose: Figuring out the new position of the enabler after it takes a step, making sure it cleanly wraps around the finish line back to the start if it overshoots. Logic: Applies the shared step size to this enabler's unique starting distance, employing the same finish-line wrap-around logic as Enabler 1. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $P_{trans} = d_{track} + \Delta d_{ce} - L_{c2} if d_{track} + \Delta d_{ce} > L_{c2} else d_{track}+\Delta d_{ce}$ Python Logic: `v["Distance on track (m)"] + v["Centre Enabler Difference (m)"] - v["Physical End Corner2 (m)"] if v["Distance on track (m)"] + v["Centre Enabler Difference (m)"] > v["Physical End Corner2 (m)"] else v["Distance on track (m)"]+v["Centre Enabler Difference (m)"]` Live Evaluation: [ROUTE: GRID] 0.8354 + 0.1200 - 20.0000 if 0.8354 + 0.1200 > 20.0000 else 0.8354+0.1200 = 0.9554
☰	$ d_{track} $	TAR Distance on track (m)	0.84	View Help Guide Purpose: Establishing the baseline distance on the track specifically for the TAR sandbox calculations. Logic: Mirrors the master track distance to identically initialize the isolated Track Arc Rotation (TAR) physics sandbox for this enabler. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $d_{track} = v_pred_{track}+L_{\text{gap}}$ Python Logic: `v_prev["TAR Distance on track (m)"]+v["Enabler gap length (m)"]` Live Evaluation: [ROUTE: GRID] 0.0000+0.8354 = 0.8354
☰	$ P_{TAR,ce} $	TAR Centre Enabler Distance (m)	2.51	View Help Guide Purpose: Isolating the exact position of the center enabler inside the TAR tracking loop to manage our process boundaries. Logic: Pulls the "Centre" enabler's sandbox position to serve as the local spatial anchor for TAR logic. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $P_{TAR,ce} = v_preP_{TAR,ce}$ Python Logic: `v_prev["TAR Centre Enabler Distance (m)"]` Live Evaluation: [ROUTE: GRID] 2.5061 = 2.5061
☰	$ \Delta d_{TAR} $	TAR Difference (m)	0.12	View Help Guide Purpose: Setting the step size for the TAR tracker, locking it perfectly in sync with our master track step. Logic: Inherits the sandbox step size from Enabler 1 to keep the secondary TAR tracking in perfect sync with the primary system's velocity. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $\Delta d_{TAR} = v_pre\Delta d_{TAR}$ Python Logic: `v_prev["TAR Difference (m)"]` Live Evaluation: [ROUTE: GRID] 0.1200 = 0.1200
☰	$ P_{trans} $	TAR Transformed Enabler Distance (m)	0.96	View Help Guide Purpose: Moving the TAR tracker forward by one step and executing our critical structural overshoot adjustment at the end of TAR 2 to keep the degrees perfect. Logic: Advances the sandbox position and triggers a geometric correction if this enabler overshoots the final rotation zone, keeping the structural degrees perfectly aligned. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $P_{trans} = d_{track} + \Delta d_{ce} - R_{z2, end} if d_{track} + \Delta d_{ce} > R_{z2, end} else d_{track} + \Delta d_{ce}$ Python Logic: `v["TAR Distance on track (m)"] + v["Centre Enabler Difference (m)"] - v["RotZone2 End (m)"] if v["TAR Distance on track (m)"] + v["Centre Enabler Difference (m)"] > v["RotZone2 End (m)"] else v["TAR Distance on track (m)"] + v["Centre Enabler Difference (m)"]` Live Evaluation: [ROUTE: GRID] 0.8354 + 0.1200 - 20.6000 if 0.8354 + 0.1200 > 20.6000 else 0.8354 + 0.1200 = 0.9554
▼ 3. SPATIAL BLUEPRINTS - S2 E1 Transition
☰	$ d_{track} $	Distance on track (m)	0.12	View Help Guide Purpose: Tracking where each individual enabler is on the physical track layout while making sure it resets cleanly to zero once it finishes a complete lap. Logic: The Time Bridge: Reaches back exactly one time segment to grab the Transformed Position, making the end of Segment 1 the exact starting point of Segment 2. Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque Mathematical Formula: $d_{track} = v_prev_seg["Transformed Enabler Distance (m)"]$ Python Logic: `v_prev_seg["Transformed Enabler Distance (m)"]` Live Evaluation: [ROUTE: GRID] 0.1200 = 0.1200
☰	$ d_{ce} $	Centre Enabler Distance (m)	0.00	View Help Guide Purpose: Pulling the exact track distance of the center enabler for the current segment to use as our master structural baseline. Logic: Uses SUMIFS to isolate the center enabler's position in this new time step. Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque Mathematical Formula: $d_{ce} = v_prev_seg["TAR Centre Enabler Distance (m)"] + v_prev_seg["TAR Difference (m)"] - R_{z2, end} + (D_{\text{centre}} - C_{\text{corner, dist}}) if round(v_prev_seg["TAR Centre Enabler Distance (m)"] + v_prev_seg["TAR Difference (m)"],1) >= (R_{z2, end} - 0.001) else v_prev_seg["TAR Centre Enabler Distance (m)"] + v_prev_seg["TAR Difference (m)"]$ Python Logic: `v_prev_seg["TAR Centre Enabler Distance (m)"] + v_prev_seg["TAR Difference (m)"] - v["RotZone2 End (m)"] + (v["Centre enabler distance from rounded corner centre (m)"] - v["Half semi corner Circumference (m)"]) if round(v_prev_seg["TAR Centre Enabler Distance (m)"] + v_prev_seg["TAR Difference (m)"],1) >= (v["RotZone2 End (m)"] - 0.001) else v_prev_seg["TAR Centre Enabler Distance (m)"] + v_prev_seg["TAR Difference (m)"]` Live Evaluation: Error calculating preview: name 'round' is not defined
☰	$ \Delta d_{ce} $	Centre Enabler Difference (m)	0.12	View Help Guide Purpose: Calculating the master spatial step size based directly on the velocity and track slant gear ratio. Logic: The Boundary Engine: Evaluates the enabler's proximity to all four Rotational Zone boundaries. If a standard step would cross a boundary, it dynamically shrinks the step size to land exactly on the line. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $\Delta d_{ce} = L_{\text{seg}} if d_{ce} == 0 else (R_{z1, start} - d_{ce} if (d_{ce} + L_{\text{seg}}) > R_{z1, start} else L_{\text{seg}}) if d_{ce} < (R_{z1, start} - 0.0001) else (R_{z1, end} - d_{ce} if (d_{ce} + L_{\text{seg}}) > R_{z1, end} else L_{\text{seg}}) if d_{ce} < (R_{z1, end} - 0.0001) else (R_{z2, start} - d_{ce} if (d_{ce} + L_{\text{seg}}) > R_{z2, start} else L_{\text{seg}}) if d_{ce} < (R_{z2, start} - 0.0001) else (R_{z2, end} - d_{ce} if (d_{ce} + L_{\text{seg}}) > R_{z2, end} else L_{\text{seg}}) if d_{ce} < (R_{z2, end} - 0.0001) else L_{\text{seg}}$ Python Logic: v["Distance travelled per segment (m)"] if v["Centre Enabler Distance (m)"] == 0 else (v["RotZone1 Start (m)"] - v["Centre Enabler Distance (m)"] if (v["Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone1 Start (m)"] else v["Distance travelled per segment (m)"]) if v["Centre Enabler Distance (m)"] < (v["RotZone1 Start (m)"] - 0.0001) else (v["RotZone1 End (m)"] - v["Centre Enabler Distance (m)"] if (v["Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone1 End (m)"] else v["Distance travelled per segment (m)"]) if v["Centre Enabler Distance (m)"] < (v["RotZone1 End (m)"] - 0.0001) else (v["RotZone2 Start (m)"] - v["Centre Enabler Distance (m)"] if (v["Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone2 Start (m)"] else v["Distance travelled per segment (m)"]) if v["Centre Enabler Distance (m)"] < (v["RotZone2 Start (m)"] - 0.0001) else (v["RotZone2 End (m)"] - v["Centre Enabler Distance (m)"] if (v["Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone2 End (m)"] else v["Distance travelled per segment (m)"]) if v["Centre Enabler Distance (m)"] < (v["RotZone2 End (m)"] - 0.0001) else v["Distance travelled per segment (m)"] Live Evaluation: [ROUTE: GRID] 0.1200 if 3.2425 == 0 else (3.4000 - 3.2425 if (3.2425 + 0.1200) > 3.4000 else 0.1200) if 3.2425 < (3.4000 - 0.0001) else (10.6000 - 3.2425 if (3.2425 + 0.1200) > 10.6000 else 0.1200) if 3.2425 < (10.6000 - 0.0001) else (13.4000 - 3.2425 if (3.2425 + 0.1200) > 13.4000 else 0.1200) if 3.2425 < (13.4000 - 0.0001) else (20.6000 - 3.2425 if (3.2425 + 0.1200) > 20.6000 else 0.1200) if 3.2425 < (20.6000 - 0.0001) else 0.1200 = 0.1200
☰	$ P_{trans} $	Transformed Enabler Distance (m)	0.24	View Help Guide Purpose: Figuring out the new position of the enabler after it takes a step, making sure it cleanly wraps around the finish line back to the start if it overshoots. Logic: Adds the newly calculated (and potentially boundary-shrunk) step size to the current distance, employing the lap wrap-around logic. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $P_{trans} = d_{track}+\Delta d_{ce}-L_{c2} if d_{track}+\Delta d_{ce}>L_{c2} else d_{track}+\Delta d_{ce}$ Python Logic: `v["Distance on track (m)"]+v["Centre Enabler Difference (m)"]-v["Physical End Corner2 (m)"] if v["Distance on track (m)"]+v["Centre Enabler Difference (m)"]>v["Physical End Corner2 (m)"] else v["Distance on track (m)"]+v["Centre Enabler Difference (m)"]` Live Evaluation: [ROUTE: GRID] 0.1200+0.1200-20.0000 if 0.1200+0.1200>20.0000 else 0.1200+0.1200 = 0.2400
☰	$ d_{track} $	TAR Distance on track (m)	0.12	View Help Guide Purpose: Establishing the baseline distance on the track specifically for the TAR sandbox calculations. Logic: Inherits the TAR Transformed position from the previous time step, mirroring the master time transition for the sandbox. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $d_{track} = v_prev_seg["TAR Transformed Enabler Distance (m)"]$ Python Logic: `v_prev_seg["TAR Transformed Enabler Distance (m)"]` Live Evaluation: [ROUTE: GRID] 0.1200 = 0.1200
☰	$ P_{TAR,ce} $	TAR Centre Enabler Distance (m)	0.00	View Help Guide Purpose: Isolating the exact position of the center enabler inside the TAR tracking loop to manage our process boundaries. Logic: Pulls the "Centre" enabler's sandbox position to serve as the local spatial anchor for TAR logic in the new time step. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $P_{TAR,ce} = v_prev_seg["TAR Centre Enabler Distance (m)"]+v_prev_seg["TAR Difference (m)"]-R_{z2, end}+(D_{\text{centre}}-C_{\text{corner, dist}} ) if round(v_prev_seg["TAR Centre Enabler Distance (m)"]+v_prev_seg["TAR Difference (m)"]+0.001,3)>=R_{z2, end} else v_prev_seg["TAR Centre Enabler Distance (m)"]+v_prev_seg["TAR Difference (m)"]$ Python Logic: `v_prev_seg["TAR Centre Enabler Distance (m)"]+v_prev_seg["TAR Difference (m)"]-v["RotZone2 End (m)"]+(v["Centre enabler distance from rounded corner centre (m)"]-v["Half semi corner Circumference (m)"] ) if round(v_prev_seg["TAR Centre Enabler Distance (m)"]+v_prev_seg["TAR Difference (m)"]+0.001,3)>=v["RotZone2 End (m)"] else v_prev_seg["TAR Centre Enabler Distance (m)"]+v_prev_seg["TAR Difference (m)"]` Live Evaluation: Error calculating preview: name 'round' is not defined
☰	$ \Delta d_{TAR} $	TAR Difference (m)	0.12	View Help Guide Purpose: Setting the step size for the TAR tracker, locking it perfectly in sync with our master track step. Logic: Uses the exact same Boundary Engine logic as the master track to precisely calculate the step size for the sandbox, checking for RotZone intersections. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $\Delta d_{TAR} = L_{\text{seg}} if P_{TAR,ce} == 0 else (R_{z1, start} - P_{TAR,ce} if (P_{TAR,ce} + L_{\text{seg}}) > R_{z1, start} else L_{\text{seg}}) if P_{TAR,ce} < (R_{z1, start} - 0.0001) else (R_{z1, end} - P_{TAR,ce} if (P_{TAR,ce} + L_{\text{seg}}) > R_{z1, end} else L_{\text{seg}}) if P_{TAR,ce} < (R_{z1, end} - 0.0001) else (R_{z2, start} - P_{TAR,ce} if (P_{TAR,ce} + L_{\text{seg}}) > R_{z2, start} else L_{\text{seg}}) if P_{TAR,ce} < (R_{z2, start} - 0.0001) else (R_{z2, end} - P_{TAR,ce} if (P_{TAR,ce} + L_{\text{seg}}) > R_{z2, end} else L_{\text{seg}}) if P_{TAR,ce} < (R_{z2, end} - 0.0001) else L_{\text{seg}}$ Python Logic: v["Distance travelled per segment (m)"] if v["TAR Centre Enabler Distance (m)"] == 0 else (v["RotZone1 Start (m)"] - v["TAR Centre Enabler Distance (m)"] if (v["TAR Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone1 Start (m)"] else v["Distance travelled per segment (m)"]) if v["TAR Centre Enabler Distance (m)"] < (v["RotZone1 Start (m)"] - 0.0001) else (v["RotZone1 End (m)"] - v["TAR Centre Enabler Distance (m)"] if (v["TAR Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone1 End (m)"] else v["Distance travelled per segment (m)"]) if v["TAR Centre Enabler Distance (m)"] < (v["RotZone1 End (m)"] - 0.0001) else (v["RotZone2 Start (m)"] - v["TAR Centre Enabler Distance (m)"] if (v["TAR Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone2 Start (m)"] else v["Distance travelled per segment (m)"]) if v["TAR Centre Enabler Distance (m)"] < (v["RotZone2 Start (m)"] - 0.0001) else (v["RotZone2 End (m)"] - v["TAR Centre Enabler Distance (m)"] if (v["TAR Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone2 End (m)"] else v["Distance travelled per segment (m)"]) if v["TAR Centre Enabler Distance (m)"] < (v["RotZone2 End (m)"] - 0.0001) else v["Distance travelled per segment (m)"] Live Evaluation: [ROUTE: GRID] 0.1200 if 3.2425 == 0 else (3.4000 - 3.2425 if (3.2425 + 0.1200) > 3.4000 else 0.1200) if 3.2425 < (3.4000 - 0.0001) else (10.6000 - 3.2425 if (3.2425 + 0.1200) > 10.6000 else 0.1200) if 3.2425 < (10.6000 - 0.0001) else (13.4000 - 3.2425 if (3.2425 + 0.1200) > 13.4000 else 0.1200) if 3.2425 < (13.4000 - 0.0001) else (20.6000 - 3.2425 if (3.2425 + 0.1200) > 20.6000 else 0.1200) if 3.2425 < (20.6000 - 0.0001) else 0.1200 = 0.1200
☰	$ P_{trans} $	TAR Transformed Enabler Distance (m)	0.24	View Help Guide Purpose: Moving the TAR tracker forward by one step and executing our critical structural overshoot adjustment at the end of TAR 2 to keep the degrees perfect. Logic: Advances the TAR position while applying a highly specific ROUND check against RotZone2_End to forcefully snap the geometry back into alignment at the exact end of the rotation phase. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $P_{trans} = d_{track} + \Delta d_{ce} - R_{z2, end} if d_{track} + \Delta d_{ce} > R_{z2, end} else d_{track} + \Delta d_{ce}$ Python Logic: `v["TAR Distance on track (m)"] + v["Centre Enabler Difference (m)"] - v["RotZone2 End (m)"] if v["TAR Distance on track (m)"] + v["Centre Enabler Difference (m)"] > v["RotZone2 End (m)"] else v["TAR Distance on track (m)"] + v["Centre Enabler Difference (m)"]` Live Evaluation: [ROUTE: GRID] 0.1200 + 0.1200 - 20.6000 if 0.1200 + 0.1200 > 20.6000 else 0.1200 + 0.1200 = 0.2400
▼ 3. SPATIAL BLUEPRINTS - S2 E2 Cascade
☰	$ d_{track} $	Distance on track (m)	0.96	View Help Guide Purpose: Tracking where each individual enabler is on the physical track layout while making sure it resets cleanly to zero once it finishes a complete lap. Logic: Establishes the absolute zero starting point for the master train sequence in the simulation. Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque Mathematical Formula: $d_{track} = v_prev_seg["Transformed Enabler Distance (m)"]$ Python Logic: `v_prev_seg["Transformed Enabler Distance (m)"]` Live Evaluation: [ROUTE: GRID] 0.9554 = 0.9554
☰	$ d_{ce} $	Centre Enabler Distance (m)	3.24	View Help Guide Purpose: Pulling the exact track distance of the center enabler for the current segment to use as our master structural baseline. Logic: Uses SUMIFS to isolate the center enabler's position in this new time step. Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque Mathematical Formula: $d_{ce} = v_pred_{ce}$ Python Logic: `v_prev["Centre Enabler Distance (m)"]` Live Evaluation: [ROUTE: GRID] 3.2425 = 3.2425
☰	$ \Delta d_{ce} $	Centre Enabler Difference (m)	0.12	View Help Guide Purpose: Calculating the master spatial step size based directly on the velocity and track slant gear ratio. Logic: The Rigid Body Link: Inherits the dynamically calculated (and potentially boundary-shrunk) step size directly from S2E1 in the same time step, ensuring the train moves perfectly together. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $\Delta d_{ce} = v_pre\Delta d_{ce}$ Python Logic: `v_prev["Centre Enabler Difference (m)"]` Live Evaluation: [ROUTE: GRID] 0.1200 = 0.1200
☰	$ P_{trans} $	Transformed Enabler Distance (m)	1.08	View Help Guide Purpose: Figuring out the new position of the enabler after it takes a step, making sure it cleanly wraps around the finish line back to the start if it overshoots. Logic: Adds the S2E1 step size to the S1E2 time-shifted distance, maintaining the rigid-body gap and executing the lap-wrap check. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $P_{trans} = d_{track}+\Delta d_{ce}-L_{c2} if d_{track}+\Delta d_{ce}>L_{c2} else d_{track}+\Delta d_{ce}$ Python Logic: `v["Distance on track (m)"]+v["Centre Enabler Difference (m)"]-v["Physical End Corner2 (m)"] if v["Distance on track (m)"]+v["Centre Enabler Difference (m)"]>v["Physical End Corner2 (m)"] else v["Distance on track (m)"]+v["Centre Enabler Difference (m)"]` Live Evaluation: [ROUTE: GRID] 0.9554+0.1200-20.0000 if 0.9554+0.1200>20.0000 else 0.9554+0.1200 = 1.0754
☰	$ d_{track} $	TAR Distance on track (m)	0.96	View Help Guide Purpose: Establishing the baseline distance on the track specifically for the TAR sandbox calculations. Logic: Inherits the TAR Transformed position from the previous time step for this specific enabler, mirroring the master time transition cascade. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $d_{track} = v_prev_seg["TAR Transformed Enabler Distance (m)"]$ Python Logic: `v_prev_seg["TAR Transformed Enabler Distance (m)"]` Live Evaluation: [ROUTE: GRID] 0.9554 = 0.9554
☰	$ P_{TAR,ce} $	TAR Centre Enabler Distance (m)	3.24	View Help Guide Purpose: Isolating the exact position of the center enabler inside the TAR tracking loop to manage our process boundaries. Logic: Inherits the anchor position directly from S2E1, allowing the sandbox cascade to flow autonomously alongside the master track. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $P_{TAR,ce} = v_preP_{TAR,ce}$ Python Logic: `v_prev["TAR Centre Enabler Distance (m)"]` Live Evaluation: [ROUTE: GRID] 3.2425 = 3.2425
☰	$ \Delta d_{TAR} $	TAR Difference (m)	0.12	View Help Guide Purpose: Setting the step size for the TAR tracker, locking it perfectly in sync with our master track step. Logic: Uses the exact same Boundary Engine logic to calculate the step size for the sandbox, checking for RotZone intersections. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $\Delta d_{TAR} = v_pre\Delta d_{TAR}$ Python Logic: `v_prev["TAR Difference (m)"]` Live Evaluation: [ROUTE: GRID] 0.1200 = 0.1200
☰	$ P_{trans} $	TAR Transformed Enabler Distance (m)	1.08	View Help Guide Purpose: Moving the TAR tracker forward by one step and executing our critical structural overshoot adjustment at the end of TAR 2 to keep the degrees perfect. Logic: Advances the TAR position while applying a highly specific ROUND check against RotZone2_End to forcefully snap the geometry back into alignment at the exact end of the rotation phase. Type: Calculated (Math Output) Render on Grids: Spatial Mathematical Formula: $P_{trans} = d_{track} + \Delta d_{ce} - R_{z2, end} if d_{track} + \Delta d_{ce} > R_{z2, end} else d_{track} + \Delta d_{ce}$ Python Logic: `v["TAR Distance on track (m)"] + v["Centre Enabler Difference (m)"] - v["RotZone2 End (m)"] if v["TAR Distance on track (m)"] + v["Centre Enabler Difference (m)"] > v["RotZone2 End (m)"] else v["TAR Distance on track (m)"] + v["Centre Enabler Difference (m)"]` Live Evaluation: [ROUTE: GRID] 0.9554 + 0.1200 - 20.6000 if 0.9554 + 0.1200 > 20.6000 else 0.9554 + 0.1200 = 1.0754
▼ 2. MASTER SEQUENCE BLUEPRINTS - S1 E1 Base
☰	$ Rev $	Revolution		View Help Guide Purpose: The base revolution Logic: Calculates the revolution number increments based on the train completing a run across the full track length Type: Manual Entry Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $\text{User Input}$ Python Logic: `N/A` Live Evaluation: N/A (Input Variable)
☰	$ C $	Cycle		View Help Guide Purpose: Cycle 1 includes top straight track and right rounded corner, Cycle 2 includes bottom straight track and left rounded corner, repeated for cyclical observation Logic: Calculates the cycle based on TARs, cycle 1 is TAR 1 and cycle 2 is TAR 2 Type: Manual Entry Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $\text{User Input}$ Python Logic: `N/A` Live Evaluation: N/A (Input Variable)
☰	$ N_{seg} $	Segment Number		View Help Guide Purpose: Starting at 1, each segment will equal the arc degree + 1 / lift time of a second for operational performance analysis across chosen number of enablers Logic: Incrementally increases the segment numbers across the full operation of the machine Type: Manual Entry Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $\text{User Input}$ Python Logic: `N/A` Live Evaluation: N/A (Input Variable)
☰	$ N_{en} $	Enabler Number		View Help Guide Purpose: A row for each of the chosen number of gravity enablers in order Logic: Identifies the specific payload unit being tracked in this initialization row. Type: Manual Entry Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $\text{User Input}$ Python Logic: `N/A` Live Evaluation: N/A (Input Variable)
☰	$ P $	Position	Back (2)	View Help Guide Purpose: Determine position of enablers in the train, centre with back and front Logic: By identifying the correct position of an enabler the correct parallel force can be determined Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $P = 2 if N_{en}<(((N_{\text{enablers}}-1)/2)+1) else (1 if N_{en}==(((N_{\text{enablers}}-1)/2)+1) else 3)$ Python Logic: `2 if v["Enabler Number"]<(((v["Number of Gravity Enablers"]-1)/2)+1) else (1 if v["Enabler Number"]==(((v["Number of Gravity Enablers"]-1)/2)+1) else 3)` Live Evaluation: [ROUTE: GRID] 2 if 1.0000<(((7.0000-1)/2)+1) else (1 if 1.0000==(((7.0000-1)/2)+1) else 3) = 2.0000
☰	$ \theta_{slant} $	Track Slant (degree)	30.00	View Help Guide Purpose: Determines when the centre enabler is a certain distance from the centre of a rounded corner, at the given velocity, track arc rotations are excecuted. Logic: The Tilt State Machine: Evaluates if the master centre enabler is in a flat zone or rotation zone, dynamically incrementing or decrementing the track tilt angle frame-by-frame. Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $\theta_{slant} = \theta_{\text{tilt}}$ Python Logic: `v["Angle tilt (degrees)"]` Live Evaluation: [ROUTE: GRID] 30.0000 = 30.0000
☰	$ S_{track} $	Track Section	Straight Track (1)	View Help Guide Purpose: Determining if an enabler is on the straight part of the track with a constant torque, or in the rounded corner producing variable torque Logic: Evaluates the current distance against the physical track boundaries to tag the enabler as being on a "Straight Track" or "Rounded Corner". Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $S_{track} = 1 if d_{track}<=L_{s1} else (2 if d_{track}<L_{s2} else (1 if d_{track}<=L_{c1} else (2 if d_{track}<L_{c2} else 0)))$ Python Logic: `1 if v["Distance on track (m)"]<=v["Physical End Straight1 (m)"] else (2 if v["Distance on track (m)"]<v["Physical End Corner1 (m)"] else (1 if v["Distance on track (m)"]<=v["Physical End Straight2 (m)"] else (2 if v["Distance on track (m)"]<v["Physical End Corner2 (m)"] else 0)))` Live Evaluation: [ROUTE: GRID] 1 if 0.0000<=4.0000 else (2 if 0.0000<10.0000 else (1 if 0.0000<=14.0000 else (2 if 0.0000<20.0000 else 0))) = 1.0000
☰	$ \text{Status} $	Status	Idle (1)	View Help Guide Purpose: Idle = DLLS switched off Rotation = when centre enabler is 0.5 velocity distance from the centre of the rounded corner, rotation is activated over velocity distance for a track arc rotation from track slant degree to -track slant degree, or -track slant degree to track slant degree Logic: The operational state machine: Swaps the drive status between "Idle" and "Rotation" based on the Centre Enabler's proximity to the corner zones. Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $\text{Status} = 1 if d_{ce}< R_{z1, start} else 2 if d_{ce}<R_{z1, end} else 1 if d_{ce}<R_{z2, start}else 2 if d_{ce}<R_{z2, end} else 0$ Python Logic: `1 if v["Centre Enabler Distance (m)"]< v["RotZone1 Start (m)"] else 2 if v["Centre Enabler Distance (m)"]<v["RotZone1 End (m)"] else 1 if v["Centre Enabler Distance (m)"]<v["RotZone2 Start (m)"]else 2 if v["Centre Enabler Distance (m)"]<v["RotZone2 End (m)"] else 0` Live Evaluation: [ROUTE: GRID] 1 if 2.5061< 3.4000 else 2 if 2.5061<10.6000 else 1 if 2.5061<13.4000else 2 if 2.5061<20.6000 else 0 = 1.0000
▼ 2. MASTER SEQUENCE BLUEPRINTS - S1 E2 Loop
☰	$ Rev $	Revolution	1.00	View Help Guide Purpose: The base revolution Logic: Calculates the revolution number increments based on the train completing a run across the full track length Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $$$Rev = v_preRev$$$ Python Logic: `v_prev["Revolution"]` Live Evaluation: [ROUTE: GRID] 1.0000 = 1.0000
☰	$ C $	Cycle	1.00	View Help Guide Purpose: Cycle 1 in cludes top straight track and right rounded corner, Cycle 2 includes bottom straight track and left rounded corner, repeated for cyclical observation Logic: Calculates the cycle based on TARs, cycle 1 is TAR 1 and cycle 2 is TAR 2 Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $$$C = v_preC$$$ Python Logic: `v_prev["Cycle"]` Live Evaluation: [ROUTE: GRID] 1.0000 = 1.0000
☰	$ N_{seg} $	Segment Number	1.00	View Help Guide Purpose: Starting at 1, each segment will equal the arc degree + 1 / lift time of a second for operational performance analysis across chosen number of enablers Logic: Incrementally increases the segment numbers across the full operation of the machine Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $N_{seg} = v_preN_{seg}$ Python Logic: `v_prev["Segment Number"]` Live Evaluation: [ROUTE: GRID] 1.0000 = 1.0000
☰	$ N_{en} $	Enabler Number	2.00	View Help Guide Purpose: A row for each of the chosen number of gravity enablers in order Logic: Identifies the specific payload unit being tracked in this initialization row. Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $N_{en} = v_preN_{en}+1$ Python Logic: `v_prev["Enabler Number"]+1` Live Evaluation: [ROUTE: GRID] 1.0000+1 = 2.0000
☰	$ P $	Position	Back (2)	View Help Guide Purpose: Determine position of enablers in the train, centre with back and front Logic: By identifying the correct position of an enabler the correct parallel force can be determined Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $P = 2 if N_{en}<(((N_{\text{enablers}}-1)/2)+1) else 1 if N_{en}==(((N_{\text{enablers}}-1)/2)+1) else 3$ Python Logic: `2 if v["Enabler Number"]<(((v["Number of Gravity Enablers"]-1)/2)+1) else 1 if v["Enabler Number"]==(((v["Number of Gravity Enablers"]-1)/2)+1) else 3` Live Evaluation: [ROUTE: GRID] 2 if 2.0000<(((7.0000-1)/2)+1) else 1 if 2.0000==(((7.0000-1)/2)+1) else 3 = 2.0000
☰	$ \theta_{slant} $	Track Slant (degree)	30.00	View Help Guide Purpose: Determines when the centre enabler is a certain distance from the centre of a rounded corner, at the given velocity, track arc rotations are excecuted. Logic: The Tilt State Machine: Evaluates if the master centre enabler is in a flat zone or rotation zone, dynamically incrementing or decrementing the track tilt angle frame-by-frame. Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $\theta_{slant} = v_pre\theta_{slant}$ Python Logic: `v_prev["Track Slant (degree)"]` Live Evaluation: [ROUTE: GRID] 30.0000 = 30.0000
☰	$ S_{track} $	Track Section	Straight Track (1)	View Help Guide Purpose: Determining if an enabler is on the straight part of the track with a constant torque, or in the rounded corner producing variable torque. Logic: Evaluates the current distance against the physical track boundaries to tag the enabler as being on a "Straight Track" or "Rounded Corner". Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $S_{track} = 1 if d_{track}<=L_{s1} else 2 if d_{track}<L_{s2}else 1 if d_{track}<=L_{c1} else 2 if d_{track}<L_{c2} else 0$ Python Logic: `1 if v["Distance on track (m)"]<=v["Physical End Straight1 (m)"] else 2 if v["Distance on track (m)"]<v["Physical End Corner1 (m)"]else 1 if v["Distance on track (m)"]<=v["Physical End Straight2 (m)"] else 2 if v["Distance on track (m)"]<v["Physical End Corner2 (m)"] else 0` Live Evaluation: [ROUTE: GRID] 1 if 0.8354<=4.0000 else 2 if 0.8354<10.0000else 1 if 0.8354<=14.0000 else 2 if 0.8354<20.0000 else 0 = 1.0000
☰	$ \text{Status} $	Status	Idle (1)	View Help Guide Purpose: Idle = DLLS switched off Rotation = when centre enabler is 0.5 velocity distance from the centre of the rounded corner, rotation is activated over velocity distance for a track arc rotation from track slant degree to -track slant degree, or -track slant degree to track slant degree Logic: The operational state machine: Swaps the drive status between "Idle" and "Rotation" based on the Centre Enabler's proximity to the corner zones. Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $\text{Status} = v_pre\text{Status}$ Python Logic: `v_prev["Status"]` Live Evaluation: [ROUTE: GRID] 1.0000 = 1.0000
▼ 2. MASTER SEQUENCE BLUEPRINTS - S2 E1 Transition
☰	$ Rev $	Revolution	1.00	View Help Guide Purpose: The base revolution Logic: Calculates the revolution number increments based on the train completing a run across the full track length Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $Rev = v_prev_seg["Revolution"] + 1 if v_prev_seg["TAR Centre Enabler Distance (m)"] + L_{\text{seg}} >= ( R_{z2, end} - 0.001 ) else v_prev_seg["Revolution"]$ Python Logic: `v_prev_seg["Revolution"] + 1 if v_prev_seg["TAR Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"] >= ( v["RotZone2 End (m)"] - 0.001 ) else v_prev_seg["Revolution"]` Live Evaluation: [ROUTE: GRID] 1.0000 + 1 if 2.5061 + 0.1200 >= ( 20.6000 - 0.001 ) else 1.0000 = 1.0000
☰	$ C $	Cycle	1.00	View Help Guide Purpose: Cycle 1 in cludes top straight track and right rounded corner, Cycle 2 includes bottom straight track and left rounded corner, repeated for cyclical observation Logic: Calculates the cycle based on TARs, cycle 1 is TAR 1 and cycle 2 is TAR 2 Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $C = 1 if P_{TAR,ce}<R_{z1, end}else 2 if P_{TAR,ce}<R_{z2, end} else 0$ Python Logic: `1 if v["TAR Centre Enabler Distance (m)"]<v["RotZone1 End (m)"]else 2 if v["TAR Centre Enabler Distance (m)"]<v["RotZone2 End (m)"] else 0` Live Evaluation: [ROUTE: GRID] 1 if 3.2425<10.6000else 2 if 3.2425<20.6000 else 0 = 1.0000
☰	$ N_{seg} $	Segment Number	2.00	View Help Guide Purpose: Starting at 1, each segment will equal the arc degree + 1 / lift time of a second for operational performance analysis across chosen number of enablers Logic: Incrementally increases the segment numbers across the full operation of the machine Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $N_{seg} = v_preN_{seg}+1$ Python Logic: `v_prev["Segment Number"]+1` Live Evaluation: [ROUTE: GRID] 1.0000+1 = 2.0000
☰	$ N_{en} $	Enabler Number	1.00	View Help Guide Purpose: A row for each of the chosen number of gravity enablers in order Logic: Identifies the specific payload unit being tracked in this initialization row. Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $N_{en} = v_prev_seg["Enabler Number"]$ Python Logic: `v_prev_seg["Enabler Number"]` Live Evaluation: [ROUTE: GRID] 1.0000 = 1.0000
☰	$ P $	Position	Back (2)	View Help Guide Purpose: Determine position of enablers in the train, centre with back and front Logic: By identifying the correct position of an enabler the correct parallel force can be determined Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $$$P = v_prev_seg["Position"]$$$ Python Logic: `v_prev_seg["Position"]` Live Evaluation: [ROUTE: GRID] 2.0000 = 2.0000
☰	$ \theta_{slant} $	Track Slant (degree)	30.00	View Help Guide Purpose: Determines when the centre enabler is a certain distance from the centre of a rounded corner, at the given velocity, track arc rotations are excecuted. Logic: The Tilt State Machine: Evaluates if the master centre enabler is in a flat zone or rotation zone, dynamically incrementing or decrementing the track tilt angle frame-by-frame. Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $\theta_{slant} = \theta_{\text{tilt}} if P_{TAR,ce} <= R_{z1, start} else (v_prev_seg["Track Slant (degree)"] - 1 if P_{TAR,ce} < R_{z1, end} else (-\theta_{\text{tilt}} if P_{TAR,ce} <= R_{z2, start} else (v_prev_seg["Track Slant (degree)"] + 1 if P_{TAR,ce} < R_{z2, end} else 0)))$ Python Logic: `v["Angle tilt (degrees)"] if v["TAR Centre Enabler Distance (m)"] <= v["RotZone1 Start (m)"] else (v_prev_seg["Track Slant (degree)"] - 1 if v["TAR Centre Enabler Distance (m)"] < v["RotZone1 End (m)"] else (-v["Angle tilt (degrees)"] if v["TAR Centre Enabler Distance (m)"] <= v["RotZone2 Start (m)"] else (v_prev_seg["Track Slant (degree)"] + 1 if v["TAR Centre Enabler Distance (m)"] < v["RotZone2 End (m)"] else 0)))` Live Evaluation: [ROUTE: GRID] 30.0000 if 3.2425 <= 3.4000 else (30.0000 - 1 if 3.2425 < 10.6000 else (-30.0000 if 3.2425 <= 13.4000 else (30.0000 + 1 if 3.2425 < 20.6000 else 0))) = 30.0000
☰	$ S_{track} $	Track Section	Straight Track (1)	View Help Guide Purpose: Determining if an enabler is on the straight part of the track with a constant torque, or in the rounded corner producing variable torque Logic: Evaluates the current distance against the physical track boundaries to tag the enabler as being on a "Straight Track" or "Rounded Corner". Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $S_{track} = 1 if d_{track}<=L_{s1} else 2 if d_{track}<L_{s2} else 1 if d_{track}<=L_{c1} else 2 if d_{track}<L_{c2} else 0$ Python Logic: `1 if v["Distance on track (m)"]<=v["Physical End Straight1 (m)"] else 2 if v["Distance on track (m)"]<v["Physical End Corner1 (m)"] else 1 if v["Distance on track (m)"]<=v["Physical End Straight2 (m)"] else 2 if v["Distance on track (m)"]<v["Physical End Corner2 (m)"] else 0` Live Evaluation: [ROUTE: GRID] 1 if 0.1200<=4.0000 else 2 if 0.1200<10.0000 else 1 if 0.1200<=14.0000 else 2 if 0.1200<20.0000 else 0 = 1.0000
☰	$ \text{Status} $	Status	Idle (1)	View Help Guide Purpose: Idle = DLLS switched off Rotation = when centre enabler is 0.5 velocity distance from the centre of the rounded corner, rotation is activated over velocity distance for a track arc rotation from track slant degree to -track slant degree, or -track slant degree to track slant degree Logic: The operational state machine: Swaps the drive status between "Idle" and "Rotation" based on the Centre Enabler's proximity to the corner zones. Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $\text{Status} = 1 if d_{ce} < R_{z1, start} - 0.001 else (2 if d_{ce} < R_{z1, end} - 0.001 else (1 if d_{ce} < R_{z2, start} - 0.001 else (2 if d_{ce} < (R_{z2, end} - 0.001) else 1)))$ Python Logic: `1 if v["Centre Enabler Distance (m)"] < v["RotZone1 Start (m)"] - 0.001 else (2 if v["Centre Enabler Distance (m)"] < v["RotZone1 End (m)"] - 0.001 else (1 if v["Centre Enabler Distance (m)"] < v["RotZone2 Start (m)"] - 0.001 else (2 if v["Centre Enabler Distance (m)"] < (v["RotZone2 End (m)"] - 0.001) else 1)))` Live Evaluation: [ROUTE: GRID] 1 if 3.2425 < 3.4000 - 0.001 else (2 if 3.2425 < 10.6000 - 0.001 else (1 if 3.2425 < 13.4000 - 0.001 else (2 if 3.2425 < (20.6000 - 0.001) else 1))) = 1.0000
▼ 2. MASTER SEQUENCE BLUEPRINTS - S2 E2 Cascade
☰	$ Rev $	Revolution	1.00	View Help Guide Purpose: The base revolution Logic: Calculates the revolution number increments based on the train completing a run across the full track length Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $$$Rev = v_preRev$$$ Python Logic: `v_prev["Revolution"]` Live Evaluation: [ROUTE: GRID] 1.0000 = 1.0000
☰	$ C $	Cycle	1.00	View Help Guide Purpose: Cycle 1 includes top straight track and right rounded corner, Cycle 2 includes bottom straight track and left rounded corner, repeated for cyclical observation Logic: Calculates the cycle based on TARs, cycle 1 is TAR 1 and cycle 2 is TAR 2 Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $$$C = v_preC$$$ Python Logic: `v_prev["Cycle"]` Live Evaluation: [ROUTE: GRID] 1.0000 = 1.0000
☰	$ N_{seg} $	Segment Number	2.00	View Help Guide Purpose: Starting at 1, each segment will equal the arc degree + 1 / lift time of a second for operational performance analysis across chosen number of enablers Logic: Incrementally increases the segment numbers across the full operation of the machine Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $N_{seg} = v_preN_{seg}$ Python Logic: `v_prev["Segment Number"]` Live Evaluation: [ROUTE: GRID] 2.0000 = 2.0000
☰	$ N_{en} $	Enabler Number	2.00	View Help Guide Purpose: A row for each of the chosen number of gravity enablers in order Logic: Identifies the specific payload unit being tracked in this initialization row. Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $N_{en} = v_prev_seg["Enabler Number"]$ Python Logic: `v_prev_seg["Enabler Number"]` Live Evaluation: [ROUTE: GRID] 2.0000 = 2.0000
☰	$ P $	Position	Back (2)	View Help Guide Purpose: Determine position of enablers in the train, centre with back and front Logic: By identifying the correct position of an enabler the correct parallel force can be determined Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $$$P = v_prev_seg["Position"]$$$ Python Logic: `v_prev_seg["Position"]` Live Evaluation: [ROUTE: GRID] 2.0000 = 2.0000
☰	$ \theta_{slant} $	Track Slant (degree)	30.00	View Help Guide Purpose: Determines when the centre enabler is a certain distance from the centre of a rounded corner, at the given velocity, track arc rotations are excecuted. Logic: The Tilt State Machine: Evaluates if the master centre enabler is in a flat zone or rotation zone, dynamically incrementing or decrementing the track tilt angle frame-by-frame. Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $\theta_{slant} = v_pre\theta_{slant}$ Python Logic: `v_prev["Track Slant (degree)"]` Live Evaluation: [ROUTE: GRID] 30.0000 = 30.0000
☰	$ S_{track} $	Track Section	Straight Track (1)	View Help Guide Purpose: Determining if an enabler is on the straight part of the track with a constant torque, or in the rounded corner producing variable torque Logic: Evaluates the current distance against the physical track boundaries to tag the enabler as being on a "Straight Track" or "Rounded Corner". Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $S_{track} = 1 if d_{track}<=L_{s1} else 2 if d_{track}<L_{s2} else 1 if d_{track}<=L_{c1} else 2 if d_{track}<L_{c2} else 0$ Python Logic: `1 if v["Distance on track (m)"]<=v["Physical End Straight1 (m)"] else 2 if v["Distance on track (m)"]<v["Physical End Corner1 (m)"] else 1 if v["Distance on track (m)"]<=v["Physical End Straight2 (m)"] else 2 if v["Distance on track (m)"]<v["Physical End Corner2 (m)"] else 0` Live Evaluation: [ROUTE: GRID] 1 if 0.9554<=4.0000 else 2 if 0.9554<10.0000 else 1 if 0.9554<=14.0000 else 2 if 0.9554<20.0000 else 0 = 1.0000
☰	$ \text{Status} $	Status	Idle (1)	View Help Guide Purpose: Idle = DLLS switched off Rotation = when centre enabler is 0.5 velocity distance from the centre of the rounded corner, rotation is activated over velocity distance for a track arc rotation from track slant degree to -track slant degree, or -track slant degree to track slant degree Logic: The operational state machine: Swaps the drive status between "Idle" and "Rotation" based on the Centre Enabler's proximity to the corner zones. Type: Calculated (Math Output) Render on Grids: Spatial, Rotational Torque, Energy Balance, Operational Totals Mathematical Formula: $\text{Status} = v_pre\text{Status}$ Python Logic: `v_prev["Status"]` Live Evaluation: [ROUTE: GRID] 1.0000 = 1.0000
▼ 4. ROTATIONAL TORQUE BLUEPRINTS - S1 E1 Base
☰	$ P_{circ} $	Enabler Circumference Distance (m)	0.00	View Help Guide Purpose: Determines distance travelled by a gravity enabler on the rounded corner Logic: (v["Distance on track (m)"] - v["Physical End Straight1 (m)"] if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else v["Distance on track (m)"] - v["Physical End Straight2 (m)"]) if v["Track Section"] == 2 else 0 Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $P_{circ} = IF(S_{track}==2,IF(d_{track}<L_{s2},d_{track}-L_{s1},d_{track}-L_{c1}),0)$ Python Logic: `(v["Distance on track (m)"] - v["Physical End Straight1 (m)"] if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else v["Distance on track (m)"] - v["Physical End Straight2 (m)"]) if v["Track Section"] == 2 else 0` Live Evaluation: [ROUTE: GRID] (0.0000 - 4.0000 if 0.0000 < 10.0000 else 0.0000 - 14.0000) if 1.0000 == 2 else 0 = 0.0000
☰	$ \alpha $	Enabler Circumference Angle (degree)	0.00	View Help Guide Purpose: The rounded corner enabler position angle Logic: Converts the curved distance travelled into an exact geometric angle around the gear hub. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\alpha = \text{deg}(P_{circ}/r_{gear})$ Python Logic: `DEGREES(v["Enabler Circumference Distance (m)"]/v["Internal Gear Radius (m)"])` Live Evaluation: [ROUTE: GRID] DEGREES(0.0000/1.9099) = 0.0000
☰	$ \theta_{eff,static} $	Static Effective Angle for parallel force (degree)	30.00	View Help Guide Purpose: Intermediate calculation for Effective Angle considering the track slant Logic: v["Track Slant (degree)"] if v["Enabler Circumference Angle (degree)"] == 0 else v["Track Slant (degree)"] + v["Enabler Circumference Angle (degree)"] Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\theta_{eff,static} = IF(\alpha==0,\theta_{slant},\theta_{slant}+\alpha)$ Python Logic: `v["Track Slant (degree)"] if v["Enabler Circumference Angle (degree)"] == 0 else v["Track Slant (degree)"] + v["Enabler Circumference Angle (degree)"]` Live Evaluation: [ROUTE: GRID] 30.0000 if 0.0000 == 0 else 30.0000 + 0.0000 = 30.0000
☰	$ \theta_{eff} $	Effective Angle for Parallel Force (degree)	30.00	View Help Guide Purpose: Determinging the correct effective parallel force angle based on the geometry of the GMEG design Logic: abs(v["Track Slant (degree)"]) if v["Track Section"] == 1 else ((v["Static Effective Angle for parallel force (degree)"] if v["Static Effective Angle for parallel force (degree)"] < 90 else 180 - v["Static Effective Angle for parallel force (degree)"]) if v["Cycle"] == 1 else -(v["Static Effective Angle for parallel force (degree)"] if v["Static Effective Angle for parallel force (degree)"] < 90 else 180 - v["Static Effective Angle for parallel force (degree)"])) Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\theta_{eff} = IF(S_{track} == 1, abs(\theta_{slant}), IF(C == 1, IF(\theta_{eff,static} < 90, \theta_{eff,static}, 180 - \theta_{eff,static}), -IF(\theta_{eff,static} < 90, \theta_{eff,static}, 180 - \theta_{eff,static})))$ Python Logic: `abs(v["Track Slant (degree)"]) if v["Track Section"] == 1 else ((v["Static Effective Angle for parallel force (degree)"] if v["Static Effective Angle for parallel force (degree)"] < 90 else 180 - v["Static Effective Angle for parallel force (degree)"]) if v["Cycle"] == 1 else -(v["Static Effective Angle for parallel force (degree)"] if v["Static Effective Angle for parallel force (degree)"] < 90 else 180 - v["Static Effective Angle for parallel force (degree)"]))` Live Evaluation: [ROUTE: GRID] abs(30.0000) if 1.0000 == 1 else ((30.0000 if 30.0000 < 90 else 180 - 30.0000) if 1.0000 == 1 else -(30.0000 if 30.0000 < 90 else 180 - 30.0000)) = 30.0000
☰	$ X_{flat} $	X flat (m)	-2.00	View Help Guide Purpose: Horizontal position with the track in a horizontal position Logic: (v["Distance on track (m)"] - (v["Straight track length (m)"] / 2) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else (v["Straight track length (m)"] / 2) - (v["Distance on track (m)"] - v["Physical End Corner1 (m)"])) if v["Track Section"] == 1 else ((v["Straight track length (m)"] / 2) + (v["Internal Gear Radius (m)"] * __import__("math").sin(__import__("math").radians(v["Enabler Circumference Angle (degree)"]))) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -(v["Straight track length (m)"] / 2) - (v["Internal Gear Radius (m)"] * __import__("math").sin(__import__("math").radians(v["Enabler Circumference Angle (degree)"])))) Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $X_{flat} = IF(S_{track}==1, IF(d_{track}<L_{s2}, d_{track}-(L_{\text{straight}}/2),(L_{\text{straight}}/2)-(d_{track}-L_{s2})), IF(d_{track}<L_{s2}, (L_{\text{straight}}/2)+(r_{gear} \times \sin(\text{rad}(\alpha))),-(L_{\text{straight}}/2)-(r_{gear} \times \sin(\text{rad}(\alpha)))))$ Python Logic: (v["Distance on track (m)"] - (v["Straight track length (m)"] / 2) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else (v["Straight track length (m)"] / 2) - (v["Distance on track (m)"] - v["Physical End Corner1 (m)"])) if v["Track Section"] == 1 else ((v["Straight track length (m)"] / 2) + (v["Internal Gear Radius (m)"] * __import__("math").sin(__import__("math").radians(v["Enabler Circumference Angle (degree)"]))) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -(v["Straight track length (m)"] / 2) - (v["Internal Gear Radius (m)"] * __import__("math").sin(__import__("math").radians(v["Enabler Circumference Angle (degree)"])))) Live Evaluation: [ROUTE: GRID] (0.0000 - (4.0000 / 2) if 0.0000 < 10.0000 else (4.0000 / 2) - (0.0000 - 10.0000)) if 1.0000 == 1 else ((4.0000 / 2) + (1.9099 * __import__("math").sin(__import__("math").radians(0.0000))) if 0.0000 < 10.0000 else -(4.0000 / 2) - (1.9099 * __import__("math").sin(__import__("math").radians(0.0000)))) = -2.0000
☰	$ Y_{flat} $	Y flat (m)	1.91	View Help Guide Purpose: Vertical position with the track in a horizontal position Logic: (v["Internal Gear Radius (m)"] if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -v["Internal Gear Radius (m)"]) if v["Track Section"] == 1 else (v["Internal Gear Radius (m)"] * __import__("math").cos(__import__("math").radians(v["Enabler Circumference Angle (degree)"])) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -v["Internal Gear Radius (m)"] * __import__("math").cos(__import__("math").radians(v["Enabler Circumference Angle (degree)"]))) Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $Y_{flat} = IF(S_{track}==1, IF(d_{track}<L_{s2},r_{gear},-r_{gear}), IF(d_{track}<L_{s2},r_{gear} \times \cos(\text{rad}(\alpha)),-r_{gear} \times \cos(\text{rad}(\alpha))))$ Python Logic: `(v["Internal Gear Radius (m)"] if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -v["Internal Gear Radius (m)"]) if v["Track Section"] == 1 else (v["Internal Gear Radius (m)"] * __import__("math").cos(__import__("math").radians(v["Enabler Circumference Angle (degree)"])) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -v["Internal Gear Radius (m)"] * __import__("math").cos(__import__("math").radians(v["Enabler Circumference Angle (degree)"])))` Live Evaluation: [ROUTE: GRID] (1.9099 if 0.0000 < 10.0000 else -1.9099) if 1.0000 == 1 else (1.9099 * __import__("math").cos(__import__("math").radians(0.0000)) if 0.0000 < 10.0000 else -1.9099 * __import__("math").cos(__import__("math").radians(0.0000))) = 1.9099
☰	$ X_{final} $	Horizontal Distance X final (m)	-0.78	View Help Guide Purpose: Horizontal position taking track slant into account Logic: Applies a 2D rotational matrix to the flat X/Y coordinates based on the track slant degree to find the true horizontal position in 3D space. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $X_{final} = (X_{flat} \times \cos(\text{rad}(-\theta_{slant})))-(Y_{flat} \times \sin(\text{rad}(-\theta_{slant})))$ Python Logic: `(v["X flat (m)"]COS(RADIANS(-v["Track Slant (degree)"])))-(v["Y flat (m)"]SIN(RADIANS(-v["Track Slant (degree)"])))` Live Evaluation: [ROUTE: GRID] (-2.0000COS(RADIANS(-30.0000)))-(1.9099SIN(RADIANS(-30.0000))) = -0.7771
☰	$ X_{\text{min, lever}} $	Min Lever Arm (m)	0.00	View Help Guide Purpose: None Logic: None Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $X_{\text{min, lever}} = IF ( \text{Status} ==1, 0, X_{final} )$ Python Logic: `IF ( v["Status"] ==1, 0, v["Horizontal Distance X final (m)"] )` Live Evaluation: [ROUTE: GRID] IF ( 1.0000 ==1, 0, -0.7771 ) = 0.0000
☰	$ X_{\text{max, lever}} $	Max Lever Arm (m)	0.00	View Help Guide Purpose: None Logic: None Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $X_{\text{max, lever}} = IF ( \text{Status} == 1, 0, X_{final} )$ Python Logic: `IF ( v["Status"] == 1, 0, v["Horizontal Distance X final (m)"] )` Live Evaluation: [ROUTE: GRID] IF ( 1.0000 == 1, 0, -0.7771 ) = 0.0000
☰	$ Y_{final} $	Vertical Distance Y final (m)	2.65	View Help Guide Purpose: Vertical position taking track slant into accovnt Logic: Applies the secondary rotational matrix formula to find the true vertical position of the enabler as the track tilts. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $Y_{final} = (X_{flat} \times \sin(\text{rad}(-\theta_{slant})))+(Y_{flat} \times \cos(\text{rad}(-\theta_{slant})))$ Python Logic: `(v["X flat (m)"]SIN(RADIANS(-v["Track Slant (degree)"])))+(v["Y flat (m)"]COS(RADIANS(-v["Track Slant (degree)"])))` Live Evaluation: [ROUTE: GRID] (-2.0000SIN(RADIANS(-30.0000)))+(1.9099COS(RADIANS(-30.0000))) = 2.6540
☰	$ F_g $	Gravitational Force Fg (N)	437,245.71	View Help Guide Purpose: Determining the gravitational force of each enabler for energy calculations Logic: Calculates standard downward force (Fg = mg) based on the combined mass of the enabler and its holder. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $F_g = (M_{\text{unit}}+M_{\text{holder}}) \times N$ Python Logic: `(v["Weight per gravity enabler (kg)"]+v["Gravity enabler holder weight (kg)"])v["Gravitational Field Strength (N/kg)"]` Live Evaluation:* [ROUTE: GRID] (5571.4286+39000.0000)*9.8100 = 437,245.7143
☰	$ E_p $	Gravitational Potential Energy GPE per Enabler (J)	126,985.24	View Help Guide Purpose: The total gravitational potential energy of each enabler taking the GMEG system inefficiencies into account Logic: Calculates standard potential energy (Ep = mgh) and cascades it through the mechanical efficiency multipliers (gear losses, bearing friction, etc.). Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $E_p = ((((M_{\text{unit}} \times N \times Y_{final}) \times \eta_{\text{gear}}) \times \eta_{\text{bearing}}) \times (1-\mu))$ Python Logic: `((((v["Weight per gravity enabler (kg)"]v["Gravitational Field Strength (N/kg)"]v["Vertical Distance Y final (m)"])v["Gear efficiency (%)"])v["Bearing efficiency friction factor (%)"])(1-v["Friction factor (%)"]))` Live Evaluation:* [ROUTE: GRID] ((((5571.42869.81002.6540)0.9500)0.9700)*(1-0.0500)) = 126,985.2444
☰	$ \Sigma E_{\text{gpe, enablers}} $	Total Gravitational Potential Energy GPE of all Enablers (J)	126,985.24	View Help Guide Purpose: The sum of the total gravitational potential energy of all enablers taking the GMEG system inefficiencies into account. Logic: Calculates standard potential energy of teh train (Ep = mgh) and cascades it through the mechanical efficiency multipliers (gear losses, bearing friction, etc.). Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\Sigma E_{\text{gpe, enablers}} = E_p$ Python Logic: `v["Gravitational Potential Energy GPE per Enabler (J)"]` Live Evaluation: [ROUTE: GRID] 126985.2444 = 126,985.2444
☰	$ F_p $	GMEG Parallel Force Fp (N)	218,622.86	View Help Guide Purpose: Enabler parallel force taking the parallel angle into account Logic: Resolves the downward gravitational vector into the actual driving force acting parallel to the track using Fp = Fg sin(Effective Angle). Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $F_p = F_g \times \sin(\text{rad}(\theta_{eff}))$ Python Logic: `v["Gravitational Force Fg (N)"]SIN(RADIANS(v["Effective Angle for Parallel Force (degree)"]))` Live Evaluation:* [ROUTE: GRID] 437245.7143*SIN(RADIANS(30.0000)) = 218,622.8571
☰	$ m_{en,p} $	Parallel mass per Enabler (kg)	22,285.71	View Help Guide Purpose: Quantifies the exact portion of the enabler's physical mass that is actively contributing to the downward drive. Logic: Multiplies the total enabler mass (unit + holder) by the sine of its effective angle to isolate the parallel mass vector. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $m_{en,p} = F_p/N$ Python Logic: `v["GMEG Parallel Force Fp (N)"]/v["Gravitational Field Strength (N/kg)"]` Live Evaluation: [ROUTE: GRID] 218622.8571/9.8100 = 22,285.7143
☰	$ \tau_{GMEG} $	GMEG Nm Output (Nm)	417,538.90	View Help Guide Purpose: Enabler torque delivery based on internal gear radius Logic: Calculates the instantaneous rotational torque produced by this specific enabler by multiplying the parallel force by the lever arm (radius). Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\tau_{GMEG} = F_p \times r_{gear}$ Python Logic: `v["GMEG Parallel Force Fp (N)"]v["Internal Gear Radius (m)"]` Live Evaluation:* [ROUTE: GRID] 218622.8571*1.9099 = 417,538.9006
☰	$ \eta_{\text{op}} $	Operational Efficiency (%)	0.89	View Help Guide Purpose: Torque delivery based on adjustable user efficiency setting Logic: Applies the baseline mechanical loss/friction coefficient to the system. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\eta_{\text{GMEG}}$ Python Logic: `v["GMEG Efficiency (%)"]` Live Evaluation: [ROUTE: GRID] 0.8884 = 0.8884
☰	$ \tau_{GMEG,final} $	Final GMEG Output (Nm)	370,941.56	View Help Guide Purpose: Enabler torque delivery based on operational inefficiency Logic: The net, real-world usable torque generated by this single enabler after losses. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\tau_{GMEG,final} = \tau_{GMEG} \times \eta_{loss}$ Python Logic: `v["GMEG Nm Output (Nm)"]* v["Operational Efficiency (%)"]` Live Evaluation: [ROUTE: GRID] 417538.9006* 0.8884 = 370,941.5593
☰	$ \Sigma\tau_{GMEG} $	Total GMEG Output per Segment (Nm)	370,941.56	View Help Guide Purpose: Total potential torque delivery of the total train with all enablers in the segment Logic: v["Final GMEG Output (Nm)"] if v["Enabler Number"] == 1 else v_prev["Total GMEG Output per Segment (Nm)"] + v["Final GMEG Output (Nm)"] Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\Sigma\tau_{GMEG} = IF(N_{en} == 1, \tau_{GMEG,final}, v_pre\Sigma\tau_{GMEG} + \tau_{GMEG,final})$ Python Logic: `v["Final GMEG Output (Nm)"] if v["Enabler Number"] == 1 else v_prev["Total GMEG Output per Segment (Nm)"] + v["Final GMEG Output (Nm)"]` Live Evaluation: [ROUTE: GRID] 370941.5593 if 1.0000 == 1 else 0.0000 + 370941.5593 = 370,941.5593
☰	$ \tau_{def} $	Torque Deficit (Nm)	29,118.91	View Help Guide Purpose: Total torque delivery from the gravity enabler train minus the base load torque delivery requirement Logic: Compares the generated torque against the required load to identify structural power shortages. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\tau_{def} = \tau_{GMEG,final}-(\tau_{\text{out}}/N_{\text{enablers}})$ Python Logic: `v["Final GMEG Output (Nm)"]-(v["GMEG Output Torque (Nm)"]/v["Number of Gravity Enablers"])` Live Evaluation: [ROUTE: GRID] 370941.5593-(2392758.5285/7.0000) = 29,118.9124
☰	$ \Sigma \tau_{\text{deficit}} $	Total Torque Deficit (Nm)	29,118.91	View Help Guide Purpose: Accounting for where negative values may influence total torque deficit Logic: Aggregates the generated torque against the required load to identify structural power shortages. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\tau_{def}$ Python Logic: `v["Torque Deficit (Nm)"]` Live Evaluation: [ROUTE: GRID] 29118.9124 = 29,118.9124
☰	$ \tau_{gear} $	Gear System Torque (Nm)	0.00	View Help Guide Purpose: Torque experienced by the DLLS per enabler during rotation cycles Logic: 0 if v["Status"] == 1 else v["Horizontal Distance X final (m)"] * v["Gravitational Force Fg (N)"] Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\tau_{gear} = IF(\text{Status}==1,0,X_{final} \times F_g)$ Python Logic: `0 if v["Status"] == 1 else v["Horizontal Distance X final (m)"] * v["Gravitational Force Fg (N)"]` Live Evaluation: [ROUTE: GRID] 0 if 1.0000 == 1 else -0.7771 * 437245.7143 = 0.0000
☰	$ \tau $	Absolute Gear System Torque (Nm)	0.00	View Help Guide Purpose: Absolute values to represent positive values for torque experienced by the DLLS Logic: 0 if v["Status"] == 1 else abs(v["Gear System Torque (Nm)"]) Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $` = IF(\text{Status}==1,0,ABS(\tau_{gear}))$ Python Logic: `0 if v["Status"] == 1 else abs(v["Gear System Torque (Nm)"])` Live Evaluation: [ROUTE: GRID] 0 if 1.0000 == 1 else abs(0.0000) = 0.0000
☰	$ \tau_{gear,train} $	Enabler train Absolute Gear System Torque (Nm)	0.00	View Help Guide Purpose: 0 Logic: Sums the absolute torque across all enablers to find the total stress on the rotation gears for this time step. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\tau_{gear,train} = `$ Python Logic: `v["Absolute Gear System Torque (Nm)"]` Live Evaluation: [ROUTE: GRID] 0.0000 = 0.0000
☰	$ W_{DLLS} $	Work Done by DLLS Joule per Segment (J)	0.00	View Help Guide Purpose: Work done by the DLLS for that segment time frame, based on the angle per segment Logic: 0 if v["Status"] == 1 else v["Absolute Gear System Torque (Nm)"] * v["Angle Per Segment radians (rad/s)"] Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $W_{DLLS} = IF(\text{Status}==1,0,` \times \text{Angle Per Segment radians (rad/s)})$ Python Logic: `0 if v["Status"] == 1 else v["Absolute Gear System Torque (Nm)"] * v["Angle Per Segment radians (rad/s)"]` Live Evaluation: [ROUTE: GRID] 0 if 1.0000 == 1 else 0.0000 * 0.0175 = 0.0000
☰	$ TW_{DLLS} $	Total Work Done by DLLS Joule per Segment (J)	0.00	View Help Guide Purpose: Count of the required work impacting the DLLS during a TAR Logic: Aggregates the rotational torque across the train during the rotation phase. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $TW_{DLLS} = W_{DLLS}$ Python Logic: `v["Work Done by DLLS Joule per Segment (J)"]` Live Evaluation: [ROUTE: GRID] 0.0000 = 0.0000
☰	$ I_{en} $	Moment of inertia per enabler (kg.m2)	0.00	View Help Guide Purpose: Modelling inertia during a track arc rotation based on each enablers' position on the track Logic: 0 if v["Status"] == 1 else ((v["TOTAL WEIGHT (KG)"] / v["Number of Gravity Enablers"]) * (v["Horizontal Distance X final (m)"] 2)) Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $I_{en} = IF(\text{Status}==1,0,((M_{\text{total}}/N_{\text{enablers}}) \times (X_{final}^2)))$ Python Logic:** `0 if v["Status"] == 1 else ((v["TOTAL WEIGHT (KG)"] / v["Number of Gravity Enablers"]) * (v["Horizontal Distance X final (m)"] 2))` Live Evaluation:** [ROUTE: GRID] 0 if 1.0000 == 1 else ((312000.0000 / 7.0000) * (-0.7771 ** 2)) = 0.0000
☰	$ I_{train} $	Enabler train Moment of inertia (kg.m2)	0.00	View Help Guide Purpose: Running total inertia based on all enablers Logic: Aggregates the individual inertia values to find the total resistance the system must overcome to swivel the track. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $I_{train} = I_{en}$ Python Logic: `v["Moment of inertia per enabler (kg.m2)"]` Live Evaluation: [ROUTE: GRID] 0.0000 = 0.0000
▼ 4. ROTATIONAL TORQUE BLUEPRINTS - S1 E2 Loop
☰	$ P_{circ} $	Enabler Circumference Distance (m)	0.00	View Help Guide Purpose: Determines distance travelled by a gravity enabler on the rounded corner Logic: (v["Distance on track (m)"] - v["Physical End Straight1 (m)"] if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else v["Distance on track (m)"] - v["Physical End Straight2 (m)"]) if v["Track Section"] == 2 else 0 Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $P_{circ} = IF(S_{track}==2, IF(d_{track}<L_{s2},d_{track}-L_{s1},d_{track}-L_{c1}), 0)$ Python Logic: `(v["Distance on track (m)"] - v["Physical End Straight1 (m)"] if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else v["Distance on track (m)"] - v["Physical End Straight2 (m)"]) if v["Track Section"] == 2 else 0` Live Evaluation: [ROUTE: GRID] (0.8354 - 4.0000 if 0.8354 < 10.0000 else 0.8354 - 14.0000) if 1.0000 == 2 else 0 = 0.0000
☰	$ \alpha $	Enabler Circumference Angle (degree)	0.00	View Help Guide Purpose: The rounded corner enabler position angle Logic: Converts the curved distance travelled into an exact geometric angle around the gear hub. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\alpha = \text{deg}(P_{circ}/r_{gear})$ Python Logic: `DEGREES(v["Enabler Circumference Distance (m)"]/v["Internal Gear Radius (m)"])` Live Evaluation: [ROUTE: GRID] DEGREES(0.0000/1.9099) = 0.0000
☰	$ \theta_{eff,static} $	Static Effective Angle for parallel force (degree)	30.00	View Help Guide Purpose: Intermediate calculation for Effective Angle considering the track slant Logic: v["Track Slant (degree)"] if v["Enabler Circumference Angle (degree)"] == 0 else v["Track Slant (degree)"] + v["Enabler Circumference Angle (degree)"] Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\theta_{eff,static} = IF(\alpha==0,\theta_{slant},\theta_{slant}+\alpha)$ Python Logic: `v["Track Slant (degree)"] if v["Enabler Circumference Angle (degree)"] == 0 else v["Track Slant (degree)"] + v["Enabler Circumference Angle (degree)"]` Live Evaluation: [ROUTE: GRID] 30.0000 if 0.0000 == 0 else 30.0000 + 0.0000 = 30.0000
☰	$ \theta_{eff} $	Effective Angle for Parallel Force (degree)	30.00	View Help Guide Purpose: Determinging the correct effective parallel force angle based on the geometry of the GMEG design Logic: abs(v["Track Slant (degree)"]) if v["Track Section"] == 1 else ((v["Static Effective Angle for parallel force (degree)"] if v["Static Effective Angle for parallel force (degree)"] < 90 else 180 - v["Static Effective Angle for parallel force (degree)"]) if v["Cycle"] == 1 else -(v["Static Effective Angle for parallel force (degree)"] if v["Static Effective Angle for parallel force (degree)"] < 90 else 180 - v["Static Effective Angle for parallel force (degree)"])) Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\theta_{eff} = IF(S_{track} == 1, abs(\theta_{slant}), IF(C == 1, IF(\theta_{eff,static} < 90, \theta_{eff,static}, 180 - \theta_{eff,static}), -IF(\theta_{eff,static} < 90, \theta_{eff,static}, 180 - \theta_{eff,static})))$ Python Logic: `abs(v["Track Slant (degree)"]) if v["Track Section"] == 1 else ((v["Static Effective Angle for parallel force (degree)"] if v["Static Effective Angle for parallel force (degree)"] < 90 else 180 - v["Static Effective Angle for parallel force (degree)"]) if v["Cycle"] == 1 else -(v["Static Effective Angle for parallel force (degree)"] if v["Static Effective Angle for parallel force (degree)"] < 90 else 180 - v["Static Effective Angle for parallel force (degree)"]))` Live Evaluation: [ROUTE: GRID] abs(30.0000) if 1.0000 == 1 else ((30.0000 if 30.0000 < 90 else 180 - 30.0000) if 1.0000 == 1 else -(30.0000 if 30.0000 < 90 else 180 - 30.0000)) = 30.0000
☰	$ X_{flat} $	X flat (m)	-1.16	View Help Guide Purpose: Horizontal position with the track in a horizontal position Logic: (v["Distance on track (m)"] - (v["Straight track length (m)"] / 2) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else (v["Straight track length (m)"] / 2) - (v["Distance on track (m)"] - v["Physical End Corner1 (m)"])) if v["Track Section"] == 1 else ((v["Straight track length (m)"] / 2) + (v["Internal Gear Radius (m)"] * __import__("math").sin(__import__("math").radians(v["Enabler Circumference Angle (degree)"]))) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -(v["Straight track length (m)"] / 2) - (v["Internal Gear Radius (m)"] * __import__("math").sin(__import__("math").radians(v["Enabler Circumference Angle (degree)"])))) Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $X_{flat} = IF(S_{track}==1, IF(d_{track}<L_{s2},d_{track}-(L_{\text{straight}}/2),(L_{\text{straight}}/2)-(d_{track}-L_{s2})), IF(d_{track}<L_{s2},(L_{\text{straight}}/2)+(r_{gear} \times \sin(\text{rad}(\alpha))),-(L_{\text{straight}}/2)-(r_{gear} \times \sin(\text{rad}(\alpha)))))$ Python Logic: (v["Distance on track (m)"] - (v["Straight track length (m)"] / 2) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else (v["Straight track length (m)"] / 2) - (v["Distance on track (m)"] - v["Physical End Corner1 (m)"])) if v["Track Section"] == 1 else ((v["Straight track length (m)"] / 2) + (v["Internal Gear Radius (m)"] * __import__("math").sin(__import__("math").radians(v["Enabler Circumference Angle (degree)"]))) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -(v["Straight track length (m)"] / 2) - (v["Internal Gear Radius (m)"] * __import__("math").sin(__import__("math").radians(v["Enabler Circumference Angle (degree)"])))) Live Evaluation: [ROUTE: GRID] (0.8354 - (4.0000 / 2) if 0.8354 < 10.0000 else (4.0000 / 2) - (0.8354 - 10.0000)) if 1.0000 == 1 else ((4.0000 / 2) + (1.9099 * __import__("math").sin(__import__("math").radians(0.0000))) if 0.8354 < 10.0000 else -(4.0000 / 2) - (1.9099 * __import__("math").sin(__import__("math").radians(0.0000)))) = -1.1646
☰	$ Y_{flat} $	Y flat (m)	1.91	View Help Guide Purpose: Vertical position with the track in a horizontal position Logic: (v["Internal Gear Radius (m)"] if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -v["Internal Gear Radius (m)"]) if v["Track Section"] == 1 else (v["Internal Gear Radius (m)"] * __import__("math").cos(__import__("math").radians(v["Enabler Circumference Angle (degree)"])) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -v["Internal Gear Radius (m)"] * __import__("math").cos(__import__("math").radians(v["Enabler Circumference Angle (degree)"]))) Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $Y_{flat} = IF(S_{track}==1, IF(d_{track}<L_{s2},r_{gear},-r_{gear}),IF(d_{track}<L_{s2},r_{gear} \times \cos(\text{rad}(\alpha)),-r_{gear} \times \cos(\text{rad}(\alpha))))$ Python Logic: `(v["Internal Gear Radius (m)"] if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -v["Internal Gear Radius (m)"]) if v["Track Section"] == 1 else (v["Internal Gear Radius (m)"] * __import__("math").cos(__import__("math").radians(v["Enabler Circumference Angle (degree)"])) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -v["Internal Gear Radius (m)"] * __import__("math").cos(__import__("math").radians(v["Enabler Circumference Angle (degree)"])))` Live Evaluation: [ROUTE: GRID] (1.9099 if 0.8354 < 10.0000 else -1.9099) if 1.0000 == 1 else (1.9099 * __import__("math").cos(__import__("math").radians(0.0000)) if 0.8354 < 10.0000 else -1.9099 * __import__("math").cos(__import__("math").radians(0.0000))) = 1.9099
☰	$ X_{final} $	Horizontal Distance X final (m)	-0.05	View Help Guide Purpose: Horizontal position taking track slant into account Logic: Applies a 2D rotational matrix to the flat X/Y coordinates based on the track slant degree to find the true horizontal position in 3D space. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $X_{final} = (X_{flat} \times \cos(\text{rad}(-\theta_{slant})))-(Y_{flat} \times \sin(\text{rad}(-\theta_{slant})))$ Python Logic: `(v["X flat (m)"]COS(RADIANS(-v["Track Slant (degree)"])))-(v["Y flat (m)"]SIN(RADIANS(-v["Track Slant (degree)"])))` Live Evaluation: [ROUTE: GRID] (-1.1646COS(RADIANS(-30.0000)))-(1.9099SIN(RADIANS(-30.0000))) = -0.0537
☰	$ X_{\text{min, lever}} $	Min Lever Arm (m)	0.00	View Help Guide Purpose: None Logic: None Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $X_{\text{min, lever}} = IF ( \text{Status} == 1, 0, IF ( X_{final} < v_preX_{\text{min, lever}} , X_{final} , v_preX_{\text{min, lever}} ) )$ Python Logic: `IF ( v["Status"] == 1, 0, IF ( v["Horizontal Distance X final (m)"] < v_prev["Min Lever Arm (m)"] , v["Horizontal Distance X final (m)"] , v_prev["Min Lever Arm (m)"] ) )` Live Evaluation: [ROUTE: GRID] IF ( 1.0000 == 1, 0, IF ( -0.0537 < 0.0000 , -0.0537 , 0.0000 ) ) = 0.0000
☰	$ X_{\text{max, lever}} $	Max Lever Arm (m)	0.00	View Help Guide Purpose: None Logic: None Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $X_{\text{max, lever}} = IF ( \text{Status} == 1 , 0, IF ( X_{final} > v_preX_{\text{max, lever}} , X_{final} , v_preX_{\text{max, lever}} ) )$ Python Logic: `IF ( v["Status"] == 1 , 0, IF ( v["Horizontal Distance X final (m)"] > v_prev["Max Lever Arm (m)"] , v["Horizontal Distance X final (m)"] , v_prev["Max Lever Arm (m)"] ) )` Live Evaluation: [ROUTE: GRID] IF ( 1.0000 == 1 , 0, IF ( -0.0537 > 0.0000 , -0.0537 , 0.0000 ) ) = 0.0000
☰	$ Y_{final} $	Vertical Distance Y final (m)	2.24	View Help Guide Purpose: Vertical position taking track slant into accovnt Logic: Applies the secondary rotational matrix formula to find the true vertical position of the enabler as the track tilts. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $Y_{final} = (X_{flat} \times \sin(\text{rad}(-\theta_{slant})))+(Y_{flat} \times \cos(\text{rad}(-\theta_{slant})))$ Python Logic: `(v["X flat (m)"]SIN(RADIANS(-v["Track Slant (degree)"])))+(v["Y flat (m)"]COS(RADIANS(-v["Track Slant (degree)"])))` Live Evaluation: [ROUTE: GRID] (-1.1646SIN(RADIANS(-30.0000)))+(1.9099COS(RADIANS(-30.0000))) = 2.2363
☰	$ F_g $	Gravitational Force Fg (N)	437,245.71	View Help Guide Purpose: Determining the gravitational force of each enabler for energy calculations Logic: Calculates standard downward force (Fg = mg) based on the combined mass of the enabler and its holder. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $F_g = (M_{\text{unit}}+M_{\text{holder}}) \times N$ Python Logic: `(v["Weight per gravity enabler (kg)"]+v["Gravity enabler holder weight (kg)"])v["Gravitational Field Strength (N/kg)"]` Live Evaluation:* [ROUTE: GRID] (5571.4286+39000.0000)*9.8100 = 437,245.7143
☰	$ E_p $	Gravitational Potential Energy GPE per Enabler (J)	107,000.64	View Help Guide Purpose: The total gravitational potential energy of each enabler taking the GMEG system inefficiencies into account Logic: Calculates standard potential energy (Ep = mgh) and cascades it through the mechanical efficiency multipliers (gear losses, bearing friction, etc.). Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $E_p = (((M_{\text{unit}} \times N \times Y_{final}) \times \eta_{\text{gear}}) \times \eta_{\text{bearing}} \times (1-\mu))$ Python Logic: `(((v["Weight per gravity enabler (kg)"]v["Gravitational Field Strength (N/kg)"]v["Vertical Distance Y final (m)"]) v["Gear efficiency (%)"])v["Bearing efficiency friction factor (%)"](1-v["Friction factor (%)"]))` Live Evaluation:* [ROUTE: GRID] (((5571.42869.81002.2363) 0.9500)0.9700*(1-0.0500)) = 107,000.6392
☰	$ \Sigma E_{\text{gpe, enablers}} $	Total Gravitational Potential Energy GPE of all Enablers (J)	233,985.88	View Help Guide Purpose: The sum of the total gravitational potential energy of all enablers taking the GMEG system inefficiencies into account. Logic: Calculates standard potential energy of teh train (Ep = mgh) and cascades it through the mechanical efficiency multipliers (gear losses, bearing friction, etc.). Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\Sigma E_{\text{gpe, enablers}} = E_p+v_pre\Sigma E_{\text{gpe, enablers}}$ Python Logic: `v["Gravitational Potential Energy GPE per Enabler (J)"]+v_prev["Total Gravitational Potential Energy GPE of all Enablers (J)"]` Live Evaluation: [ROUTE: GRID] 107000.6392+126985.2444 = 233,985.8836
☰	$ F_p $	GMEG Parallel Force Fp (N)	218,622.86	View Help Guide Purpose: Enabler parallel force taking the parallel angle into account Logic: Resolves the downward gravitational vector into the actual driving force acting parallel to the track using Fp = Fg sin(Effective Angle). Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $F_p = F_g \times \sin(\text{rad}(\theta_{eff}))$ Python Logic: `v["Gravitational Force Fg (N)"]SIN(RADIANS(v["Effective Angle for Parallel Force (degree)"]))` Live Evaluation:* [ROUTE: GRID] 437245.7143*SIN(RADIANS(30.0000)) = 218,622.8571
☰	$ m_{en,p} $	Parallel mass per Enabler (kg)	22,285.71	View Help Guide Purpose: Quantifies the exact portion of the enabler's physical mass that is actively contributing to the downward drive. Logic: Multiplies the total enabler mass (unit + holder) by the sine of its effective angle to isolate the parallel mass vector. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $m_{en,p} = F_p/N$ Python Logic: `v["GMEG Parallel Force Fp (N)"]/v["Gravitational Field Strength (N/kg)"]` Live Evaluation: [ROUTE: GRID] 218622.8571/9.8100 = 22,285.7143
☰	$ \tau_{GMEG} $	GMEG Nm Output (Nm)	417,538.90	View Help Guide Purpose: Enabler torque delivery based on internal gear radius Logic: Calculates the instantaneous rotational torque produced by this specific enabler by multiplying the parallel force by the lever arm (radius). Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\tau_{GMEG} = F_p \times r_{gear}$ Python Logic: `v["GMEG Parallel Force Fp (N)"]v["Internal Gear Radius (m)"]` Live Evaluation:* [ROUTE: GRID] 218622.8571*1.9099 = 417,538.9006
☰	$ \eta_{loss} $	Operational Efficiency (%)	0.89	View Help Guide Purpose: Torque delivery based on adjustable user inefficiency setting Logic: Applies the baseline mechanical loss/friction coefficient to the system. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\eta_{loss} = \eta_{\text{GMEG}}$ Python Logic: `v["GMEG Efficiency (%)"]` Live Evaluation: [ROUTE: GRID] 0.8884 = 0.8884
☰	$ \tau_{GMEG,final} $	Final GMEG Output (Nm)	370,941.56	View Help Guide Purpose: Enabler torque delivery based on operational inefficiency Logic: The net, real-world usable torque generated by this single enabler after losses. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\tau_{GMEG,final} = \tau_{GMEG} \times \eta_{loss}$ Python Logic: `v["GMEG Nm Output (Nm)"]v["Operational Efficiency (%)"]` Live Evaluation:* [ROUTE: GRID] 417538.9006*0.8884 = 370,941.5593
☰	$ \Sigma\tau_{GMEG} $	Total GMEG Output per Segment (Nm)	741,883.12	View Help Guide Purpose: Total potential torque delivery of the total train with all enablers in the segment Logic: Aggregates the torque from every enabler in the train for this specific moment in time to find the total system output. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\Sigma\tau_{GMEG} = v_pre\Sigma\tau_{GMEG} + \tau_{GMEG,final}$ Python Logic: `v_prev["Total GMEG Output per Segment (Nm)"] + v["Final GMEG Output (Nm)"]` Live Evaluation: [ROUTE: GRID] 370941.5593 + 370941.5593 = 741,883.1187
☰	$ \tau_{def} $	Torque Deficit (Nm)	29,118.91	View Help Guide Purpose: Total torque delivery from the gravity enabler train minus the base load torque delivery requirement Logic: Compares the generated torque against the required load to identify structural power shortages. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\tau_{def} = \tau_{GMEG,final}-(\tau_{\text{out}}/N_{\text{enablers}})$ Python Logic: `v["Final GMEG Output (Nm)"]-(v["GMEG Output Torque (Nm)"]/v["Number of Gravity Enablers"])` Live Evaluation: [ROUTE: GRID] 370941.5593-(2392758.5285/7.0000) = 29,118.9124
☰	$ \Sigma \tau_{\text{deficit}} $	Total Torque Deficit (Nm)	58,237.82	View Help Guide Purpose: Accounting for where negative values may influence total torque deficit Logic: Aggregates the generated torque against the required load to identify structural power shortages. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\tau_{def}+v_pre\text{Total Torque Deficit (Nm)}$ Python Logic: `v["Torque Deficit (Nm)"]+v_prev["Total Torque Deficit (Nm)"]` Live Evaluation: [ROUTE: GRID] 29118.9124+29118.9124 = 58,237.8248
☰	$ \tau_{gear} $	Gear System Torque (Nm)	0.00	View Help Guide Purpose: Torque experienced by the DLLS per enabler during rotation cycles Logic: 0 if v["Status"] == 1 else v["Horizontal Distance X final (m)"] * v["Gravitational Force Fg (N)"] Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\tau_{gear} = IF(\text{Status}==1,0,X_{final} \times F_g)$ Python Logic: `0 if v["Status"] == 1 else v["Horizontal Distance X final (m)"] * v["Gravitational Force Fg (N)"]` Live Evaluation: [ROUTE: GRID] 0 if 1.0000 == 1 else -0.0537 * 437245.7143 = 0.0000
☰	$ \tau $	Absolute Gear System Torque (Nm)	0.00	View Help Guide Purpose: Absolute values to represent positive values for torque experienced by the DLLS Logic: 0 if v["Status"] == 1 else abs(v["Gear System Torque (Nm)"]) Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $` = IF(\text{Status}==1,0,ABS(\tau_{gear}))$ Python Logic: `0 if v["Status"] == 1 else abs(v["Gear System Torque (Nm)"])` Live Evaluation: [ROUTE: GRID] 0 if 1.0000 == 1 else abs(0.0000) = 0.0000
☰	$ \tau_{gear,train} $	Enabler train Absolute Gear System Torque (Nm)	0.00	View Help Guide Purpose: 0 Logic: Sums the absolute torque across all enablers to find the total stress on the rotation gears for this time step. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\tau_{gear,train} = `+v_pre\tau_{gear,train}$ Python Logic: `v["Absolute Gear System Torque (Nm)"]+v_prev["Enabler train Absolute Gear System Torque (Nm)"]` Live Evaluation: [ROUTE: GRID] 0.0000+0.0000 = 0.0000
☰	$ W_{DLLS} $	Work Done by DLLS Joule per Segment (J)	0.00	View Help Guide Purpose: Work done by the DLLS for that segment time frame, based on the angle per segment Logic: 0 if v["Status"] == 1 else v["Absolute Gear System Torque (Nm)"] * v["Angle Per Segment radians (rad/s)"] Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $W_{DLLS} = IF(\text{Status}==1,0,` \times \text{Angle Per Segment radians (rad/s)})$ Python Logic: `0 if v["Status"] == 1 else v["Absolute Gear System Torque (Nm)"] * v["Angle Per Segment radians (rad/s)"]` Live Evaluation: [ROUTE: GRID] 0 if 1.0000 == 1 else 0.0000 * 0.0175 = 0.0000
☰	$ TW_{DLLS} $	Total Work Done by DLLS Joule per Segment (J)	0.00	View Help Guide Purpose: Count of the required work impacting the DLLS during a TAR Logic: Aggregates the rotational torque across the train during the rotation phase. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $TW_{DLLS} = W_{DLLS}+v_preTW_{DLLS}$ Python Logic: `v["Work Done by DLLS Joule per Segment (J)"]+v_prev["Total Work Done by DLLS Joule per Segment (J)"]` Live Evaluation: [ROUTE: GRID] 0.0000+0.0000 = 0.0000
☰	$ I_{en} $	Moment of inertia per enabler (kg.m2)	0.00	View Help Guide Purpose: Modelling inertia during a track arc rotation based on each enablers' position on the track Logic: 0 if v["Status"] == 1 else ((v["TOTAL WEIGHT (KG)"] / v["Number of Gravity Enablers"]) * (v["Horizontal Distance X final (m)"] 2)) Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $I_{en} = IF(\text{Status}==1,0,((M_{\text{total}}/N_{\text{enablers}}) \times (X_{final}^2)))$ Python Logic:** `0 if v["Status"] == 1 else ((v["TOTAL WEIGHT (KG)"] / v["Number of Gravity Enablers"]) * (v["Horizontal Distance X final (m)"] 2))` Live Evaluation:** [ROUTE: GRID] 0 if 1.0000 == 1 else ((312000.0000 / 7.0000) * (-0.0537 ** 2)) = 0.0000
☰	$ I_{train} $	Enabler train Moment of inertia (kg.m2)	0.00	View Help Guide Purpose: Running total inertia based on all enablers Logic: Aggregates the individual inertia values to find the total resistance the system must overcome to swivel the track. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $I_{train} = I_{en}+v_preI_{train}$ Python Logic: `v["Moment of inertia per enabler (kg.m2)"]+v_prev["Enabler train Moment of inertia (kg.m2)"]` Live Evaluation: [ROUTE: GRID] 0.0000+0.0000 = 0.0000
▼ 4. ROTATIONAL TORQUE BLUEPRINTS - S2 E1 Transition
☰	$ P_{circ} $	Enabler Circumference Distance (m)	0.00	View Help Guide Purpose: Determines distance travelled by a gravity enabler on the rounded corner Logic: (v["Distance on track (m)"] - v["Physical End Straight1 (m)"] if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else v["Distance on track (m)"] - v["Physical End Straight2 (m)"]) if v["Track Section"] == 2 else 0 Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $P_{circ} = IF(S_{track}==2,IF( d_{track}<L_{s2},d_{track}-L_{s1},d_{track}-L_{c1}),0)$ Python Logic: `(v["Distance on track (m)"] - v["Physical End Straight1 (m)"] if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else v["Distance on track (m)"] - v["Physical End Straight2 (m)"]) if v["Track Section"] == 2 else 0` Live Evaluation: [ROUTE: GRID] (0.1200 - 4.0000 if 0.1200 < 10.0000 else 0.1200 - 14.0000) if 1.0000 == 2 else 0 = 0.0000
☰	$ \alpha $	Enabler Circumference Angle (degree)	0.00	View Help Guide Purpose: The rounded corner enabler position angle Logic: Converts the curved distance travelled into an exact geometric angle around the gear hub. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\alpha = \text{deg}(P_{circ}/r_{gear})$ Python Logic: `DEGREES(v["Enabler Circumference Distance (m)"]/v["Internal Gear Radius (m)"])` Live Evaluation: [ROUTE: GRID] DEGREES(0.0000/1.9099) = 0.0000
☰	$ \theta_{eff,static} $	Static Effective Angle for parallel force (degree)	30.00	View Help Guide Purpose: Intermediate calculation for Effective Angle considering the track slant Logic: v["Track Slant (degree)"] if v["Enabler Circumference Angle (degree)"] == 0 else v["Track Slant (degree)"] + v["Enabler Circumference Angle (degree)"] Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\theta_{eff,static} = IF(\alpha==0,\theta_{slant},\theta_{slant}+\alpha)$ Python Logic: `v["Track Slant (degree)"] if v["Enabler Circumference Angle (degree)"] == 0 else v["Track Slant (degree)"] + v["Enabler Circumference Angle (degree)"]` Live Evaluation: [ROUTE: GRID] 30.0000 if 0.0000 == 0 else 30.0000 + 0.0000 = 30.0000
☰	$ \theta_{eff} $	Effective Angle for Parallel Force (degree)	30.00	View Help Guide Purpose: Determinging the correct effective parallel force angle based on the geometry of the GMEG design Logic: abs(v["Track Slant (degree)"]) if v["Track Section"] == 1 else ((v["Static Effective Angle for parallel force (degree)"] if v["Static Effective Angle for parallel force (degree)"] < 90 else 180 - v["Static Effective Angle for parallel force (degree)"]) if v["TAR Transformed Enabler Distance (m)"] < v["RotZone1 End (m)"] else (-(v["Static Effective Angle for parallel force (degree)"] if v["Static Effective Angle for parallel force (degree)"] < 90 else 180 - v["Static Effective Angle for parallel force (degree)"]) if v["TAR Transformed Enabler Distance (m)"] < v["RotZone2 End (m)"] else 0.0)) Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\theta_{eff} = IF(S_{track} == 1, abs(\theta_{slant}), IF(P_{trans}<R_{z1, end},IF(\theta_{eff,static} < 90, \theta_{eff,static}, 180 - \theta_{eff,static}),IF(P_{trans}<R_{z2, end},-IF(\theta_{eff,static} < 90, \theta_{eff,static}, 180 - \theta_{eff,static}), 0.0)))$ Python Logic: abs(v["Track Slant (degree)"]) if v["Track Section"] == 1 else ((v["Static Effective Angle for parallel force (degree)"] if v["Static Effective Angle for parallel force (degree)"] < 90 else 180 - v["Static Effective Angle for parallel force (degree)"]) if v["TAR Transformed Enabler Distance (m)"] < v["RotZone1 End (m)"] else (-(v["Static Effective Angle for parallel force (degree)"] if v["Static Effective Angle for parallel force (degree)"] < 90 else 180 - v["Static Effective Angle for parallel force (degree)"]) if v["TAR Transformed Enabler Distance (m)"] < v["RotZone2 End (m)"] else 0.0)) Live Evaluation: [ROUTE: GRID] abs(30.0000) if 1.0000 == 1 else ((30.0000 if 30.0000 < 90 else 180 - 30.0000) if 0.2400 < 10.6000 else (-(30.0000 if 30.0000 < 90 else 180 - 30.0000) if 0.2400 < 20.6000 else 0.0)) = 30.0000
☰	$ X_{flat} $	X flat (m)	-1.88	View Help Guide Purpose: Horizontal position with the track in a horizontal position Logic: (v["Distance on track (m)"] - (v["Straight track length (m)"] / 2) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else (v["Straight track length (m)"] / 2) - (v["Distance on track (m)"] - v["Physical End Corner1 (m)"])) if v["Track Section"] == 1 else ((v["Straight track length (m)"] / 2) + (v["Internal Gear Radius (m)"] * __import__("math").sin(__import__("math").radians(v["Enabler Circumference Angle (degree)"]))) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -(v["Straight track length (m)"] / 2) - (v["Internal Gear Radius (m)"] * __import__("math").sin(__import__("math").radians(v["Enabler Circumference Angle (degree)"])))) Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $X_{flat} = IF(S_{track}==1, IF(d_{track}<L_{s2},d_{track}-(L_{\text{straight}}/2),(L_{\text{straight}}/2)-(d_{track}-L_{s2})), IF(d_{track}<L_{s2},(L_{\text{straight}}/2)+(r_{gear} \times \sin(\text{rad}(\alpha))),-(L_{\text{straight}}/2)-(r_{gear} \times \sin(\text{rad}(\alpha)))))$ Python Logic: (v["Distance on track (m)"] - (v["Straight track length (m)"] / 2) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else (v["Straight track length (m)"] / 2) - (v["Distance on track (m)"] - v["Physical End Corner1 (m)"])) if v["Track Section"] == 1 else ((v["Straight track length (m)"] / 2) + (v["Internal Gear Radius (m)"] * __import__("math").sin(__import__("math").radians(v["Enabler Circumference Angle (degree)"]))) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -(v["Straight track length (m)"] / 2) - (v["Internal Gear Radius (m)"] * __import__("math").sin(__import__("math").radians(v["Enabler Circumference Angle (degree)"])))) Live Evaluation: [ROUTE: GRID] (0.1200 - (4.0000 / 2) if 0.1200 < 10.0000 else (4.0000 / 2) - (0.1200 - 10.0000)) if 1.0000 == 1 else ((4.0000 / 2) + (1.9099 * __import__("math").sin(__import__("math").radians(0.0000))) if 0.1200 < 10.0000 else -(4.0000 / 2) - (1.9099 * __import__("math").sin(__import__("math").radians(0.0000)))) = -1.8800
☰	$ Y_{flat} $	Y flat (m)	1.91	View Help Guide Purpose: Vertical position with the track in a horizontal position Logic: (v["Internal Gear Radius (m)"] if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -v["Internal Gear Radius (m)"]) if v["Track Section"] == 1 else (v["Internal Gear Radius (m)"] * __import__("math").cos(__import__("math").radians(v["Enabler Circumference Angle (degree)"])) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -v["Internal Gear Radius (m)"] * __import__("math").cos(__import__("math").radians(v["Enabler Circumference Angle (degree)"]))) Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $Y_{flat} = IF(S_{track}==1, IF(d_{track}<L_{s2},r_{gear},-r_{gear}), IF(d_{track}<L_{s2},r_{gear} \times \cos(\text{rad}(\alpha)),-r_{gear} \times \cos(\text{rad}(\alpha))))$ Python Logic: `(v["Internal Gear Radius (m)"] if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -v["Internal Gear Radius (m)"]) if v["Track Section"] == 1 else (v["Internal Gear Radius (m)"] * __import__("math").cos(__import__("math").radians(v["Enabler Circumference Angle (degree)"])) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -v["Internal Gear Radius (m)"] * __import__("math").cos(__import__("math").radians(v["Enabler Circumference Angle (degree)"])))` Live Evaluation: [ROUTE: GRID] (1.9099 if 0.1200 < 10.0000 else -1.9099) if 1.0000 == 1 else (1.9099 * __import__("math").cos(__import__("math").radians(0.0000)) if 0.1200 < 10.0000 else -1.9099 * __import__("math").cos(__import__("math").radians(0.0000))) = 1.9099
☰	$ X_{final} $	Horizontal Distance X final (m)	-0.67	View Help Guide Purpose: Horizontal position taking track slant into account Logic: Applies a 2D rotational matrix to the flat X/Y coordinates based on the track slant degree to find the true horizontal position in 3D space. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $X_{final} = (X_{flat} \times \cos(\text{rad}(-\theta_{slant})))-(Y_{flat} \times \sin(\text{rad}(-\theta_{slant})))$ Python Logic: `(v["X flat (m)"]COS(RADIANS(-v["Track Slant (degree)"])))-(v["Y flat (m)"]SIN(RADIANS(-v["Track Slant (degree)"])))` Live Evaluation: [ROUTE: GRID] (-1.8800COS(RADIANS(-30.0000)))-(1.9099SIN(RADIANS(-30.0000))) = -0.6732
☰	$ X_{\text{min, lever}} $	Min Lever Arm (m)	0.00	View Help Guide Purpose: None Logic: None Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $X_{\text{min, lever}} = IF ( \text{Status} == 1, 0 , X_{final} )$ Python Logic: `IF ( v["Status"] == 1, 0 , v["Horizontal Distance X final (m)"] )` Live Evaluation: [ROUTE: GRID] IF ( 1.0000 == 1, 0 , -0.6732 ) = 0.0000
☰	$ X_{\text{max, lever}} $	Max Lever Arm (m)	0.00	View Help Guide Purpose: None Logic: None Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $X_{\text{max, lever}} = IF ( \text{Status} == 1 , 0 , X_{final} )$ Python Logic: `IF ( v["Status"] == 1 , 0 , v["Horizontal Distance X final (m)"] )` Live Evaluation: [ROUTE: GRID] IF ( 1.0000 == 1 , 0 , -0.6732 ) = 0.0000
☰	$ Y_{final} $	Vertical Distance Y final (m)	2.59	View Help Guide Purpose: Vertical position taking track slant into accovnt Logic: Applies the secondary rotational matrix formula to find the true vertical position of the enabler as the track tilts. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $Y_{final} = (X_{flat} \times \sin(\text{rad}(-\theta_{slant})))+(Y_{flat} \times \cos(\text{rad}(-\theta_{slant})))$ Python Logic: `(v["X flat (m)"]SIN(RADIANS(-v["Track Slant (degree)"])))+(v["Y flat (m)"]COS(RADIANS(-v["Track Slant (degree)"])))` Live Evaluation: [ROUTE: GRID] (-1.8800SIN(RADIANS(-30.0000)))+(1.9099COS(RADIANS(-30.0000))) = 2.5940
☰	$ F_g $	Gravitational Force Fg (N)	437,245.71	View Help Guide Purpose: Determining the gravitational force of each enabler for energy calculations Logic: Calculates standard downward force (Fg = mg) based on the combined mass of the enabler and its holder. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $F_g = (M_{\text{unit}}+M_{\text{holder}}) \times N$ Python Logic: `(v["Weight per gravity enabler (kg)"]+v["Gravity enabler holder weight (kg)"])v["Gravitational Field Strength (N/kg)"]` Live Evaluation:* [ROUTE: GRID] (5571.4286+39000.0000)*9.8100 = 437,245.7143
☰	$ E_p $	Gravitational Potential Energy GPE per Enabler (J)	124,114.43	View Help Guide Purpose: Determines the exact harvestable energy from the enabler's physical height, minus inherent mechanical losses. Logic: Calculates standard potential energy (Ep = mgh) and cascades it through the mechanical efficiency multipliers (gear losses, bearing friction, etc.). Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $E_p = (((M_{\text{unit}} \times N \times Y_{final}) \times \eta_{\text{gear}}) \times \eta_{\text{bearing}}) \times (1-\mu)$ Python Logic: `(((v["Weight per gravity enabler (kg)"]v["Gravitational Field Strength (N/kg)"]v["Vertical Distance Y final (m)"])v["Gear efficiency (%)"])v["Bearing efficiency friction factor (%)"])(1-v["Friction factor (%)"])` Live Evaluation:* [ROUTE: GRID] (((5571.42869.81002.5940)0.9500)0.9700)*(1-0.0500) = 124,114.4257
☰	$ \Sigma E_{\text{gpe, enablers}} $	Total Gravitational Potential Energy GPE of all Enablers (J)	124,114.43	View Help Guide Purpose: The sum of the total gravitational potential energy of all enablers taking the GMEG system inefficiencies into account. Logic: Calculates standard potential energy of teh train (Ep = mgh) and cascades it through the mechanical efficiency multipliers (gear losses, bearing friction, etc.). Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\Sigma E_{\text{gpe, enablers}} = E_p$ Python Logic: `v["Gravitational Potential Energy GPE per Enabler (J)"]` Live Evaluation: [ROUTE: GRID] 124114.4257 = 124,114.4257
☰	$ F_p $	GMEG Parallel Force Fp (N)	218,622.86	View Help Guide Purpose: Enabler parallel force taking the parallel angle into account Logic: Resolves the downward gravitational vector into the actual driving force acting parallel to the track using Fp = Fg sin(Effective Angle). Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $F_p = F_g \times \sin(\text{rad}(\theta_{eff}))$ Python Logic: `v["Gravitational Force Fg (N)"]SIN(RADIANS(v["Effective Angle for Parallel Force (degree)"]))` Live Evaluation:* [ROUTE: GRID] 437245.7143*SIN(RADIANS(30.0000)) = 218,622.8571
☰	$ m_{en,p} $	Parallel mass per Enabler (kg)	22,285.71	View Help Guide Purpose: Quantifies the exact portion of the enabler's physical mass that is actively contributing to the downward drive. Logic: Multiplies the total enabler mass (unit + holder) by the sine of its effective angle to isolate the parallel mass vector. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $m_{en,p} = F_p/N$ Python Logic: `v["GMEG Parallel Force Fp (N)"]/v["Gravitational Field Strength (N/kg)"]` Live Evaluation: [ROUTE: GRID] 218622.8571/9.8100 = 22,285.7143
☰	$ \tau_{GMEG} $	GMEG Nm Output (Nm)	417,538.90	View Help Guide Purpose: Enabler torque delivery based on internal gear radius Logic: Calculates the instantaneous rotational torque produced by this specific enabler by multiplying the parallel force by the lever arm (radius). Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\tau_{GMEG} = F_p \times r_{gear}$ Python Logic: `v["GMEG Parallel Force Fp (N)"]v["Internal Gear Radius (m)"]` Live Evaluation:* [ROUTE: GRID] 218622.8571*1.9099 = 417,538.9006
☰	$ \eta_{loss} $	Operational Efficiency (%)	0.89	View Help Guide Purpose: Torque delivery based on adjustable user inefficiency setting Logic: Applies the baseline mechanical loss/friction coefficient to the system. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\eta_{loss} = \eta_{\text{GMEG}}$ Python Logic: `v["GMEG Efficiency (%)"]` Live Evaluation: [ROUTE: GRID] 0.8884 = 0.8884
☰	$ \tau_{GMEG,final} $	Final GMEG Output (Nm)	370,941.56	View Help Guide Purpose: Enabler torque delivery based on operational inefficiency Logic: The net, real-world usable torque generated by this single enabler after losses. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\tau_{GMEG,final} = \tau_{GMEG} \times \eta_{loss}$ Python Logic: `v["GMEG Nm Output (Nm)"]v["Operational Efficiency (%)"]` Live Evaluation:* [ROUTE: GRID] 417538.9006*0.8884 = 370,941.5593
☰	$ \Sigma\tau_{GMEG} $	Total GMEG Output per Segment (Nm)	370,941.56	View Help Guide Purpose: Total potential torque delivery of the total train with all enablers in the segment Logic: Aggregates the torque from every enabler in the train for this specific moment in time to find the total system output. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\Sigma\tau_{GMEG} = \tau_{GMEG,final}$ Python Logic: `v["Final GMEG Output (Nm)"]` Live Evaluation: [ROUTE: GRID] 370941.5593 = 370,941.5593
☰	$ \tau_{def} $	Torque Deficit (Nm)	29,118.91	View Help Guide Purpose: Total torque delivery from the gravity enabler train minus the base load torque delivery requirement Logic: Compares the generated torque against the required load to identify structural power shortages. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\tau_{def} = \tau_{GMEG,final}-(\tau_{\text{out}}/N_{\text{enablers}})$ Python Logic: `v["Final GMEG Output (Nm)"]-(v["GMEG Output Torque (Nm)"]/v["Number of Gravity Enablers"])` Live Evaluation: [ROUTE: GRID] 370941.5593-(2392758.5285/7.0000) = 29,118.9124
☰	$ \Sigma \tau_{\text{deficit}} $	Total Torque Deficit (Nm)	29,118.91	View Help Guide Purpose: Accounting for where negative values may influence total torque deficit Logic: Aggregates the generated torque against the required load to identify structural power shortages. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $` = \tau_{def}$ Python Logic: `v["Torque Deficit (Nm)"]` Live Evaluation: [ROUTE: GRID] 29118.9124 = 29,118.9124
☰	$ \tau_{gear} $	Gear System Torque (Nm)	0.00	View Help Guide Purpose: Torque experienced by the DLLS per enabler during rotation cycles Logic: 0 if v["Status"] == 1 else v["Horizontal Distance X final (m)"] * v["Gravitational Force Fg (N)"] Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\tau_{gear} = IF(\text{Status}==1,0,X_{final} \times F_g)$ Python Logic: `0 if v["Status"] == 1 else v["Horizontal Distance X final (m)"] * v["Gravitational Force Fg (N)"]` Live Evaluation: [ROUTE: GRID] 0 if 1.0000 == 1 else -0.6732 * 437245.7143 = 0.0000
☰	$ \tau $	Absolute Gear System Torque (Nm)	0.00	View Help Guide Purpose: Absolute values to represent positive values for torque experienced by the DLLS Logic: 0 if v["Status"] == 1 else abs(v["Gear System Torque (Nm)"]) Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $` = IF(\text{Status}==1,0,ABS(\tau_{gear}))$ Python Logic: `0 if v["Status"] == 1 else abs(v["Gear System Torque (Nm)"])` Live Evaluation: [ROUTE: GRID] 0 if 1.0000 == 1 else abs(0.0000) = 0.0000
☰	$ \tau_{gear,train} $	Enabler train Absolute Gear System Torque (Nm)	0.00	View Help Guide Purpose: 0 Logic: Sums the absolute torque across all enablers to find the total stress on the rotation gears for this time step. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\tau_{gear,train} = `$ Python Logic: `v["Absolute Gear System Torque (Nm)"]` Live Evaluation: [ROUTE: GRID] 0.0000 = 0.0000
☰	$ W_{DLLS} $	Work Done by DLLS Joule per Segment (J)	0.00	View Help Guide Purpose: Work done by the DLLS for that segment time frame, based on the angle per segment Logic: 0 if v["Status"] == 1 else v["Absolute Gear System Torque (Nm)"] * v["Angle Per Segment radians (rad/s)"] Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $W_{DLLS} = IF(\text{Status}==1,0,` \times \text{Angle Per Segment radians (rad/s)})$ Python Logic: `0 if v["Status"] == 1 else v["Absolute Gear System Torque (Nm)"] * v["Angle Per Segment radians (rad/s)"]` Live Evaluation: [ROUTE: GRID] 0 if 1.0000 == 1 else 0.0000 * 0.0175 = 0.0000
☰	$ TW_{DLLS} $	Total Work Done by DLLS Joule per Segment (J)	0.00	View Help Guide Purpose: Count of the required work impacting the DLLS during a TAR Logic: Aggregates the rotational torque across the train during the rotation phase. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $TW_{DLLS} = W_{DLLS}$ Python Logic: `v["Work Done by DLLS Joule per Segment (J)"]` Live Evaluation: [ROUTE: GRID] 0.0000 = 0.0000
☰	$ I_{en} $	Moment of inertia per enabler (kg.m2)	0.00	View Help Guide Purpose: Modelling inertia during a track arc rotation based on each enablers' position on the track Logic: 0 if v["Status"] == 1 else ((v["TOTAL WEIGHT (KG)"] / v["Number of Gravity Enablers"]) * (v["Horizontal Distance X final (m)"] 2)) Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $I_{en} = IF(\text{Status}==1,0,((M_{\text{total}}/N_{\text{enablers}}) \times (X_{final}^2)))$ Python Logic:** `0 if v["Status"] == 1 else ((v["TOTAL WEIGHT (KG)"] / v["Number of Gravity Enablers"]) * (v["Horizontal Distance X final (m)"] 2))` Live Evaluation:** [ROUTE: GRID] 0 if 1.0000 == 1 else ((312000.0000 / 7.0000) * (-0.6732 ** 2)) = 0.0000
☰	$ I_{train} $	Enabler train Moment of inertia (kg.m2)	0.00	View Help Guide Purpose: Running total inertia based on all enablers Logic: Aggregates the individual inertia values to find the total resistance the system must overcome to swivel the track. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $I_{train} = I_{en}$ Python Logic: `v["Moment of inertia per enabler (kg.m2)"]` Live Evaluation: [ROUTE: GRID] 0.0000 = 0.0000
▼ 4. ROTATIONAL TORQUE BLUEPRINTS - S2 E2 Cascade
☰	$ P_{circ} $	Enabler Circumference Distance (m)	0.00	View Help Guide Purpose: Determines distance travelled by a gravity enabler on the rounded corner Logic: (v["Distance on track (m)"] - v["Physical End Straight1 (m)"] if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else v["Distance on track (m)"] - v["Physical End Straight2 (m)"]) if v["Track Section"] == 2 else 0 Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $P_{circ} = IF(S_{track}==2,IF( d_{track}<L_{s2},d_{track}-L_{s1},d_{track}-L_{c1}),0)$ Python Logic: `(v["Distance on track (m)"] - v["Physical End Straight1 (m)"] if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else v["Distance on track (m)"] - v["Physical End Straight2 (m)"]) if v["Track Section"] == 2 else 0` Live Evaluation: [ROUTE: GRID] (0.9554 - 4.0000 if 0.9554 < 10.0000 else 0.9554 - 14.0000) if 1.0000 == 2 else 0 = 0.0000
☰	$ \alpha $	Enabler Circumference Angle (degree)	0.00	View Help Guide Purpose: The rounded corner enabler position angle Logic: Converts the curved distance travelled into an exact geometric angle around the gear hub. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\alpha = \text{deg}(P_{circ}/r_{gear})$ Python Logic: `DEGREES(v["Enabler Circumference Distance (m)"]/v["Internal Gear Radius (m)"])` Live Evaluation: [ROUTE: GRID] DEGREES(0.0000/1.9099) = 0.0000
☰	$ \theta_{eff,static} $	Static Effective Angle for parallel force (degree)	30.00	View Help Guide Purpose: Intermediate calculation for Effective Angle considering the track slant Logic: v["Track Slant (degree)"] if v["Enabler Circumference Angle (degree)"] == 0 else v["Track Slant (degree)"] + v["Enabler Circumference Angle (degree)"] Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\theta_{eff,static} = IF(\alpha==0,\theta_{slant},\theta_{slant}+\alpha)$ Python Logic: `v["Track Slant (degree)"] if v["Enabler Circumference Angle (degree)"] == 0 else v["Track Slant (degree)"] + v["Enabler Circumference Angle (degree)"]` Live Evaluation: [ROUTE: GRID] 30.0000 if 0.0000 == 0 else 30.0000 + 0.0000 = 30.0000
☰	$ \theta_{eff} $	Effective Angle for Parallel Force (degree)	30.00	View Help Guide Purpose: Determinging the correct effective parallel force angle based on the geometry of the GMEG design Logic: abs(v["Track Slant (degree)"]) if v["Track Section"] == 1 else ((v["Static Effective Angle for parallel force (degree)"] if v["Static Effective Angle for parallel force (degree)"] < 90 else 180 - v["Static Effective Angle for parallel force (degree)"]) if v["TAR Transformed Enabler Distance (m)"] < v["RotZone1 End (m)"] else (-(v["Static Effective Angle for parallel force (degree)"] if v["Static Effective Angle for parallel force (degree)"] < 90 else 180 - v["Static Effective Angle for parallel force (degree)"]) if v["TAR Transformed Enabler Distance (m)"] < v["RotZone2 End (m)"] else 0.0)) Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\theta_{eff} = IF(S_{track} == 1, abs(\theta_{slant}), IF(P_{trans}<R_{z1, end},IF(\theta_{eff,static} < 90, \theta_{eff,static}, 180 - \theta_{eff,static}),IF(P_{trans}<R_{z2, end},-IF(\theta_{eff,static} < 90, \theta_{eff,static}, 180 - \theta_{eff,static}), 0.0)))$ Python Logic: abs(v["Track Slant (degree)"]) if v["Track Section"] == 1 else ((v["Static Effective Angle for parallel force (degree)"] if v["Static Effective Angle for parallel force (degree)"] < 90 else 180 - v["Static Effective Angle for parallel force (degree)"]) if v["TAR Transformed Enabler Distance (m)"] < v["RotZone1 End (m)"] else (-(v["Static Effective Angle for parallel force (degree)"] if v["Static Effective Angle for parallel force (degree)"] < 90 else 180 - v["Static Effective Angle for parallel force (degree)"]) if v["TAR Transformed Enabler Distance (m)"] < v["RotZone2 End (m)"] else 0.0)) Live Evaluation: [ROUTE: GRID] abs(30.0000) if 1.0000 == 1 else ((30.0000 if 30.0000 < 90 else 180 - 30.0000) if 1.0754 < 10.6000 else (-(30.0000 if 30.0000 < 90 else 180 - 30.0000) if 1.0754 < 20.6000 else 0.0)) = 30.0000
☰	$ X_{flat} $	X flat (m)	-1.04	View Help Guide Purpose: Horizontal position with the track in a horizontal position Logic: (v["Distance on track (m)"] - (v["Straight track length (m)"] / 2) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else (v["Straight track length (m)"] / 2) - (v["Distance on track (m)"] - v["Physical End Corner1 (m)"])) if v["Track Section"] == 1 else ((v["Straight track length (m)"] / 2) + (v["Internal Gear Radius (m)"] * __import__("math").sin(__import__("math").radians(v["Enabler Circumference Angle (degree)"]))) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -(v["Straight track length (m)"] / 2) - (v["Internal Gear Radius (m)"] * __import__("math").sin(__import__("math").radians(v["Enabler Circumference Angle (degree)"])))) Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $X_{flat} = IF(S_{track}==1, IF(d_{track}<L_{s2},d_{track}-(L_{\text{straight}}/2),(L_{\text{straight}}/2)-(d_{track}-L_{s2})), IF(d_{track}<L_{s2},(L_{\text{straight}}/2)+(r_{gear} \times \sin(\text{rad}(\alpha))),-(L_{\text{straight}}/2)-(r_{gear} \times \sin(\text{rad}(\alpha)))))$ Python Logic: (v["Distance on track (m)"] - (v["Straight track length (m)"] / 2) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else (v["Straight track length (m)"] / 2) - (v["Distance on track (m)"] - v["Physical End Corner1 (m)"])) if v["Track Section"] == 1 else ((v["Straight track length (m)"] / 2) + (v["Internal Gear Radius (m)"] * __import__("math").sin(__import__("math").radians(v["Enabler Circumference Angle (degree)"]))) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -(v["Straight track length (m)"] / 2) - (v["Internal Gear Radius (m)"] * __import__("math").sin(__import__("math").radians(v["Enabler Circumference Angle (degree)"])))) Live Evaluation: [ROUTE: GRID] (0.9554 - (4.0000 / 2) if 0.9554 < 10.0000 else (4.0000 / 2) - (0.9554 - 10.0000)) if 1.0000 == 1 else ((4.0000 / 2) + (1.9099 * __import__("math").sin(__import__("math").radians(0.0000))) if 0.9554 < 10.0000 else -(4.0000 / 2) - (1.9099 * __import__("math").sin(__import__("math").radians(0.0000)))) = -1.0446
☰	$ Y_{flat} $	Y flat (m)	1.91	View Help Guide Purpose: Vertical position with the track in a horizontal position Logic: (v["Internal Gear Radius (m)"] if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -v["Internal Gear Radius (m)"]) if v["Track Section"] == 1 else (v["Internal Gear Radius (m)"] * __import__("math").cos(__import__("math").radians(v["Enabler Circumference Angle (degree)"])) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -v["Internal Gear Radius (m)"] * __import__("math").cos(__import__("math").radians(v["Enabler Circumference Angle (degree)"]))) Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $Y_{flat} = IF(S_{track}==1, IF(d_{track}<L_{s2},r_{gear},-r_{gear}), IF(d_{track}<L_{s2},r_{gear} \times \cos(\text{rad}(\alpha)),-r_{gear} \times \cos(\text{rad}(\alpha))))$ Python Logic: `(v["Internal Gear Radius (m)"] if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -v["Internal Gear Radius (m)"]) if v["Track Section"] == 1 else (v["Internal Gear Radius (m)"] * __import__("math").cos(__import__("math").radians(v["Enabler Circumference Angle (degree)"])) if v["Distance on track (m)"] < v["Physical End Corner1 (m)"] else -v["Internal Gear Radius (m)"] * __import__("math").cos(__import__("math").radians(v["Enabler Circumference Angle (degree)"])))` Live Evaluation: [ROUTE: GRID] (1.9099 if 0.9554 < 10.0000 else -1.9099) if 1.0000 == 1 else (1.9099 * __import__("math").cos(__import__("math").radians(0.0000)) if 0.9554 < 10.0000 else -1.9099 * __import__("math").cos(__import__("math").radians(0.0000))) = 1.9099
☰	$ X_{final} $	Horizontal Distance X final (m)	0.05	View Help Guide Purpose: Horizontal position taking track slant into account Logic: Applies a 2D rotational matrix to the flat X/Y coordinates based on the track slant degree to find the true horizontal position in 3D space. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $X_{final} = (X_{flat} \times \cos(\text{rad}(-\theta_{slant})))-(Y_{flat} \times \sin(\text{rad}(-\theta_{slant})))$ Python Logic: `(v["X flat (m)"]COS(RADIANS(-v["Track Slant (degree)"])))-(v["Y flat (m)"]SIN(RADIANS(-v["Track Slant (degree)"])))` Live Evaluation: [ROUTE: GRID] (-1.0446COS(RADIANS(-30.0000)))-(1.9099SIN(RADIANS(-30.0000))) = 0.0502
☰	$ X_{\text{min, lever}} $	Min Lever Arm (m)	0.00	View Help Guide Purpose: None Logic: None Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $X_{\text{min, lever}} = IF ( \text{Status} == 1 , 0 , IF ( X_{final} < v_preX_{\text{min, lever}} , X_{final} , v_preX_{\text{min, lever}} ) )$ Python Logic: `IF ( v["Status"] == 1 , 0 , IF ( v["Horizontal Distance X final (m)"] < v_prev["Min Lever Arm (m)"] , v["Horizontal Distance X final (m)"] , v_prev["Min Lever Arm (m)"] ) )` Live Evaluation: [ROUTE: GRID] IF ( 1.0000 == 1 , 0 , IF ( 0.0502 < 0.0000 , 0.0502 , 0.0000 ) ) = 0.0000
☰	$ X_{\text{max, lever}} $	Max Lever Arm (m)	0.00	View Help Guide Purpose: None Logic: None Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $X_{\text{max, lever}} = IF ( \text{Status} == 1 , 0 , IF ( X_{final} > v_preX_{\text{max, lever}} , X_{final} , v_preX_{\text{max, lever}} ) )$ Python Logic: `IF ( v["Status"] == 1 , 0 , IF ( v["Horizontal Distance X final (m)"] > v_prev["Max Lever Arm (m)"] , v["Horizontal Distance X final (m)"] , v_prev["Max Lever Arm (m)"] ) )` Live Evaluation: [ROUTE: GRID] IF ( 1.0000 == 1 , 0 , IF ( 0.0502 > 0.0000 , 0.0502 , 0.0000 ) ) = 0.0000
☰	$ Y_{final} $	Vertical Distance Y final (m)	2.18	View Help Guide Purpose: Vertical position taking track slant into accovnt Logic: Applies the secondary rotational matrix formula to find the true vertical position of the enabler as the track tilts. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $Y_{final} = (X_{flat} \times \sin(\text{rad}(-\theta_{slant})))+(Y_{flat} \times \cos(\text{rad}(-\theta_{slant})))$ Python Logic: `(v["X flat (m)"]SIN(RADIANS(-v["Track Slant (degree)"])))+(v["Y flat (m)"]COS(RADIANS(-v["Track Slant (degree)"])))` Live Evaluation: [ROUTE: GRID] (-1.0446SIN(RADIANS(-30.0000)))+(1.9099COS(RADIANS(-30.0000))) = 2.1763
☰	$ F_g $	Gravitational Force Fg (N)	437,245.71	View Help Guide Purpose: Determining the gravitational force of each enabler for energy calculations Logic: Calculates standard downward force (Fg = mg) based on the combined mass of the enabler and its holder. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $F_g = (M_{\text{unit}}+M_{\text{holder}}) \times N$ Python Logic: `(v["Weight per gravity enabler (kg)"]+v["Gravity enabler holder weight (kg)"])v["Gravitational Field Strength (N/kg)"]` Live Evaluation:* [ROUTE: GRID] (5571.4286+39000.0000)*9.8100 = 437,245.7143
☰	$ E_p $	Gravitational Potential Energy GPE per Enabler (J)	104,129.82	View Help Guide Purpose: The total gravitational potential energy of each enabler taking the GMEG system inefficiencies into account Logic: Calculates standard potential energy (Ep = mgh) and cascades it through the mechanical efficiency multipliers (gear losses, bearing friction, etc.). Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $E_p = (((M_{\text{unit}} \times N \times Y_{final}) \times \eta_{\text{gear}}) \times \eta_{\text{bearing}}) \times (1-\mu)$ Python Logic: `(((v["Weight per gravity enabler (kg)"]v["Gravitational Field Strength (N/kg)"]v["Vertical Distance Y final (m)"])v["Gear efficiency (%)"])v["Bearing efficiency friction factor (%)"])(1-v["Friction factor (%)"])` Live Evaluation:* [ROUTE: GRID] (((5571.42869.81002.1763)0.9500)0.9700)*(1-0.0500) = 104,129.8205
☰	$ \Sigma E_{\text{gpe, enablers}} $	Total Gravitational Potential Energy GPE of all Enablers (J)	228,244.25	View Help Guide Purpose: The sum of the total gravitational potential energy of all enablers taking the GMEG system inefficiencies into account. Logic: Calculates standard potential energy of teh train (Ep = mgh) and cascades it through the mechanical efficiency multipliers (gear losses, bearing friction, etc.). Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\Sigma E_{\text{gpe, enablers}} = E_p+v_pre\Sigma E_{\text{gpe, enablers}}$ Python Logic: `v["Gravitational Potential Energy GPE per Enabler (J)"]+v_prev["Total Gravitational Potential Energy GPE of all Enablers (J)"]` Live Evaluation: [ROUTE: GRID] 104129.8205+124114.4257 = 228,244.2461
☰	$ F_p $	GMEG Parallel Force Fp (N)	218,622.86	View Help Guide Purpose: Enabler parallel force taking the parallel angle into account Logic: Resolves the downward gravitational vector into the actual driving force acting parallel to the track using Fp = Fg sin(Effective Angle). Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $F_p = F_g \times \sin(\text{rad}(\theta_{eff}))$ Python Logic: `v["Gravitational Force Fg (N)"]SIN(RADIANS(v["Effective Angle for Parallel Force (degree)"]))` Live Evaluation:* [ROUTE: GRID] 437245.7143*SIN(RADIANS(30.0000)) = 218,622.8571
☰	$ m_{en,p} $	Parallel mass per Enabler (kg)	22,285.71	View Help Guide Purpose: Quantifies the exact portion of the enabler's physical mass that is actively contributing to the downward drive. Logic: Multiplies the total enabler mass (unit + holder) by the sine of its effective angle to isolate the parallel mass vector. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $m_{en,p} = F_p/N$ Python Logic: `v["GMEG Parallel Force Fp (N)"]/v["Gravitational Field Strength (N/kg)"]` Live Evaluation: [ROUTE: GRID] 218622.8571/9.8100 = 22,285.7143
☰	$ \tau_{GMEG} $	GMEG Nm Output (Nm)	417,538.90	View Help Guide Purpose: Enabler torque delivery based on internal gear radius Logic: Calculates the instantaneous rotational torque produced by this specific enabler by multiplying the parallel force by the lever arm (radius). Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\tau_{GMEG} = F_p \times r_{gear}$ Python Logic: `v["GMEG Parallel Force Fp (N)"]v["Internal Gear Radius (m)"]` Live Evaluation:* [ROUTE: GRID] 218622.8571*1.9099 = 417,538.9006
☰	$ \eta_{loss} $	Operational Efficiency (%)	0.89	View Help Guide Purpose: Torque delivery based on adjustable user inefficiency setting Logic: Applies the baseline mechanical loss/friction coefficient to the system. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\eta_{loss} = \eta_{\text{GMEG}}$ Python Logic: `v["GMEG Efficiency (%)"]` Live Evaluation: [ROUTE: GRID] 0.8884 = 0.8884
☰	$ \tau_{GMEG,final} $	Final GMEG Output (Nm)	370,941.56	View Help Guide Purpose: Enabler torque delivery based on operational inefficiency Logic: The net, real-world usable torque generated by this single enabler after losses. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\tau_{GMEG,final} = \tau_{GMEG} \times \eta_{loss}$ Python Logic: `v["GMEG Nm Output (Nm)"]v["Operational Efficiency (%)"]` Live Evaluation:* [ROUTE: GRID] 417538.9006*0.8884 = 370,941.5593
☰	$ \Sigma\tau_{GMEG} $	Total GMEG Output per Segment (Nm)	741,883.12	View Help Guide Purpose: Total potential torque delivery of the total train with all enablers in the segment Logic: Aggregates the torque from every enabler in the train for this specific moment in time to find the total system output. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\Sigma\tau_{GMEG} = v_pre\Sigma\tau_{GMEG}+\tau_{GMEG,final}$ Python Logic: `v_prev["Total GMEG Output per Segment (Nm)"]+v["Final GMEG Output (Nm)"]` Live Evaluation: [ROUTE: GRID] 370941.5593+370941.5593 = 741,883.1187
☰	$ \tau_{def} $	Torque Deficit (Nm)	29,118.91	View Help Guide Purpose: Total torque delivery from the gravity enabler train minus the base load torque delivery requirement Logic: Compares the generated torque against the required load to identify structural power shortages. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\tau_{def} = \tau_{GMEG,final}-(\tau_{\text{out}}/N_{\text{enablers}})$ Python Logic: `v["Final GMEG Output (Nm)"]-(v["GMEG Output Torque (Nm)"]/v["Number of Gravity Enablers"])` Live Evaluation: [ROUTE: GRID] 370941.5593-(2392758.5285/7.0000) = 29,118.9124
☰	$ \tau_{\tau_def} $	Total Torque Deficit (Nm)	58,237.82	View Help Guide Purpose: Accounting for where negative values may influence total torque deficit Logic: Aggregates the generated torque against the required load to identify structural power shortages. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\tau_{\tau_def} = \tau_{def}+v_pre\tau_{\tau_def}$ Python Logic: `v["Torque Deficit (Nm)"]+v_prev["Total Torque Deficit (Nm)"]` Live Evaluation: [ROUTE: GRID] 29118.9124+29118.9124 = 58,237.8248
☰	$ \tau_{gear} $	Gear System Torque (Nm)	0.00	View Help Guide Purpose: Torque experienced by the DLLS per enabler during rotation cycles Logic: 0 if v["Status"] == 1 else v["Horizontal Distance X final (m)"] * v["Gravitational Force Fg (N)"] Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\tau_{gear} = IF(\text{Status}==1,0,X_{final} \times F_g)$ Python Logic: `0 if v["Status"] == 1 else v["Horizontal Distance X final (m)"] * v["Gravitational Force Fg (N)"]` Live Evaluation: [ROUTE: GRID] 0 if 1.0000 == 1 else 0.0502 * 437245.7143 = 0.0000
☰	$ \tau $	Absolute Gear System Torque (Nm)	0.00	View Help Guide Purpose: Absolute values to represent positive values for torque experienced by the DLLS Logic: 0 if v["Status"] == 1 else abs(v["Gear System Torque (Nm)"]) Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $` = IF(\text{Status}==1,0,ABS(\tau_{gear}))$ Python Logic: `0 if v["Status"] == 1 else abs(v["Gear System Torque (Nm)"])` Live Evaluation: [ROUTE: GRID] 0 if 1.0000 == 1 else abs(0.0000) = 0.0000
☰	$ \tau_{gear,train} $	Enabler train Absolute Gear System Torque (Nm)	0.00	View Help Guide Purpose: 0 Logic: Sums the absolute torque across all enablers to find the total stress on the rotation gears for this time step. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $\tau_{gear,train} = `+v_pre\tau_{gear,train}$ Python Logic: `v["Absolute Gear System Torque (Nm)"]+v_prev["Enabler train Absolute Gear System Torque (Nm)"]` Live Evaluation: [ROUTE: GRID] 0.0000+0.0000 = 0.0000
☰	$ W_{DLLS} $	Work Done by DLLS Joule per Segment (J)	0.00	View Help Guide Purpose: Work done by the DLLS for that segment time frame, based on the angle per segment Logic: 0 if v["Status"] == 1 else v["Absolute Gear System Torque (Nm)"] * v["Angle Per Segment radians (rad/s)"] Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $W_{DLLS} = IF(\text{Status}==1,0,` \times \text{Angle Per Segment radians (rad/s)})$ Python Logic: `0 if v["Status"] == 1 else v["Absolute Gear System Torque (Nm)"] * v["Angle Per Segment radians (rad/s)"]` Live Evaluation: [ROUTE: GRID] 0 if 1.0000 == 1 else 0.0000 * 0.0175 = 0.0000
☰	$ TW_{DLLS} $	Total Work Done by DLLS Joule per Segment (J)	0.00	View Help Guide Purpose: Count of the required work impacting the DLLS during a TAR Logic: Aggregates the rotational torque across the train during the rotation phase. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $TW_{DLLS} = W_{DLLS}+v_preTW_{DLLS}$ Python Logic: `v["Work Done by DLLS Joule per Segment (J)"]+v_prev["Total Work Done by DLLS Joule per Segment (J)"]` Live Evaluation: [ROUTE: GRID] 0.0000+0.0000 = 0.0000
☰	$ I_{en} $	Moment of inertia per enabler (kg.m2)	0.00	View Help Guide Purpose: Modelling inertia during a track arc rotation based on each enablers' position on the track Logic: 0 if v["Status"] == 1 else ((v["TOTAL WEIGHT (KG)"] / v["Number of Gravity Enablers"]) * (v["Horizontal Distance X final (m)"] 2)) Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $I_{en} = IF(\text{Status}==1,0,((M_{\text{total}}/N_{\text{enablers}}) \times (X_{final}^2)))$ Python Logic:** `0 if v["Status"] == 1 else ((v["TOTAL WEIGHT (KG)"] / v["Number of Gravity Enablers"]) * (v["Horizontal Distance X final (m)"] 2))` Live Evaluation:** [ROUTE: GRID] 0 if 1.0000 == 1 else ((312000.0000 / 7.0000) * (0.0502 ** 2)) = 0.0000
☰	$ I_{train} $	Enabler train Moment of inertia (kg.m2)	0.00	View Help Guide Purpose: Running total inertia based on all enablers Logic: Aggregates the individual inertia values to find the total resistance the system must overcome to swivel the track. Type: Calculated (Math Output) Render on Grids: Rotational Torque Mathematical Formula: $I_{train} = I_{en}+v_preI_{train}$ Python Logic: `v["Moment of inertia per enabler (kg.m2)"]+v_prev["Enabler train Moment of inertia (kg.m2)"]` Live Evaluation: [ROUTE: GRID] 0.0000+0.0000 = 0.0000
▼ 5. ENERGY BALANCE BLUEPRINTS - S1 E1 Base
☰	$ t_{seg} $	Time per segment (s)	0.02	View Help Guide Purpose: Time period needed for energy balance calculations Logic: Divides the total track lift time by the total degrees of tilt to find the exact duration of a single simulation frame. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $t_{seg} = t_{\text{lift}}/(\theta_{\text{tilt}} \times 2)$ Python Logic: `v["Lift Time (s)"]/(v["Angle tilt (degrees)"]2)` Live Evaluation:* [ROUTE: GRID] 1.0000/(30.0000*2) = 0.0167
☰	$ t_{total} $	Total time (s)	0.02	View Help Guide Purpose: Accumlituve time per segment for timelime progression Logic: Tracks the running total of seconds elapsed since Time = 0. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $t_{total} = t_{seg}$ Python Logic: `v["Time per segment (s)"]` Live Evaluation: [ROUTE: GRID] 0.0167 = 0.0167
☰	$ W_g $	Work Done by Gravity (J)	26,234.74	View Help Guide Purpose: Work done calculated per segment Logic: Multiplies the parallel gravitational force (Fp) by the distance travelled (W = F x d). Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $W_g = F_p \times L_{\text{seg}}$ Python Logic: `v["GMEG Parallel Force Fp (N)"]v["Distance travelled per segment (m)"]` Live Evaluation:* [ROUTE: GRID] 218622.8571*0.1200 = 26,234.7429
☰	$ E_{trans} $	DLLS Energy transferred to GMEG (J)	0.00	View Help Guide Purpose: DLLS arc rotation energy transfer with efficiency factor Logic: Applies the DLLS mechanical transfer efficiency coefficient to the total work done by the DLLS gears. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{trans} = W_{DLLS} \times \eta_{DLLS}$ Python Logic: `v["Work Done by DLLS Joule per Segment (J)"]v["Energy Transfer Efficiency DLLS (%)"]` Live Evaluation:* [ROUTE: GRID] 0.0000*0.9000 = 0.0000
☰	$ E_{loss,fric} $	Energy Lost to Friction (J)	1,311.74	View Help Guide Purpose: Accounting for losses in gravity enabler train Logic: abs(v["Work Done by Gravity (J)"] * v["Friction factor (%)"]) Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{loss,fric} = ABS(W_g \times \mu)$ Python Logic: `abs(v["Work Done by Gravity (J)"] * v["Friction factor (%)"])` Live Evaluation: [ROUTE: GRID] abs(26234.7429 * 0.0500) = 1,311.7371
☰	$ E_{req} $	GMEG Operational Requirement (J)	20,208.04	View Help Guide Purpose: Power needed to the GMEG generator per segment Logic: Slices the total kW generator load into a micro-Joule requirement per-enabler, per-segment. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{req} = (P_{\text{out}} \times 1000) \times (1/(\theta_{\text{tilt}} \times 2)/N_{\text{enablers}})$ Python Logic: `(v["Magnetic Generator Power Output (kW)"]1000)(1/(v["Angle tilt (degrees)"]2)/v["Number of Gravity Enablers"])` Live Evaluation:* [ROUTE: GRID] (8487.37631000)(1/(30.0000*2)/7.0000) = 20,208.0389
☰	$ E_{bal} $	Energy Balance (J)	4,714.97	View Help Guide Purpose: Total output considering all inputs and outputs Logic: Subtracts the friction and generator loads from the combined energy inputs (Gravity Work + DLLS Energy). A value of 0 proves perfect equilibrium. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{bal} = W_g+E_{trans}-E_{loss,fric}-E_{req}$ Python Logic: `v["Work Done by Gravity (J)"]+v["DLLS Energy transferred to GMEG (J)"]-v["Energy Lost to Friction (J)"]-v["GMEG Operational Requirement (J)"]` Live Evaluation: [ROUTE: GRID] 26234.7429+0.0000-1311.7371-20208.0389 = 4,714.9668
☰	$ E_k $	KE for Train (J)	4,714.97	View Help Guide Purpose: Determing kinetic energy availability Logic: Inherits the net energy balance to model the kinetic state of the enabler train. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_k = E_{bal}$ Python Logic: `v["Energy Balance (J)"]` Live Evaluation: [ROUTE: GRID] 4714.9668 = 4,714.9668
☰	$ E_{k,op} $	Total KE for Train at Operational Speed (J)	4,714.97	View Help Guide Purpose: Total kinetic energy of the gravity enabler train Logic: Inherits the net energy balance to model the kinetic state of the enabler train. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{k,op} = E_{bal}$ Python Logic: `v["Energy Balance (J)"]` Live Evaluation: [ROUTE: GRID] 4714.9668 = 4,714.9668
☰	$ E_{bal,start} $	Gravitational Startup State Energy Balance (J)	24,923.01	View Help Guide Purpose: System start up with the DLLS powered externally Logic: Calculates the energy balance excluding the GMEG Operational Requirement to show how the system accelerates from a dead stop. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{bal,start} = W_g+E_{trans}-E_{loss,fric}$ Python Logic: `v["Work Done by Gravity (J)"]+v["DLLS Energy transferred to GMEG (J)"]-v["Energy Lost to Friction (J)"]` Live Evaluation: [ROUTE: GRID] 26234.7429+0.0000-1311.7371 = 24,923.0057
☰	$ \Sigma E_{bal,start} $	Gravitational Startup State Accumulative Energy Balance (J)	0.00	View Help Guide Purpose: Expected increase or decrease in the energy of the enabler train Logic: Sums the sequential Startup State balances over time. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $\Sigma E_{bal,start} = \text{Gravitational Startup State Energy Balance (J)}$ Python Logic: `v["Gravitational Startup State Energy Balance (J)"]` Live Evaluation: [ROUTE: GRID] 0.0000 = 0.0000
☰	$ v_{start} $	Gravitational Startup State Velocity (m/s)	0.00	View Help Guide Purpose: Expected increase or decrease in the speed of the enabler train Logic: Calculates velocity using v = SQRT(2 * KE / Total Mass), based on the Accumulative Startup Energy. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $v_{start} = \sqrt{2 \times \Sigma E_{bal,start}/M_{\text{total}})$ Python Logic: `SQRT(2v["Gravitational Startup State Accumulative Energy Balance (J)"]/v["TOTAL WEIGHT (KG)"])` Live Evaluation:* [ROUTE: GRID] SQRT(2*0.0000/312000.0000) = 0.0000
☰	$ E_{bal,op} $	Operational State Steady Velocity Energy Balance (J)	4,714.97	View Help Guide Purpose: Total output considering all inputs and outputs at normal operational speed Logic: Identical to the main Energy Balance formula; proves long-term sustainability under full electrical load. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{bal,op} = W_g+E_{trans}-E_{loss,fric}-E_{req}$ Python Logic: `v["Work Done by Gravity (J)"]+v["DLLS Energy transferred to GMEG (J)"]-v["Energy Lost to Friction (J)"]-v["GMEG Operational Requirement (J)"]` Live Evaluation: [ROUTE: GRID] 26234.7429+0.0000-1311.7371-20208.0389 = 4,714.9668
☰	$ \Sigma E_{bal,op} $	Operational State Steady Velocity Accumulative Energy Balance (J)	4,714.97	View Help Guide Purpose: Expected increase or decrease in the energy of the enabler train Logic: Sums the sequential Operational State balances over time. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $\Sigma E_{bal,op} = E_{bal,op}$ Python Logic: `v["Operational State Steady Velocity Energy Balance (J)"]` Live Evaluation: [ROUTE: GRID] 4714.9668 = 4,714.9668
☰	$ v_{op} $	Operational State Steady Velocity (m/s)	0.17	View Help Guide Purpose: Expected increase or decrease in the speed of the enabler train Logic: UNUSED Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $v_{op} = \sqrt{2 \times \Sigma E_{bal,op}/M_{\text{total}})$ Python Logic: `SQRT(2v["Operational State Steady Velocity Accumulative Energy Balance (J)"]/v["TOTAL WEIGHT (KG)"])` Live Evaluation:* [ROUTE: GRID] SQRT(2*4714.9668/312000.0000) = 0.1739
☰	$ E_{in,supp} $	Additional Support System Input (J)	0.00	View Help Guide Purpose: Determining impact on the system when adding additional energy through a start up motor Logic: Translates the available excess support kW into Joules per segment. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $N/A$ Python Logic: `N/A` Live Evaluation: N/A (Input Variable)
☰	$ E_{bal,supp} $	Additional Support System Energy Balance (J)	0.00	View Help Guide Purpose: Total output considering all inputs and outputs Logic: Adds the auxiliary support energy to the standard Operational Energy Balance. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $N/A$ Python Logic: `N/A` Live Evaluation: N/A (Input Variable)
☰	$ \Sigma E_{bal,supp} $	Additional Support System Accumulative Energy Balance (J)	0.00	View Help Guide Purpose: Expected increase or decrease in the energy of the enabler train with the additional start up energy Logic: Sums the auxiliary inputs and balances across the time series. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $N/A$ Python Logic: `N/A` Live Evaluation: N/A (Input Variable)
☰	$ v_{supp} $	Additional Support System Velocity (m/s)	0.00	View Help Guide Purpose: Expected increase or decrease in the speed of the enabler train Logic: Calculates velocity using v = SQRT(2 * KE / Total Mass), based on the Accumulative Support Energy. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $N/A$ Python Logic: `N/A` Live Evaluation: N/A (Input Variable)
▼ 5. ENERGY BALANCE BLUEPRINTS - S1 E2 Loop
☰	$ t_{seg} $	Time per segment (s)	0.02	View Help Guide Purpose: Time period needed for energy balance calculations Logic: UNUSED (Inherited from Enabler 1 to ensure a locked time step). Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $t_{seg} = v_pret_{seg}$ Python Logic: `v_prev["Time per segment (s)"]` Live Evaluation: [ROUTE: GRID] 0.0167 = 0.0167
☰	$ t_{total} $	Total time (s)	0.02	View Help Guide Purpose: Accumlituve time per segment for timelime progression Logic: Tracks the running total of seconds elapsed since Time = 0. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $t_{total} = v_pret_{total}$ Python Logic: `v_prev["Total time (s)"]` Live Evaluation: [ROUTE: GRID] 0.0167 = 0.0167
☰	$ W_g $	Work Done by Gravity (J)	26,234.74	View Help Guide Purpose: Work done calculated per segment Logic: Multiplies the parallel gravitational force (Fp) by the distance travelled (W = F x d). Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $W_g = F_p \times L_{\text{seg}}$ Python Logic: `v["GMEG Parallel Force Fp (N)"]v["Distance travelled per segment (m)"]` Live Evaluation:* [ROUTE: GRID] 218622.8571*0.1200 = 26,234.7429
☰	$ E_{trans} $	DLLS Energy transferred to GMEG (J)	0.00	View Help Guide Purpose: DLLS arc rotation energy transfer with efficiency factor Logic: Applies the DLLS mechanical transfer efficiency coefficient to the total work done by the DLLS gears acting on Enabler 2. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{trans} = W_{DLLS} \times \eta_{DLLS}$ Python Logic: `v["Work Done by DLLS Joule per Segment (J)"]v["Energy Transfer Efficiency DLLS (%)"]` Live Evaluation:* [ROUTE: GRID] 0.0000*0.9000 = 0.0000
☰	$ E_{loss,fric} $	Energy Lost to Friction (J)	1,311.74	View Help Guide Purpose: Accounting for losses in gravity enabler train Logic: Applies the user-defined friction percentage directly to the raw work done by gravity. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{loss,fric} = W_g \times \mu$ Python Logic: `v["Work Done by Gravity (J)"]v["Friction factor (%)"]` Live Evaluation:* [ROUTE: GRID] 26234.7429*0.0500 = 1,311.7371
☰	$ E_{req} $	GMEG Operational Requirement (J)	20,208.04	View Help Guide Purpose: Power needed to the GMEG generator per segment Logic: Slices the total kW generator load into a micro-Joule requirement per-enabler, per-segment. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{req} = (P_{\text{out}} \times 1000) \times (1/(\theta_{\text{tilt}} \times 2)/N_{\text{enablers}})$ Python Logic: `(v["Magnetic Generator Power Output (kW)"]1000)(1/(v["Angle tilt (degrees)"]2)/v["Number of Gravity Enablers"])` Live Evaluation:* [ROUTE: GRID] (8487.37631000)(1/(30.0000*2)/7.0000) = 20,208.0389
☰	$ E_{bal} $	Energy Balance (J)	4,714.97	View Help Guide Purpose: Total output considering all inputs and outputs Logic: Subtracts the friction and generator loads from the combined energy inputs (Gravity Work + DLLS Energy). Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{bal} = W_g+E_{trans}-E_{loss,fric}-E_{req}$ Python Logic: `v["Work Done by Gravity (J)"]+v["DLLS Energy transferred to GMEG (J)"]-v["Energy Lost to Friction (J)"]-v["GMEG Operational Requirement (J)"]` Live Evaluation: [ROUTE: GRID] 26234.7429+0.0000-1311.7371-20208.0389 = 4,714.9668
☰	$ E_k $	KE for Train (J)	4,714.97	View Help Guide Purpose: Determing kinetic energy availability Logic: Inherits the net energy balance to model the kinetic state of the enabler train. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_k = E_{bal}$ Python Logic: `v["Energy Balance (J)"]` Live Evaluation: [ROUTE: GRID] 4714.9668 = 4,714.9668
☰	$ E_{k,op} $	Total KE for Train at Operational Speed (J)	9,429.93	View Help Guide Purpose: Total kinetic energy of the gravity enabler train Logic: Inherits the Energy Balance (J). Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{k,op} = E_{bal}+v_preE_{k,op}$ Python Logic: `v["Energy Balance (J)"]+v_prev["Total KE for Train at Operational Speed (J)"]` Live Evaluation: [ROUTE: GRID] 4714.9668+4714.9668 = 9,429.9336
☰	$ E_{bal,start} $	Gravitational Startup State Energy Balance (J)	24,923.01	View Help Guide Purpose: System start up with the DLLS powered externally Logic: Calculates the energy balance excluding the GMEG Operational Requirement to show how the system accelerates from a dead stop. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{bal,start} = W_g+E_{trans}-E_{loss,fric}$ Python Logic: `v["Work Done by Gravity (J)"]+v["DLLS Energy transferred to GMEG (J)"]-v["Energy Lost to Friction (J)"]` Live Evaluation: [ROUTE: GRID] 26234.7429+0.0000-1311.7371 = 24,923.0057
☰	$ \Sigma E_{bal,start} $	Gravitational Startup State Accumulative Energy Balance (J)	0.00	View Help Guide Purpose: Expected increase or decrease in the energy of the enabler train Logic: Sums the sequential Startup State balances over time. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $\Sigma E_{bal,start} = E_{bal,start}+v_pre\Sigma E_{bal,start}$ Python Logic: `v["Gravitational Startup State Energy Balance (J)"]+v_prev["Gravitational Startup State Accumulative Energy Balance (J)"]` Live Evaluation: [ROUTE: GRID] 0.0000+0.0000 = 0.0000
☰	$ v_{start} $	Gravitational Startup State Velocity (m/s)	0.00	View Help Guide Purpose: Expected increase or decrease in the speed of the enabler train Logic: Calculates velocity using v = SQRT(2 * KE / Total Mass), based on the Accumulative Startup Energy. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $v_{start} = \sqrt{2 \times \Sigma E_{bal,start}/M_{\text{total}})$ Python Logic: `SQRT(2v["Gravitational Startup State Accumulative Energy Balance (J)"]/v["TOTAL WEIGHT (KG)"])` Live Evaluation:* [ROUTE: GRID] SQRT(2*0.0000/312000.0000) = 0.0000
☰	$ E_{bal,op} $	Operational State Steady Velocity Energy Balance (J)	4,714.97	View Help Guide Purpose: Total output considering all inputs and outputs at normal operational speed Logic: Identical to the main Energy Balance formula; proves long-term sustainability under full electrical load. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{bal,op} = W_g+E_{trans}-E_{loss,fric}-E_{req}$ Python Logic: `v["Work Done by Gravity (J)"]+v["DLLS Energy transferred to GMEG (J)"]-v["Energy Lost to Friction (J)"]-v["GMEG Operational Requirement (J)"]` Live Evaluation: [ROUTE: GRID] 26234.7429+0.0000-1311.7371-20208.0389 = 4,714.9668
☰	$ \Sigma E_{bal,op} $	Operational State Steady Velocity Accumulative Energy Balance (J)	9,429.93	View Help Guide Purpose: Expected increase or decrease in the energy of the enabler train Logic: Sums the sequential Operational State balances over time. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $\Sigma E_{bal,op} = E_{bal,op}+v_pre\Sigma E_{bal,op}$ Python Logic: `v["Operational State Steady Velocity Energy Balance (J)"]+v_prev["Operational State Steady Velocity Accumulative Energy Balance (J)"]` Live Evaluation: [ROUTE: GRID] 4714.9668+4714.9668 = 9,429.9336
☰	$ v_{op} $	Operational State Steady Velocity (m/s)	0.25	View Help Guide Purpose: Expected increase or decrease in the speed of the enabler train Logic: UNUSED Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $v_{op} = \sqrt{2 \times \Sigma E_{bal,op}/M_{\text{total}})$ Python Logic: `SQRT(2v["Operational State Steady Velocity Accumulative Energy Balance (J)"]/v["TOTAL WEIGHT (KG)"])` Live Evaluation:* [ROUTE: GRID] SQRT(2*9429.9336/312000.0000) = 0.2459
☰	$ E_{in,supp} $	Additional Support System Input (J)	0.00	View Help Guide Purpose: Determining impact on the system when adding additional energy through a start up motor Logic: Translates the available excess support kW into Joules per segment, specifically reaching up to pull the time value from Enabler 1 (N2) to maintain a perfectly synced simulation frame. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $N/A$ Python Logic: `N/A` Live Evaluation: N/A (Input Variable)
☰	$ E_{bal,supp} $	Additional Support System Energy Balance (J)	0.00	View Help Guide Purpose: Total output considering all inputs and outputs Logic: Adds the auxiliary support energy to the standard Operational Energy Balance. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $N/A$ Python Logic: `N/A` Live Evaluation: N/A (Input Variable)
☰	$ \Sigma E_{bal,supp} $	Additional Support System Accumulative Energy Balance (J)	0.00	View Help Guide Purpose: Expected increase or decrease in the energy of the enabler train with the additional start up energy Logic: Sums the auxiliary inputs and balances across the time series. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $N/A$ Python Logic: `N/A` Live Evaluation: N/A (Input Variable)
☰	$ v_{supp} $	Additional Support System Velocity (m/s)	0.00	View Help Guide Purpose: Expected increase or decrease in the speed of the enabler train Logic: Calculates velocity using v = SQRT(2 * KE / Total Mass), based on the Accumulative Support Energy. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $N/A$ Python Logic: `N/A` Live Evaluation: N/A (Input Variable)
▼ 5. ENERGY BALANCE BLUEPRINTS - S2 E1 Transition
☰	$ t_{seg} $	Time per segment (s)	0.02	View Help Guide Purpose: Time period needed for energy balance calculations Logic: Divides the distance travelled in this segment by the desired operational velocity. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $t_{seg} = \Delta d_{TAR}/v$ Python Logic: `v["TAR Difference (m)"]/v["Operational Velocity (m/s)"]` Live Evaluation: [ROUTE: GRID] 0.1200/7.2000 = 0.0167
☰	$ t_{total} $	Total time (s)	0.03	View Help Guide Purpose: Accumlituve time per segment for timelime progression Logic: Adds the new Time per segment to the Total time inherited from the previous segment (S1). Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $t_{total} = v_prev_seg["Total time (s)"]+t_{seg}$ Python Logic: `v_prev_seg["Total time (s)"]+v["Time per segment (s)"]` Live Evaluation: [ROUTE: GRID] 0.0167+0.0167 = 0.0333
☰	$ W_g $	Work Done by Gravity (J)	26,234.74	View Help Guide Purpose: Work done calculated per segment Logic: Multiplies the parallel gravitational force (Fp) by the distance travelled (W = F x d). Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $W_g = F_p \times \Delta d_{TAR}$ Python Logic: `v["GMEG Parallel Force Fp (N)"]v["TAR Difference (m)"]` Live Evaluation:* [ROUTE: GRID] 218622.8571*0.1200 = 26,234.7429
☰	$ E_{trans} $	DLLS Energy transferred to GMEG (J)	0.00	View Help Guide Purpose: DLLS arc rotation energy transfer with efficiency factor Logic: Applies the DLLS mechanical transfer efficiency coefficient to the total work done by the DLLS gears. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{trans} = W_{DLLS} \times \eta_{DLLS}$ Python Logic: `v["Work Done by DLLS Joule per Segment (J)"]v["Energy Transfer Efficiency DLLS (%)"]` Live Evaluation:* [ROUTE: GRID] 0.0000*0.9000 = 0.0000
☰	$ E_{loss,fric} $	Energy Lost to Friction (J)	1,311.74	View Help Guide Purpose: Accounting for losses in gravity enabler train Logic: abs(v["Work Done by Gravity (J)"] * v["Friction factor (%)"]) Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{loss,fric} = ABS(W_g \times \mu)$ Python Logic: `abs(v["Work Done by Gravity (J)"] * v["Friction factor (%)"])` Live Evaluation: [ROUTE: GRID] abs(26234.7429 * 0.0500) = 1,311.7371
☰	$ E_{req} $	GMEG Operational Requirement (J)	20,208.04	View Help Guide Purpose: Power needed to the GMEG generator per segment Logic: Slices the total kW generator load into a micro-Joule requirement per-enabler, per-segment. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{req} = (P_{\text{out}} \times 1000) \times (1/(\theta_{\text{tilt}} \times 2)/N_{\text{enablers}})$ Python Logic: `(v["Magnetic Generator Power Output (kW)"]1000)(1/(v["Angle tilt (degrees)"]2)/v["Number of Gravity Enablers"])` Live Evaluation:* [ROUTE: GRID] (8487.37631000)(1/(30.0000*2)/7.0000) = 20,208.0389
☰	$ E_{bal} $	Energy Balance (J)	4,714.97	View Help Guide Purpose: Total output considering all inputs and outputs Logic: Subtracts the friction and generator loads from the combined energy inputs. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{bal} = W_g+E_{trans}-E_{loss,fric}-E_{req}$ Python Logic: `v["Work Done by Gravity (J)"]+v["DLLS Energy transferred to GMEG (J)"]-v["Energy Lost to Friction (J)"]-v["GMEG Operational Requirement (J)"]` Live Evaluation: [ROUTE: GRID] 26234.7429+0.0000-1311.7371-20208.0389 = 4,714.9668
☰	$ E_k $	KE for Train (J)	4,714.97	View Help Guide Purpose: Determing kinetic energy availability Logic: Inherits the net energy balance to model the kinetic state of the enabler train. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_k = E_{bal}$ Python Logic: `v["Energy Balance (J)"]` Live Evaluation: [ROUTE: GRID] 4714.9668 = 4,714.9668
☰	$ E_{k,op} $	Total KE for Train at Operational Speed (J)	4,714.97	View Help Guide Purpose: Total kinetic energy of the gravity enabler train Logic: Adds the new Energy Balance to the Total KE inherited from the previous segment (S1). Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{k,op} = E_{bal}$ Python Logic: `v["Energy Balance (J)"]` Live Evaluation: [ROUTE: GRID] 4714.9668 = 4,714.9668
☰	$ E_{bal,start} $	Gravitational Startup State Energy Balance (J)	24,923.01	View Help Guide Purpose: System start up with the DLLS powered externally Logic: Calculates the energy balance excluding the GMEG Operational Requirement to show how the system accelerates from a dead stop. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{bal,start} = W_g+E_{trans}-E_{loss,fric}$ Python Logic: `v["Work Done by Gravity (J)"]+v["DLLS Energy transferred to GMEG (J)"]-v["Energy Lost to Friction (J)"]` Live Evaluation: [ROUTE: GRID] 26234.7429+0.0000-1311.7371 = 24,923.0057
☰	$ \Sigma E_{bal,start} $	Gravitational Startup State Accumulative Energy Balance (J)	0.00	View Help Guide Purpose: Expected increase or decrease in the energy of the enabler train Logic: Sums the sequential Startup balances for this segment and adds them to the previous segment's total. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $\Sigma E_{bal,start} = E_{bal,start}+v_pre\Sigma E_{bal,start}$ Python Logic: `v["Gravitational Startup State Energy Balance (J)"]+v_prev["Gravitational Startup State Accumulative Energy Balance (J)"]` Live Evaluation: [ROUTE: GRID] 0.0000+0.0000 = 0.0000
☰	$ v_{start} $	Gravitational Startup State Velocity (m/s)	0.00	View Help Guide Purpose: Expected increase or decrease in the speed of the enabler train Logic: Calculates velocity using v = SQRT(2 * KE / Total Mass), based on the Accumulative Startup Energy. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $v_{start} = \sqrt{2 \times \Sigma E_{bal,start}/M_{\text{total}})$ Python Logic: `SQRT(2v["Gravitational Startup State Accumulative Energy Balance (J)"]/v["TOTAL WEIGHT (KG)"])` Live Evaluation:* [ROUTE: GRID] SQRT(2*0.0000/312000.0000) = 0.0000
☰	$ E_{bal,op} $	Operational State Steady Velocity Energy Balance (J)	4,714.97	View Help Guide Purpose: Total output considering all inputs and outputs at normal operational speed Logic: Identical to the main Energy Balance formula; proves long-term sustainability under full electrical load. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{bal,op} = W_g+E_{trans}-E_{loss,fric}-E_{req}$ Python Logic: `v["Work Done by Gravity (J)"]+v["DLLS Energy transferred to GMEG (J)"]-v["Energy Lost to Friction (J)"]-v["GMEG Operational Requirement (J)"]` Live Evaluation: [ROUTE: GRID] 26234.7429+0.0000-1311.7371-20208.0389 = 4,714.9668
☰	$ \Sigma E_{bal,op} $	Operational State Steady Velocity Accumulative Energy Balance (J)	4,714.97	View Help Guide Purpose: Expected increase or decrease in the energy of the enabler train Logic: Sums the sequential Operational State balances over time. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $\Sigma E_{bal,op} = E_{bal,op}$ Python Logic: `v["Operational State Steady Velocity Energy Balance (J)"]` Live Evaluation: [ROUTE: GRID] 4714.9668 = 4,714.9668
☰	$ v_{op} $	Operational State Steady Velocity (m/s)	0.17	View Help Guide Purpose: Expected increase or decrease in the speed of the enabler train Logic: Calculates velocity using v = SQRT(2 * KE / Total Mass), based on the Accumulative Operational Energy. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $v_{op} = \sqrt{2 \times \Sigma E_{bal,op}/M_{\text{total}})$ Python Logic: `SQRT(2v["Operational State Steady Velocity Accumulative Energy Balance (J)"]/v["TOTAL WEIGHT (KG)"])` Live Evaluation:* [ROUTE: GRID] SQRT(2*4714.9668/312000.0000) = 0.1739
☰	$ E_{in,supp} $	Additional Support System Input (J)	0.00	View Help Guide Purpose: Determining impact on the system when adding additional energy through a start up motor Logic: Translates the available excess support kW into Joules per segment. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $N/A$ Python Logic: `N/A` Live Evaluation: N/A (Input Variable)
☰	$ E_{bal,supp} $	Additional Support System Energy Balance (J)	0.00	View Help Guide Purpose: Total output considering all inputs and outputs Logic: Adds the auxiliary support energy to the standard Operational Energy Balance. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $N/A$ Python Logic: `N/A` Live Evaluation: N/A (Input Variable)
☰	$ \Sigma E_{bal,supp} $	Additional Support System Accumulative Energy Balance (J)	0.00	View Help Guide Purpose: Expected increase or decrease in the energy of the enabler train with the additional start up energy Logic: Sums the auxiliary inputs and balances across the time series. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $N/A$ Python Logic: `N/A` Live Evaluation: N/A (Input Variable)
☰	$ v_{supp} $	Additional Support System Velocity (m/s)	0.00	View Help Guide Purpose: Expected increase or decrease in the speed of the enabler train Logic: Calculates velocity using v = SQRT(2 * KE / Total Mass), based on the Accumulative Support Energy. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $N/A$ Python Logic: `N/A` Live Evaluation: N/A (Input Variable)
▼ 5. ENERGY BALANCE BLUEPRINTS - S2 E2 Cascade
☰	$ t_{seg} $	Time per segment (s)	0.02	View Help Guide Purpose: Time period needed for energy balance calculations Logic: UNUSED (Inherited from Enabler 1 to ensure a locked time step for the whole train). Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $t_{seg} = v_pret_{seg}$ Python Logic: `v_prev["Time per segment (s)"]` Live Evaluation: [ROUTE: GRID] 0.0167 = 0.0167
☰	$ t_{total} $	Total time (s)	0.03	View Help Guide Purpose: Accumlituve time per segment for timelime progression Logic: Adds the new Time per segment to the Total time inherited from the previous segment (S1). Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $t_{total} = v_pret_{total}$ Python Logic: `v_prev["Total time (s)"]` Live Evaluation: [ROUTE: GRID] 0.0333 = 0.0333
☰	$ W_g $	Work Done by Gravity (J)	26,234.74	View Help Guide Purpose: Work done calculated per segment Logic: Multiplies the parallel gravitational force (Fp) by the distance travelled (W = F x d). Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $W_g = F_p \times \Delta d_{TAR}$ Python Logic: `v["GMEG Parallel Force Fp (N)"]v["TAR Difference (m)"]` Live Evaluation:* [ROUTE: GRID] 218622.8571*0.1200 = 26,234.7429
☰	$ E_{trans} $	DLLS Energy transferred to GMEG (J)	0.00	View Help Guide Purpose: DLLS arc rotation energy transfer with efficiency factor Logic: Applies the DLLS mechanical transfer efficiency coefficient to the total work done by the DLLS gears acting on Enabler 2. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{trans} = W_{DLLS} \times \eta_{DLLS}$ Python Logic: `v["Work Done by DLLS Joule per Segment (J)"]v["Energy Transfer Efficiency DLLS (%)"]` Live Evaluation:* [ROUTE: GRID] 0.0000*0.9000 = 0.0000
☰	$ E_{loss,fric} $	Energy Lost to Friction (J)	1,311.74	View Help Guide Purpose: Accounting for losses in gravity enabler train Logic: abs(v["Work Done by Gravity (J)"] * v["Friction factor (%)"]) Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{loss,fric} = ABS(W_g \times \mu)$ Python Logic: `abs(v["Work Done by Gravity (J)"] * v["Friction factor (%)"])` Live Evaluation: [ROUTE: GRID] abs(26234.7429 * 0.0500) = 1,311.7371
☰	$ E_{req} $	GMEG Operational Requirement (J)	20,208.04	View Help Guide Purpose: Power needed to the GMEG generator per segment Logic: Slices the total kW generator load into a micro-Joule requirement per-enabler, per-segment. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{req} = (P_{\text{out}} \times 1000) \times (1/(\theta_{\text{tilt}} \times 2)/N_{\text{enablers}})$ Python Logic: `(v["Magnetic Generator Power Output (kW)"]1000)(1/(v["Angle tilt (degrees)"]2)/v["Number of Gravity Enablers"])` Live Evaluation:* [ROUTE: GRID] (8487.37631000)(1/(30.0000*2)/7.0000) = 20,208.0389
☰	$ E_{bal} $	Energy Balance (J)	4,714.97	View Help Guide Purpose: Total output considering all inputs and outputs Logic: Subtracts the friction and generator loads from the combined energy inputs (Gravity Work + DLLS Energy). Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{bal} = W_g+E_{trans}-E_{loss,fric}-E_{req}$ Python Logic: `v["Work Done by Gravity (J)"]+v["DLLS Energy transferred to GMEG (J)"]-v["Energy Lost to Friction (J)"]-v["GMEG Operational Requirement (J)"]` Live Evaluation: [ROUTE: GRID] 26234.7429+0.0000-1311.7371-20208.0389 = 4,714.9668
☰	$ E_k $	KE for Train (J)	4,714.97	View Help Guide Purpose: Determing kinetic energy availability Logic: Inherits the net energy balance to model the kinetic state of the enabler train. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_k = E_{bal}$ Python Logic: `v["Energy Balance (J)"]` Live Evaluation: [ROUTE: GRID] 4714.9668 = 4,714.9668
☰	$ E_{k,op} $	Total KE for Train at Operational Speed (J)	9,429.93	View Help Guide Purpose: Total kinetic energy of the gravity enabler train Logic: The Energy Cascade: Adds the new Energy Balance to Enabler 2's Total KE inherited from the previous segment (S1). Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{k,op} = E_k+v_preE_{k,op}$ Python Logic: `v["KE for Train (J)"]+v_prev["Total KE for Train at Operational Speed (J)"]` Live Evaluation: [ROUTE: GRID] 4714.9668+4714.9668 = 9,429.9336
☰	$ E_{bal,start} $	Gravitational Startup State Energy Balance (J)	24,923.01	View Help Guide Purpose: System start up with the DLLS powered externally Logic: Calculates the energy balance excluding the GMEG Operational Requirement to show how the system accelerates from a dead stop. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{bal,start} = W_g+E_{trans}-E_{loss,fric}$ Python Logic: `v["Work Done by Gravity (J)"]+v["DLLS Energy transferred to GMEG (J)"]-v["Energy Lost to Friction (J)"]` Live Evaluation: [ROUTE: GRID] 26234.7429+0.0000-1311.7371 = 24,923.0057
☰	$ \Sigma E_{bal,start} $	Gravitational Startup State Accumulative Energy Balance (J)	0.00	View Help Guide Purpose: Expected increase or decrease in the energy of the enabler train Logic: Sums the sequential Startup balances for this segment and adds them to the previous segment's total. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $\Sigma E_{bal,start} = E_{bal,start}+v_pre\Sigma E_{bal,start}$ Python Logic: `v["Gravitational Startup State Energy Balance (J)"]+v_prev["Gravitational Startup State Accumulative Energy Balance (J)"]` Live Evaluation: [ROUTE: GRID] 0.0000+0.0000 = 0.0000
☰	$ v_{start} $	Gravitational Startup State Velocity (m/s)	0.00	View Help Guide Purpose: Expected increase or decrease in the speed of the enabler train Logic: Calculates velocity using v = SQRT(2 * KE / Total Mass), based on the Accumulative Startup Energy. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $v_{start} = \sqrt{2 \times \Sigma E_{bal,start}/M_{\text{total}})$ Python Logic: `SQRT(2 v["Gravitational Startup State Accumulative Energy Balance (J)"]/v["TOTAL WEIGHT (KG)"])` Live Evaluation:* [ROUTE: GRID] SQRT(2 *0.0000/312000.0000) = 0.0000
☰	$ E_{bal,op} $	Operational State Steady Velocity Energy Balance (J)	4,714.97	View Help Guide Purpose: Total output considering all inputs and outputs at normal operational speed Logic: Identical to the main Energy Balance formula; proves long-term sustainability under full electrical load. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $E_{bal,op} = W_g+E_{trans}-E_{loss,fric}-E_{req}$ Python Logic: `v["Work Done by Gravity (J)"]+v["DLLS Energy transferred to GMEG (J)"]-v["Energy Lost to Friction (J)"]-v["GMEG Operational Requirement (J)"]` Live Evaluation: [ROUTE: GRID] 26234.7429+0.0000-1311.7371-20208.0389 = 4,714.9668
☰	$ \Sigma E_{bal,op} $	Operational State Steady Velocity Accumulative Energy Balance (J)	9,429.93	View Help Guide Purpose: Expected increase or decrease in the energy of the enabler train Logic: Sums the sequential Operational State balances over time. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $\Sigma E_{bal,op} = E_{bal,op}+v_pre\Sigma E_{bal,op}$ Python Logic: `v["Operational State Steady Velocity Energy Balance (J)"]+v_prev["Operational State Steady Velocity Accumulative Energy Balance (J)"]` Live Evaluation: [ROUTE: GRID] 4714.9668+4714.9668 = 9,429.9336
☰	$ v_{op} $	Operational State Steady Velocity (m/s)	0.25	View Help Guide Purpose: Expected increase or decrease in the speed of the enabler train Logic: UNUSED Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $v_{op} = \sqrt{2 \times \Sigma E_{bal,op}/M_{\text{total}})$ Python Logic: `SQRT(2v["Operational State Steady Velocity Accumulative Energy Balance (J)"]/v["TOTAL WEIGHT (KG)"])` Live Evaluation:* [ROUTE: GRID] SQRT(2*9429.9336/312000.0000) = 0.2459
☰	$ E_{in,supp} $	Additional Support System Input (J)	0.00	View Help Guide Purpose: Determining impact on the system when adding additional energy through a start up motor Logic: Translates the available excess support kW into Joules per segment, reaching up to pull the time value from Enabler 1 of this segment (N22) to maintain a perfectly synced simulation frame. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $N/A$ Python Logic: `N/A` Live Evaluation: N/A (Input Variable)
☰	$ E_{bal,supp} $	Additional Support System Energy Balance (J)	0.00	View Help Guide Purpose: Total output considering all inputs and outputs Logic: Adds the auxiliary support energy to the standard Operational Energy Balance. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $N/A$ Python Logic: `N/A` Live Evaluation: N/A (Input Variable)
☰	$ \Sigma E_{bal,supp} $	Additional Support System Accumulative Energy Balance (J)	0.00	View Help Guide Purpose: Expected increase or decrease in the energy of the enabler train with the additional start up energy Logic: Sums the auxiliary inputs and balances across the time series. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $N/A$ Python Logic: `N/A` Live Evaluation: N/A (Input Variable)
☰	$ v_{supp} $	Additional Support System Velocity (m/s)	0.00	View Help Guide Purpose: Expected increase or decrease in the speed of the enabler train Logic: Calculates velocity using v = SQRT(2 * KE / Total Mass), based on the Accumulative Support Energy. Type: Calculated (Math Output) Render on Grids: Energy Balance Mathematical Formula: $N/A$ Python Logic: `N/A` Live Evaluation: N/A (Input Variable)
▼ 6. OPERATIONAL TOTALS
☰	$ \Sigma \tau_{\text{seg, gmeg}} $	Segment Total GMEG Output (Nm)	2,928,277.41	View Help Guide Purpose: The segment total mechanical potential Logic: This allows for an aggregation function across the operation Type: Calculated (Math Output) Render on Grids: Operational Totals Mathematical Formula: $\Sigma \tau_{\text{seg, gmeg}} = GET_SEGMENT_FINAL("Rotational Torque", "Total GMEG Output per Segment (Nm)", N_{seg})$ Python Logic: `GET_SEGMENT_FINAL("Rotational Torque", "Total GMEG Output per Segment (Nm)", v["Segment Number"])` Live Evaluation: [ROUTE: GRID] GET_SEGMENT_FINAL("Rotational Torque", "Total GMEG Output per Segment (Nm)", 1.0000) = 2,928,277.4117
☰	$ W_{\text{seg, work}} $	Segment Work Done by DLLS Joule (J)	0.00	View Help Guide Purpose: The segment total of work done to perform a Track Arc Rotation Logic: This allows for an aggregation function across the operation to size the DLLS Type: Calculated (Math Output) Render on Grids: Operational Totals Mathematical Formula: $W_{\text{seg, work}} = GET_SEGMENT_FINAL("Rotational Torque", "Total Work Done by DLLS Joule per Segment (J)", N_{seg})$ Python Logic: `GET_SEGMENT_FINAL("Rotational Torque", "Total Work Done by DLLS Joule per Segment (J)", v["Segment Number"])` Live Evaluation: [ROUTE: GRID] GET_SEGMENT_FINAL("Rotational Torque", "Total Work Done by DLLS Joule per Segment (J)", 1.0000) = 0.0000
☰	$ \tau_{\text{seg, train}} $	Segment Enabler train Absolute Gear System Torque (Nm)	0.00	View Help Guide Purpose: The segment total the operational torque to drive a Track Arc Rotation Logic: This allows for an aggregation function across the operation to size the DLLS Type: Calculated (Math Output) Render on Grids: Operational Totals Mathematical Formula: $\tau_{\text{seg, train}} = GET_SEGMENT_FINAL("Rotational Torque", "Enabler train Absolute Gear System Torque (Nm)", N_{seg})$ Python Logic: `GET_SEGMENT_FINAL("Rotational Torque", "Enabler train Absolute Gear System Torque (Nm)", v["Segment Number"])` Live Evaluation: [ROUTE: GRID] GET_SEGMENT_FINAL("Rotational Torque", "Enabler train Absolute Gear System Torque (Nm)", 1.0000) = 0.0000
☰	$ \Sigma E_{\text{seg, gpe}} $	Segment Total Gravitational Potential Energy GPE of all Enablers (J)	459,149.66	View Help Guide Purpose: The segment total GPE of the enabler train Logic: This allows for an aggregation function across the operation to compare the mgh model in comparison to the Fp model Type: Calculated (Math Output) Render on Grids: Operational Totals Mathematical Formula: $\Sigma E_{\text{seg, gpe}} = GET_SEGMENT_FINAL("Rotational Torque", "Total Gravitational Potential Energy GPE of all Enablers (J)", N_{seg})$ Python Logic: `GET_SEGMENT_FINAL("Rotational Torque", "Total Gravitational Potential Energy GPE of all Enablers (J)", v["Segment Number"])` Live Evaluation: [ROUTE: GRID] GET_SEGMENT_FINAL("Rotational Torque", "Total Gravitational Potential Energy GPE of all Enablers (J)", 1.0000) = 459,149.6586
☰	$ I_{\text{seg, train}} $	Segment Enabler train Moment of inertia (kg.m2)	0.00	View Help Guide Purpose: The segment total inertia of the enabler train Logic: This allows for an aggregation function across the operation to size the DLLS Type: Calculated (Math Output) Render on Grids: Operational Totals Mathematical Formula: $I_{\text{seg, train}} = GET_SEGMENT_FINAL("Rotational Torque", "Enabler train Moment of inertia (kg.m2)", N_{seg})$ Python Logic: `GET_SEGMENT_FINAL("Rotational Torque", "Enabler train Moment of inertia (kg.m2)", v["Segment Number"])` Live Evaluation: [ROUTE: GRID] GET_SEGMENT_FINAL("Rotational Torque", "Enabler train Moment of inertia (kg.m2)", 1.0000) = 0.0000
☰	$ \Sigma E_{\text{seg, ke}} $	Segment Total KE for Train at Operational Speed (J)	55,290.28	View Help Guide Purpose: The segment total kinetic energy of the enabler train Logic: This allows for an aggregation function across the operation Type: Calculated (Math Output) Render on Grids: Operational Totals Mathematical Formula: $\Sigma E_{\text{seg, ke}} = GET_SEGMENT_FINAL("Energy Balance", "Total KE for Train at Operational Speed (J)", N_{seg})$ Python Logic: `GET_SEGMENT_FINAL("Energy Balance", "Total KE for Train at Operational Speed (J)", v["Segment Number"])` Live Evaluation: [ROUTE: GRID] GET_SEGMENT_FINAL("Energy Balance", "Total KE for Train at Operational Speed (J)", 1.0000) = 55,290.2846
☰	$ v_{\text{seg, start}} $	Segment Gravitational Startup State Velocity (m/s)	0.00	View Help Guide Purpose: The segment total velocity Logic: This allows for an aggregation function across the operation to understand speed increase during operation and to size the KETS Type: Calculated (Math Output) Render on Grids: Operational Totals Mathematical Formula: $v_{\text{seg, start}} = GET_SEGMENT_FINAL("Energy Balance", "Gravitational Startup State Velocity (m/s)", N_{seg})$ Python Logic: `GET_SEGMENT_FINAL("Energy Balance", "Gravitational Startup State Velocity (m/s)", v["Segment Number"])` Live Evaluation: [ROUTE: GRID] GET_SEGMENT_FINAL("Energy Balance", "Gravitational Startup State Velocity (m/s)", 1.0000) = 0.0000
☰	$ \eta_{\text{seg, op}} $	Segment Operational State Steady Velocity (m/s)	0.60	View Help Guide Purpose: The segment total velocity during normal operation Logic: This allows for an aggregation function across the operation to size the KETS Type: Calculated (Math Output) Render on Grids: Operational Totals Mathematical Formula: $\eta_{\text{seg, op}} = GET_SEGMENT_FINAL("Energy Balance", "Operational State Steady Velocity (m/s)",N_{seg})$ Python Logic: `GET_SEGMENT_FINAL("Energy Balance", "Operational State Steady Velocity (m/s)",v["Segment Number"])` Live Evaluation: [ROUTE: GRID] GET_SEGMENT_FINAL("Energy Balance", "Operational State Steady Velocity (m/s)",1.0000) = 0.5953
☰	$ \Sigma E_{\text{seg, op}} $	Segment Operational State Steady Velocity Accumulative Energy Balance (J)	55,290.28	View Help Guide Purpose: None Logic: None Type: Calculated (Math Output) Render on Grids: Operational Totals Mathematical Formula: $\Sigma E_{\text{seg, op}} = GET_SEGMENT_FINAL("Energy Balance", "Operational State Steady Velocity Accumulative Energy Balance (J)",N_{seg})$ Python Logic: `GET_SEGMENT_FINAL("Energy Balance", "Operational State Steady Velocity Accumulative Energy Balance (J)",v["Segment Number"])` Live Evaluation: [ROUTE: GRID] GET_SEGMENT_FINAL("Energy Balance", "Operational State Steady Velocity Accumulative Energy Balance (J)",1.0000) = 55,290.2846
☰	$ X_{\text{seg, min}} $	Segment Min Lever Arm (m)	0.00	View Help Guide Purpose: None Logic: None Type: Calculated (Math Output) Render on Grids: Operational Totals Mathematical Formula: $GET_SEGMENT_FINAL("Rotational Torque", "Min Lever Arm (m)", N_{seg})$ Python Logic: `GET_SEGMENT_FINAL("Rotational Torque", "Min Lever Arm (m)", v["Segment Number"])` Live Evaluation: [ROUTE: GRID] GET_SEGMENT_FINAL("Rotational Torque", "Min Lever Arm (m)", 1.0000) = 0.0000
☰	$ X_{\text{seg, max}} $	Segment Max Lever Arm (m)	0.00	View Help Guide Purpose: None Logic: None Type: Calculated (Math Output) Render on Grids: Operational Totals Mathematical Formula: $GET_SEGMENT_FINAL("Rotational Torque", "Max Lever Arm (m)", N_{seg})$ Python Logic: `GET_SEGMENT_FINAL("Rotational Torque", "Max Lever Arm (m)", v["Segment Number"])` Live Evaluation: [ROUTE: GRID] GET_SEGMENT_FINAL("Rotational Torque", "Max Lever Arm (m)", 1.0000) = 0.0000

Add New Variable & Layout Control

Global Find & Replace

✏️ Edit Variable

🔒 Isolated Bucket & Aggregator