| ▼ 1. MASTER GRID SETTINGS | ||||
| ☰ | \( T_{seg} \) | GRID Target Segments |
View Help GuidePurpose: 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/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( N_{\text{enablers}} \) | GRID Enablers Per Segment | 11.00 |
View Help GuidePurpose: 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] 11.0000 = 11.0000
|
| ☰ | \( G_{\text{hz}} \) | GRID Operating Frequency Hz | 64.00 |
View Help GuidePurpose: 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)"]*2Live Evaluation: [ROUTE: GRID] 32.0000*2 = 64.0000
|
| ▼ 2. MASTER SEQUENCE BLUEPRINTS - S1 E1 Base | ||||
| ☰ | \( Rev \) | Revolution |
View Help GuidePurpose: 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/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( C \) | Cycle |
View Help GuidePurpose: 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/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( N_{seg} \) | Segment Number |
View Help GuidePurpose: 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/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( N_{en} \) | Enabler Number |
View Help GuidePurpose: 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/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( P \) | Position | Blank (0) |
View Help GuidePurpose: 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 = IF(N_{en}<(((N_{\text{enablers}}-1)/2)+1),2,IF(N_{en}==(((N_{\text{enablers}}-1)/2)+1),1,3))$$ Python Logic:
IF(v["Enabler Number"]<(((v["Number of Gravity Enablers"]-1)/2)+1),2,IF(v["Enabler Number"]==(((v["Number of Gravity Enablers"]-1)/2)+1),1,3))Live Evaluation: Error calculating preview: '<' not supported between instances of 'str' and 'float'
|
| ☰ | \( \theta_{slant} \) | Track Slant (degree) | 32.00 |
View Help GuidePurpose: 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] 32.0000 = 32.0000
|
| ☰ | \( S_{track} \) | Track Section | Straight Track (1) |
View Help GuidePurpose: 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} = IF(d_{track}<=L_{s1},1,IF(d_{track}<L_{s2},2,IF(d_{track}<=L_{c1},1,IF(d_{track}<L_{c2},2,0))))$$ Python Logic:
IF(v["Distance on track (m)"]<=v["Physical End Straight1 (m)"],1,IF(v["Distance on track (m)"]<v["Physical End Corner1 (m)"],2,IF(v["Distance on track (m)"]<=v["Physical End Straight2 (m)"],1,IF(v["Distance on track (m)"]<v["Physical End Corner2 (m)"],2,0))))Live Evaluation: [ROUTE: GRID] IF(0.0000<=6.0000,1,IF(0.0000<12.4000,2,IF(0.0000<=18.4000,1,IF(0.0000<24.8000,2,0)))) = 1.0000
|
| ☰ | \( \text{Status} \) | Status | Idle (1) |
View Help GuidePurpose: 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} = IF(d_{ce}< R_{z1, start},1,IF(d_{ce}<R_{z1, end},2,IF(d_{ce}<R_{z2, start},1,IF(d_{ce}<R_{z2, end},2,0))))$$ Python Logic:
IF(v["Centre Enabler Distance (m)"]< v["RotZone1 Start (m)"],1,IF(v["Centre Enabler Distance (m)"]<v["RotZone1 End (m)"],2,IF(v["Centre Enabler Distance (m)"]<v["RotZone2 Start (m)"],1,IF(v["Centre Enabler Distance (m)"]<v["RotZone2 End (m)"],2,0))))Live Evaluation: [ROUTE: GRID] IF(2.9825< 5.0400,1,IF(2.9825<13.3600,2,IF(2.9825<17.4400,1,IF(2.9825<25.7600,2,0)))) = 1.0000
|
| ▼ 2. MASTER SEQUENCE BLUEPRINTS - S1 E2 Loop | ||||
| ☰ | \( Rev \) | Revolution | 1.00 |
View Help GuidePurpose: 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 GuidePurpose: 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 GuidePurpose: 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 | 0.00 |
View Help GuidePurpose: 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"]+1Live Evaluation: Error calculating preview: can only concatenate str (not "int") to str
|
| ☰ | \( P \) | Position | Back (2) |
View Help GuidePurpose: 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 = IF(N_{en}<(((N_{\text{enablers}}-1)/2)+1),2,IF(N_{en}==(((N_{\text{enablers}}-1)/2)+1),1,3))$$ Python Logic:
IF(v["Enabler Number"]<(((v["Number of Gravity Enablers"]-1)/2)+1),2,IF(v["Enabler Number"]==(((v["Number of Gravity Enablers"]-1)/2)+1),1,3))Live Evaluation: [ROUTE: GRID] IF(2.0000<(((11.0000-1)/2)+1),2,IF(2.0000==(((11.0000-1)/2)+1),1,3)) = 2.0000
|
| ☰ | \( \theta_{slant} \) | Track Slant (degree) | 32.00 |
View Help GuidePurpose: 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] 32.0000 = 32.0000
|
| ☰ | \( S_{track} \) | Track Section | Straight Track (1) |
View Help GuidePurpose: 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} = IF(d_{track}<=L_{s1},1,IF(d_{track}<L_{s2},2,IF(d_{track}<=L_{c1},1,IF(d_{track}<L_{c2},2,0))))$$ Python Logic:
IF(v["Distance on track (m)"]<=v["Physical End Straight1 (m)"],1,IF(v["Distance on track (m)"]<v["Physical End Corner1 (m)"],2,IF(v["Distance on track (m)"]<=v["Physical End Straight2 (m)"],1,IF(v["Distance on track (m)"]<v["Physical End Corner2 (m)"],2,0))))Live Evaluation: [ROUTE: GRID] IF(0.5965<=6.0000,1,IF(0.5965<12.4000,2,IF(0.5965<=18.4000,1,IF(0.5965<24.8000,2,0)))) = 1.0000
|
| ☰ | \( \text{Status} \) | Status | Idle (1) |
View Help GuidePurpose: 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} = IF(d_{ce}< R_{z1, start},1,IF(d_{ce}<R_{z1, end},2,IF(d_{ce}<R_{z2, start},1,IF(d_{ce}<R_{z2, end},2,0))))$$ Python Logic:
IF(v["Centre Enabler Distance (m)"]< v["RotZone1 Start (m)"],1,IF(v["Centre Enabler Distance (m)"]<v["RotZone1 End (m)"],2,IF(v["Centre Enabler Distance (m)"]<v["RotZone2 Start (m)"],1,IF(v["Centre Enabler Distance (m)"]<v["RotZone2 End (m)"],2,0))))Live Evaluation: [ROUTE: GRID] IF(2.9825< 5.0400,1,IF(2.9825<13.3600,2,IF(2.9825<17.4400,1,IF(2.9825<25.7600,2,0)))) = 1.0000
|
| ▼ 2. MASTER SEQUENCE BLUEPRINTS - S2 E1 Transition | ||||
| ☰ | \( Rev \) | Revolution | 1.00 |
View Help GuidePurpose: 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 = IF(v_prev_seg["TAR Centre Enabler Distance (m)"] >= (R_{z2, end} - 0.001), v_prev_seg["Revolution"] + 1, v_prev_seg["Revolution"])$$ Python Logic:
IF(v_prev_seg["TAR Centre Enabler Distance (m)"] >= (v["RotZone2 End (m)"] - 0.001), v_prev_seg["Revolution"] + 1, v_prev_seg["Revolution"])Live Evaluation: [ROUTE: GRID] IF(2.9825 >= (25.7600 - 0.001), 1.0000 + 1, 1.0000) = 1.0000
|
| ☰ | \( C \) | Cycle | 1.00 |
View Help GuidePurpose: 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 = IF(P_{TAR,ce}<R_{z1, end},1,
IF(P_{TAR,ce}<R_{z2, end},2,0))$$ Python Logic:
IF(v["TAR Centre Enabler Distance (m)"]<v["RotZone1 End (m)"],1,
IF(v["TAR Centre Enabler Distance (m)"]<v["RotZone2 End (m)"],2,0))Live Evaluation: [ROUTE: GRID] IF(3.1125<13.3600,1,
IF(3.1125<25.7600,2,0)) = 1.0000
|
| ☰ | \( N_{seg} \) | Segment Number | 3.00 |
View Help GuidePurpose: 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} = N_{seg}+1$$ Python Logic:
v["Segment Number"]+1Live Evaluation: [ROUTE: GRID] 2.0000+1 = 3.0000
|
| ☰ | \( N_{en} \) | Enabler Number | 0.00 |
View Help GuidePurpose: 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: Error calculating preview: could not convert string to float: 'All'
|
| ☰ | \( P \) | Position | Front (3) |
View Help GuidePurpose: 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] 3.0000 = 3.0000
|
| ☰ | \( \theta_{slant} \) | Track Slant (degree) | 32.00 |
View Help GuidePurpose: 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} = IF(P_{TAR,ce}<=R_{z1, start},\theta_{\text{tilt}},IF(P_{TAR,ce}<R_{z1, end},v_prev_seg["Track Slant (degree)"]-1,IF(P_{TAR,ce}<=R_{z2, start},-\theta_{\text{tilt}},IF(P_{TAR,ce}<R_{z2, end},v_prev_seg["Track Slant (degree)"]+1,0))))$$ Python Logic:
IF(v["TAR Centre Enabler Distance (m)"]<=v["RotZone1 Start (m)"],v["Angle tilt (degrees)"],IF(v["TAR Centre Enabler Distance (m)"]<v["RotZone1 End (m)"],v_prev_seg["Track Slant (degree)"]-1,IF(v["TAR Centre Enabler Distance (m)"]<=v["RotZone2 Start (m)"],-v["Angle tilt (degrees)"],IF(v["TAR Centre Enabler Distance (m)"]<v["RotZone2 End (m)"],v_prev_seg["Track Slant (degree)"]+1,0))))Live Evaluation: [ROUTE: GRID] IF(3.1125<=5.0400,32.0000,IF(3.1125<13.3600,32.0000-1,IF(3.1125<=17.4400,-32.0000,IF(3.1125<25.7600,32.0000+1,0)))) = 32.0000
|
| ☰ | \( S_{track} \) | Track Section | Straight Track (1) |
View Help GuidePurpose: 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} = IF(d_{track}<=L_{s1},1,IF(d_{track}<L_{s2},2,IF(d_{track}<=L_{c1},1,IF(d_{track}<L_{c2},2,0))))$$ Python Logic:
IF(v["Distance on track (m)"]<=v["Physical End Straight1 (m)"],1,IF(v["Distance on track (m)"]<v["Physical End Corner1 (m)"],2,IF(v["Distance on track (m)"]<=v["Physical End Straight2 (m)"],1,IF(v["Distance on track (m)"]<v["Physical End Corner2 (m)"],2,0))))Live Evaluation: [ROUTE: GRID] IF(0.1300<=6.0000,1,IF(0.1300<12.4000,2,IF(0.1300<=18.4000,1,IF(0.1300<24.8000,2,0)))) = 1.0000
|
| ☰ | \( \text{Status} \) | Status | Idle (1) |
View Help GuidePurpose: 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} = IF(d_{ce}< R_{z1, start},1,IF(d_{ce}<R_{z1, end},2,IF(d_{ce}<R_{z2, start},1,IF(d_{ce}<R_{z2, end},2,0))))$$ Python Logic:
IF(v["Centre Enabler Distance (m)"]< v["RotZone1 Start (m)"],1,IF(v["Centre Enabler Distance (m)"]<v["RotZone1 End (m)"],2,IF(v["Centre Enabler Distance (m)"]<v["RotZone2 Start (m)"],1,IF(v["Centre Enabler Distance (m)"]<v["RotZone2 End (m)"],2,0))))Live Evaluation: [ROUTE: GRID] IF(3.1125< 5.0400,1,IF(3.1125<13.3600,2,IF(3.1125<17.4400,1,IF(3.1125<25.7600,2,0)))) = 1.0000
|
| ▼ 2. MASTER SEQUENCE BLUEPRINTS - S2 E2 Cascade | ||||
| ☰ | \( Rev \) | Revolution | 1.00 |
View Help GuidePurpose: 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 GuidePurpose: 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 GuidePurpose: 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 GuidePurpose: 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 GuidePurpose: 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) | 32.00 |
View Help GuidePurpose: 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] 32.0000 = 32.0000
|
| ☰ | \( S_{track} \) | Track Section | Straight Track (1) |
View Help GuidePurpose: 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} = IF(d_{track}<=L_{s1},1,IF(d_{track}<L_{s2},2,IF(d_{track}<=L_{c1},1,IF(d_{track}<L_{c2},2,0))))$$ Python Logic:
IF(v["Distance on track (m)"]<=v["Physical End Straight1 (m)"],1,IF(v["Distance on track (m)"]<v["Physical End Corner1 (m)"],2,IF(v["Distance on track (m)"]<=v["Physical End Straight2 (m)"],1,IF(v["Distance on track (m)"]<v["Physical End Corner2 (m)"],2,0))))Live Evaluation: [ROUTE: GRID] IF(0.7265<=6.0000,1,IF(0.7265<12.4000,2,IF(0.7265<=18.4000,1,IF(0.7265<24.8000,2,0)))) = 1.0000
|
| ☰ | \( \text{Status} \) | Status | Idle (1) |
View Help GuidePurpose: 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} = IF(d_{ce}< R_{z1, start},1,IF(d_{ce}<R_{z1, end},2,IF(d_{ce}<R_{z2, start},1,IF(d_{ce}<R_{z2, end},2,0))))$$ Python Logic:
IF(v["Centre Enabler Distance (m)"]< v["RotZone1 Start (m)"],1,IF(v["Centre Enabler Distance (m)"]<v["RotZone1 End (m)"],2,IF(v["Centre Enabler Distance (m)"]<v["RotZone2 Start (m)"],1,IF(v["Centre Enabler Distance (m)"]<v["RotZone2 End (m)"],2,0))))Live Evaluation: [ROUTE: GRID] IF(3.1125< 5.0400,1,IF(3.1125<13.3600,2,IF(3.1125<17.4400,1,IF(3.1125<25.7600,2,0)))) = 1.0000
|
| ▼ 3. SPATIAL BLUEPRINTS - S1 E1 Base | ||||
| ☰ | \( d_{track} \) | Distance on track (m) |
View Help GuidePurpose: 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: Manual Entry
Render on Grids: Spatial
Mathematical Formula:
$$\text{User Input}$$ Python Logic:
N/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( d_{ce} \) | Centre Enabler Distance (m) | 2.98 |
View Help GuidePurpose: 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
Mathematical Formula:
$$d_{ce} = ((N_{\text{enablers}}-1)/2) \times L_{\text{gap}}$$ Python Logic:
((v["Number of Gravity Enablers"]-1)/2)*v["Enabler gap length (m)"]Live Evaluation: [ROUTE: GRID] ((11.0000-1)/2)*0.5965 = 2.9825
|
| ☰ | \( \Delta d_{ce} \) | Centre Enabler Difference (m) | 0.13 |
View Help GuidePurpose: 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} = IF(d_{ce}==0, L_{\text{seg}},
IF(d_{ce}< (R_{z1, start}- 0.0001),IF((d_{ce}+ L_{\text{seg}}) > R_{z1, start}, R_{z1, start}- d_{ce}, L_{\text{seg}}),
IF(d_{ce}< (R_{z1, end}- 0.0001),IF((d_{ce}+ L_{\text{seg}}) > R_{z1, end}, R_{z1, end}- d_{ce}, L_{\text{seg}}),
IF(d_{ce}< (R_{z2, start}- 0.0001),IF((d_{ce}+ L_{\text{seg}}) > R_{z2, start}, R_{z2, start}- d_{ce}, L_{\text{seg}}),
IF(d_{ce}< (R_{z2, end}- 0.0001),IF((d_{ce}+ L_{\text{seg}}) > R_{z2, end}, R_{z2, end}- d_{ce}, L_{\text{seg}}),
L_{\text{seg}})))))$$ Python Logic:
IF(v["Centre Enabler Distance (m)"]==0, v["Distance travelled per segment (m)"],
IF(v["Centre Enabler Distance (m)"]< (v["RotZone1 Start (m)"]- 0.0001),IF((v["Centre Enabler Distance (m)"]+ v["Distance travelled per segment (m)"]) > v["RotZone1 Start (m)"], v["RotZone1 Start (m)"]- v["Centre Enabler Distance (m)"], v["Distance travelled per segment (m)"]),
IF(v["Centre Enabler Distance (m)"]< (v["RotZone1 End (m)"]- 0.0001),IF((v["Centre Enabler Distance (m)"]+ v["Distance travelled per segment (m)"]) > v["RotZone1 End (m)"], v["RotZone1 End (m)"]- v["Centre Enabler Distance (m)"], v["Distance travelled per segment (m)"]),
IF(v["Centre Enabler Distance (m)"]< (v["RotZone2 Start (m)"]- 0.0001),IF((v["Centre Enabler Distance (m)"]+ v["Distance travelled per segment (m)"]) > v["RotZone2 Start (m)"], v["RotZone2 Start (m)"]- v["Centre Enabler Distance (m)"], v["Distance travelled per segment (m)"]),
IF(v["Centre Enabler Distance (m)"]< (v["RotZone2 End (m)"]- 0.0001),IF((v["Centre Enabler Distance (m)"]+ v["Distance travelled per segment (m)"]) > v["RotZone2 End (m)"], v["RotZone2 End (m)"]- v["Centre Enabler Distance (m)"], v["Distance travelled per segment (m)"]),
v["Distance travelled per segment (m)"])))))Live Evaluation: [ROUTE: GRID] IF(2.9825==0, 0.1300,
IF(2.9825< (5.0400- 0.0001),IF((2.9825+ 0.1300) > 5.0400, 5.0400- 2.9825, 0.1300),
IF(2.9825< (13.3600- 0.0001),IF((2.9825+ 0.1300) > 13.3600, 13.3600- 2.9825, 0.1300),
IF(2.9825< (17.4400- 0.0001),IF((2.9825+ 0.1300) > 17.4400, 17.4400- 2.9825, 0.1300),
IF(2.9825< (25.7600- 0.0001),IF((2.9825+ 0.1300) > 25.7600, 25.7600- 2.9825, 0.1300),
0.1300))))) = 0.1300
|
| ☰ | \( P_{trans} \) | Transformed Enabler Distance (m) | 0.13 |
View Help GuidePurpose: 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}$$ Python Logic:
v["Distance on track (m)"]+v["Centre Enabler Difference (m)"]Live Evaluation: [ROUTE: GRID] 0.0000+0.1300 = 0.1300
|
| ☰ | \( d_{track} \) | TAR Distance on track (m) |
View Help GuidePurpose: 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: Manual Entry
Render on Grids: Spatial
Mathematical Formula:
$$\text{User Input}$$ Python Logic:
N/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( P_{TAR,ce} \) | TAR Centre Enabler Distance (m) | 2.98 |
View Help GuidePurpose: 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} = ((N_{\text{enablers}}-1)/2) \times L_{\text{gap}}$$ Python Logic:
((v["Number of Gravity Enablers"]-1)/2)*v["Enabler gap length (m)"]Live Evaluation: [ROUTE: GRID] ((11.0000-1)/2)*0.5965 = 2.9825
|
| ☰ | \( \Delta d_{TAR} \) | TAR Difference (m) | 0.13 |
View Help GuidePurpose: 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} = IF(P_{TAR,ce}==0, d_{seg},
IF(P_{TAR,ce} < (R_{z1, start}- 0.0001),IF((P_{TAR,ce} + d_{seg}) > R_{z1, start}, R_{z1, start}- P_{TAR,ce}, d_{seg}),
IF(P_{TAR,ce} < (R_{z1, end}- 0.0001),IF((P_{TAR,ce} + d_{seg}) > R_{z1, end}, R_{z1, end}- P_{TAR,ce}, d_{seg}),
IF(P_{TAR,ce} < (R_{z2, start}- 0.0001),IF((P_{TAR,ce} + d_{seg}) > R_{z2, start}, R_{z2, start}- P_{TAR,ce}, d_{seg}),
IF(P_{TAR,ce} < (R_{z2, end}- 0.0001),IF((P_{TAR,ce} + d_{seg}) > R_{z2, end}, R_{z2, end}- P_{TAR,ce}, d_{seg}),
d_{seg})))))$$ Python Logic:
IF(v["TAR Centre Enabler Distance (m)"]==0, v["Distance travelled per segment (m)"],
IF(v["TAR Centre Enabler Distance (m)"] < (v["RotZone1 Start (m)"]- 0.0001),IF((v["TAR Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone1 Start (m)"], v["RotZone1 Start (m)"]- v["TAR Centre Enabler Distance (m)"], v["Distance travelled per segment (m)"]),
IF(v["TAR Centre Enabler Distance (m)"] < (v["RotZone1 End (m)"]- 0.0001),IF((v["TAR Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone1 End (m)"], v["RotZone1 End (m)"]- v["TAR Centre Enabler Distance (m)"], v["Distance travelled per segment (m)"]),
IF(v["TAR Centre Enabler Distance (m)"] < (v["RotZone2 Start (m)"]- 0.0001),IF((v["TAR Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone2 Start (m)"], v["RotZone2 Start (m)"]- v["TAR Centre Enabler Distance (m)"], v["Distance travelled per segment (m)"]),
IF(v["TAR Centre Enabler Distance (m)"] < (v["RotZone2 End (m)"]- 0.0001),IF((v["TAR Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone2 End (m)"], v["RotZone2 End (m)"]- v["TAR Centre Enabler Distance (m)"], v["Distance travelled per segment (m)"]),
v["Distance travelled per segment (m)"])))))Live Evaluation: [ROUTE: GRID] IF(2.9825==0, 0.1300,
IF(2.9825 < (5.0400- 0.0001),IF((2.9825 + 0.1300) > 5.0400, 5.0400- 2.9825, 0.1300),
IF(2.9825 < (13.3600- 0.0001),IF((2.9825 + 0.1300) > 13.3600, 13.3600- 2.9825, 0.1300),
IF(2.9825 < (17.4400- 0.0001),IF((2.9825 + 0.1300) > 17.4400, 17.4400- 2.9825, 0.1300),
IF(2.9825 < (25.7600- 0.0001),IF((2.9825 + 0.1300) > 25.7600, 25.7600- 2.9825, 0.1300),
0.1300))))) = 0.1300
|
| ☰ | \( P_{trans} \) | TAR Transformed Enabler Distance (m) | 0.13 |
View Help GuidePurpose: 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_{TAR}$$ Python Logic:
v["TAR Distance on track (m)"]+v["TAR Difference (m)"]Live Evaluation: [ROUTE: GRID] 0.0000+0.1300 = 0.1300
|
| ▼ 3. SPATIAL BLUEPRINTS - S1 E2 Loop | ||||
| ☰ | \( d_{track} \) | Distance on track (m) | 0.60 |
View Help GuidePurpose: 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
Mathematical Formula:
$$d_{track} = v_pred_{track}+L_{\text{gap}}$$ Python Logic:
v_prev["Distance on track (m)"]+v["Enabler gap length (m)"]Live Evaluation: [ROUTE: GRID] 0.0000+0.5965 = 0.5965
|
| ☰ | \( d_{ce} \) | Centre Enabler Distance (m) | 2.98 |
View Help GuidePurpose: 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
Mathematical Formula:
$$d_{ce} = v_pred_{ce}$$ Python Logic:
v_prev["Centre Enabler Distance (m)"]Live Evaluation: [ROUTE: GRID] 2.9825 = 2.9825
|
| ☰ | \( \Delta d_{ce} \) | Centre Enabler Difference (m) | 0.13 |
View Help GuidePurpose: 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.1300 = 0.1300
|
| ☰ | \( P_{trans} \) | Transformed Enabler Distance (m) | 0.73 |
View Help GuidePurpose: 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}$$ Python Logic:
v["Distance on track (m)"]+v["Centre Enabler Difference (m)"]Live Evaluation: [ROUTE: GRID] 0.5965+0.1300 = 0.7265
|
| ☰ | \( d_{track} \) | TAR Distance on track (m) | 0.60 |
View Help GuidePurpose: 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.5965 = 0.5965
|
| ☰ | \( P_{TAR,ce} \) | TAR Centre Enabler Distance (m) | 2.98 |
View Help GuidePurpose: 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.9825 = 2.9825
|
| ☰ | \( \Delta d_{TAR} \) | TAR Difference (m) | 0.13 |
View Help GuidePurpose: 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.1300 = 0.1300
|
| ☰ | \( P_{trans} \) | TAR Transformed Enabler Distance (m) | 0.73 |
View Help GuidePurpose: 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_{TAR}$$ Python Logic:
v["TAR Distance on track (m)"]+v["TAR Difference (m)"]Live Evaluation: [ROUTE: GRID] 0.5965+0.1300 = 0.7265
|
| ▼ 3. SPATIAL BLUEPRINTS - S2 E1 Transition | ||||
| ☰ | \( d_{track} \) | Distance on track (m) | 0.13 |
View Help GuidePurpose: 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
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.1300 = 0.1300
|
| ☰ | \( d_{ce} \) | Centre Enabler Distance (m) | 3.11 |
View Help GuidePurpose: 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
Mathematical Formula:
$$d_{ce} = IF(v_prev_seg["Centre Enabler Distance (m)"]+v_prev_seg["Centre Enabler Difference (m)"]>L_{c2},v_prev_seg["Centre Enabler Distance (m)"]+v_prev_seg["Centre Enabler Difference (m)"]-L_{c2},v_prev_seg["Centre Enabler Distance (m)"]+v_prev_seg["Centre Enabler Difference (m)"])$$ Python Logic:
IF(v_prev_seg["Centre Enabler Distance (m)"]+v_prev_seg["Centre Enabler Difference (m)"]>v["Physical End Corner2 (m)"],v_prev_seg["Centre Enabler Distance (m)"]+v_prev_seg["Centre Enabler Difference (m)"]-v["Physical End Corner2 (m)"],v_prev_seg["Centre Enabler Distance (m)"]+v_prev_seg["Centre Enabler Difference (m)"])Live Evaluation: [ROUTE: GRID] IF(2.9825+0.1300>24.8000,2.9825+0.1300-24.8000,2.9825+0.1300) = 3.1125
|
| ☰ | \( \Delta d_{ce} \) | Centre Enabler Difference (m) | 0.13 |
View Help GuidePurpose: 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} = IF(d_{ce}==0, d_{seg}, IF(d_{ce}< (R_{z1, start}- 0.0001),IF((d_{ce}+ d_{seg}) > R_{z1, start}, R_{z1, start}- d_{ce}, d_{seg}),IF(d_{ce}< (R_{z1, end}- 0.0001),IF((d_{ce}+ d_{seg}) > R_{z1, end}, R_{z1, end}- d_{ce}, d_{seg}),IF(d_{ce}< (R_{z2, start}- 0.0001),IF((d_{ce}+ d_{seg}) > R_{z2, start}, R_{z2, start}- d_{ce}, d_{seg}),IF(d_{ce}< (R_{z2, end}- 0.0001),IF((d_{ce}+ d_{seg}) > R_{z2, end}, R_{z2, end}- d_{ce}, d_{seg}),d_{seg})))))$$ Python Logic:
IF(v["Centre Enabler Distance (m)"]==0, v["Distance travelled per segment (m)"], IF(v["Centre Enabler Distance (m)"]< (v["RotZone1 Start (m)"]- 0.0001),IF((v["Centre Enabler Distance (m)"]+ v["Distance travelled per segment (m)"]) > v["RotZone1 Start (m)"], v["RotZone1 Start (m)"]- v["Centre Enabler Distance (m)"], v["Distance travelled per segment (m)"]),IF(v["Centre Enabler Distance (m)"]< (v["RotZone1 End (m)"]- 0.0001),IF((v["Centre Enabler Distance (m)"]+ v["Distance travelled per segment (m)"]) > v["RotZone1 End (m)"], v["RotZone1 End (m)"]- v["Centre Enabler Distance (m)"], v["Distance travelled per segment (m)"]),IF(v["Centre Enabler Distance (m)"]< (v["RotZone2 Start (m)"]- 0.0001),IF((v["Centre Enabler Distance (m)"]+ v["Distance travelled per segment (m)"]) > v["RotZone2 Start (m)"], v["RotZone2 Start (m)"]- v["Centre Enabler Distance (m)"], v["Distance travelled per segment (m)"]),IF(v["Centre Enabler Distance (m)"]< (v["RotZone2 End (m)"]- 0.0001),IF((v["Centre Enabler Distance (m)"]+ v["Distance travelled per segment (m)"]) > v["RotZone2 End (m)"], v["RotZone2 End (m)"]- v["Centre Enabler Distance (m)"], v["Distance travelled per segment (m)"]),v["Distance travelled per segment (m)"])))))Live Evaluation: [ROUTE: GRID] IF(3.1125==0, 0.1300, IF(3.1125< (5.0400- 0.0001),IF((3.1125+ 0.1300) > 5.0400, 5.0400- 3.1125, 0.1300),IF(3.1125< (13.3600- 0.0001),IF((3.1125+ 0.1300) > 13.3600, 13.3600- 3.1125, 0.1300),IF(3.1125< (17.4400- 0.0001),IF((3.1125+ 0.1300) > 17.4400, 17.4400- 3.1125, 0.1300),IF(3.1125< (25.7600- 0.0001),IF((3.1125+ 0.1300) > 25.7600, 25.7600- 3.1125, 0.1300),0.1300))))) = 0.1300
|
| ☰ | \( P_{trans} \) | Transformed Enabler Distance (m) | 0.26 |
View Help GuidePurpose: 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} = IF(d_{track}+\Delta d_{ce}>L_{c2},d_{track}+\Delta d_{ce}-L_{c2},d_{track}+\Delta d_{ce})$$ Python Logic:
IF(v["Distance on track (m)"]+v["Centre Enabler Difference (m)"]>v["Physical End Corner2 (m)"],v["Distance on track (m)"]+v["Centre Enabler Difference (m)"]-v["Physical End Corner2 (m)"],v["Distance on track (m)"]+v["Centre Enabler Difference (m)"])Live Evaluation: [ROUTE: GRID] IF(0.1300+0.1300>24.8000,0.1300+0.1300-24.8000,0.1300+0.1300) = 0.2600
|
| ☰ | \( d_{track} \) | TAR Distance on track (m) | 0.13 |
View Help GuidePurpose: 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.1300 = 0.1300
|
| ☰ | \( P_{TAR,ce} \) | TAR Centre Enabler Distance (m) | 3.11 |
View Help GuidePurpose: 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} = IF(v_prev_seg["TAR Centre Enabler Distance (m)"]+v_prev_seg["TAR Difference (m)"]>R_{z2, end},
v_prev_seg["TAR Centre Enabler Distance (m)"]+v_prev_seg["TAR Difference (m)"]-R_{z2, end}+(D_{\text{centre}}-C_{\text{corner, dist}}),
v_prev_seg["TAR Centre Enabler Distance (m)"]+v_prev_seg["TAR Difference (m)"])$$ Python Logic:
IF(v_prev_seg["TAR Centre Enabler Distance (m)"]+v_prev_seg["TAR Difference (m)"]>v["RotZone2 End (m)"],
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)"]),
v_prev_seg["TAR Centre Enabler Distance (m)"]+v_prev_seg["TAR Difference (m)"])Live Evaluation: [ROUTE: GRID] IF(2.9825+0.1300>25.7600,
2.9825+0.1300-25.7600+(4.1600-3.2000),
2.9825+0.1300) = 3.1125
|
| ☰ | \( \Delta d_{TAR} \) | TAR Difference (m) | 0.13 |
View Help GuidePurpose: 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} = IF(d_{ce}==0, d_{seg}, IF(d_{ce} < (R_{z1, start} - 0.0001), IF((d_{ce} + d_{seg}) > R_{z1, start}, R_{z1, start} - d_{ce}, d_{seg}), IF(d_{ce} < (R_{z1, end} - 0.0001), IF((d_{ce} + d_{seg}) > R_{z1, end}, R_{z1, end} - d_{ce}, d_{seg}), IF(d_{ce} < (R_{z2, start} - 0.0001), IF((d_{ce} + d_{seg}) > R_{z2, start}, R_{z2, start} - d_{ce}, d_{seg}), IF(d_{ce} < (R_{z2, end} - 0.0001), IF((d_{ce} + d_{seg}) > R_{z2, end}, R_{z2, end} - d_{ce}, d_{seg}), d_{seg})))))$$ Python Logic:
IF(v["Centre Enabler Distance (m)"]==0, v["Distance travelled per segment (m)"], IF(v["Centre Enabler Distance (m)"] < (v["RotZone1 Start (m)"] - 0.0001), IF((v["Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone1 Start (m)"], v["RotZone1 Start (m)"] - v["Centre Enabler Distance (m)"], v["Distance travelled per segment (m)"]), IF(v["Centre Enabler Distance (m)"] < (v["RotZone1 End (m)"] - 0.0001), IF((v["Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone1 End (m)"], v["RotZone1 End (m)"] - v["Centre Enabler Distance (m)"], v["Distance travelled per segment (m)"]), IF(v["Centre Enabler Distance (m)"] < (v["RotZone2 Start (m)"] - 0.0001), IF((v["Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone2 Start (m)"], v["RotZone2 Start (m)"] - v["Centre Enabler Distance (m)"], v["Distance travelled per segment (m)"]), IF(v["Centre Enabler Distance (m)"] < (v["RotZone2 End (m)"] - 0.0001), IF((v["Centre Enabler Distance (m)"] + v["Distance travelled per segment (m)"]) > v["RotZone2 End (m)"], v["RotZone2 End (m)"] - v["Centre Enabler Distance (m)"], v["Distance travelled per segment (m)"]), v["Distance travelled per segment (m)"])))))Live Evaluation: [ROUTE: GRID] IF(3.1125==0, 0.1300, IF(3.1125 < (5.0400 - 0.0001), IF((3.1125 + 0.1300) > 5.0400, 5.0400 - 3.1125, 0.1300), IF(3.1125 < (13.3600 - 0.0001), IF((3.1125 + 0.1300) > 13.3600, 13.3600 - 3.1125, 0.1300), IF(3.1125 < (17.4400 - 0.0001), IF((3.1125 + 0.1300) > 17.4400, 17.4400 - 3.1125, 0.1300), IF(3.1125 < (25.7600 - 0.0001), IF((3.1125 + 0.1300) > 25.7600, 25.7600 - 3.1125, 0.1300), 0.1300))))) = 0.1300
|
| ☰ | \( P_{trans} \) | TAR Transformed Enabler Distance (m) | 0.26 |
View Help GuidePurpose: 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} = IF(d_{track}+\Delta d_{TAR}>R_{z2, end},d_{track}+\Delta d_{TAR}-R_{z2, end}+((v/2)-C_{\text{corner, dist}}),d_{track}+\Delta d_{TAR})$$ Python Logic:
IF(v["TAR Distance on track (m)"]+v["TAR Difference (m)"]>v["RotZone2 End (m)"],v["TAR Distance on track (m)"]+v["TAR Difference (m)"]-v["RotZone2 End (m)"]+((v["Operational Velocity (m/s)"]/2)-v["Half semi corner Circumference (m)"]),v["TAR Distance on track (m)"]+v["TAR Difference (m)"])Live Evaluation: [ROUTE: GRID] IF(0.1300+0.1300>25.7600,0.1300+0.1300-25.7600+((8.3200/2)-3.2000),0.1300+0.1300) = 0.2600
|
| ▼ 3. SPATIAL BLUEPRINTS - S2 E2 Cascade | ||||
| ☰ | \( d_{track} \) | Distance on track (m) | 0.73 |
View Help GuidePurpose: 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
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.7265 = 0.7265
|
| ☰ | \( d_{ce} \) | Centre Enabler Distance (m) | 3.11 |
View Help GuidePurpose: 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
Mathematical Formula:
$$d_{ce} = v_pred_{ce}$$ Python Logic:
v_prev["Centre Enabler Distance (m)"]Live Evaluation: [ROUTE: GRID] 3.1125 = 3.1125
|
| ☰ | \( \Delta d_{ce} \) | Centre Enabler Difference (m) | 0.13 |
View Help GuidePurpose: 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.1300 = 0.1300
|
| ☰ | \( P_{trans} \) | Transformed Enabler Distance (m) | 0.86 |
View Help GuidePurpose: 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} = IF(d_{track}+\Delta d_{ce}>L_{c2},d_{track}+\Delta d_{ce}-L_{c2},d_{track}+\Delta d_{ce})$$ Python Logic:
IF(v["Distance on track (m)"]+v["Centre Enabler Difference (m)"]>v["Physical End Corner2 (m)"],v["Distance on track (m)"]+v["Centre Enabler Difference (m)"]-v["Physical End Corner2 (m)"],v["Distance on track (m)"]+v["Centre Enabler Difference (m)"])Live Evaluation: [ROUTE: GRID] IF(0.7265+0.1300>24.8000,0.7265+0.1300-24.8000,0.7265+0.1300) = 0.8565
|
| ☰ | \( d_{track} \) | TAR Distance on track (m) | 0.73 |
View Help GuidePurpose: 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.7265 = 0.7265
|
| ☰ | \( P_{TAR,ce} \) | TAR Centre Enabler Distance (m) | 3.11 |
View Help GuidePurpose: 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.1125 = 3.1125
|
| ☰ | \( \Delta d_{TAR} \) | TAR Difference (m) | 0.13 |
View Help GuidePurpose: 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.1300 = 0.1300
|
| ☰ | \( P_{trans} \) | TAR Transformed Enabler Distance (m) | 0.86 |
View Help GuidePurpose: 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} = IF(d_{track}+\Delta d_{TAR}>R_{z2, end},d_{track}+\Delta d_{TAR}-R_{z2, end}+((v/2)-C_{\text{corner, dist}}),d_{track}+\Delta d_{TAR})$$ Python Logic:
IF(v["TAR Distance on track (m)"]+v["TAR Difference (m)"]>v["RotZone2 End (m)"],v["TAR Distance on track (m)"]+v["TAR Difference (m)"]-v["RotZone2 End (m)"]+((v["Operational Velocity (m/s)"]/2)-v["Half semi corner Circumference (m)"]),v["TAR Distance on track (m)"]+v["TAR Difference (m)"])Live Evaluation: [ROUTE: GRID] IF(0.7265+0.1300>25.7600,0.7265+0.1300-25.7600+((8.3200/2)-3.2000),0.7265+0.1300) = 0.8565
|
| ▼ 4. ROTATIONAL TORQUE BLUEPRINTS - S1 E1 Base | ||||
| ☰ | \( d_{track} \) | Distance on track (m) | 0.00 |
View Help GuidePurpose: Determining the position of an enabler on the full track length
Logic: Pulls the absolute spatial location of the enabler from the master tracking loop (from the Spatial Blueprints).
Type: Calculated (Math Output)
Render on Grids: Rotational Torque
Mathematical Formula:
$$d_{track} = d_{track}$$ Python Logic:
v["Distance on track (m)"]Live Evaluation: [ROUTE: GRID] 0.0000 = 0.0000
|
| ☰ | \( d_{ce} \) | Centre Enabler Distance (m) | 2.98 |
View Help GuidePurpose: Distance centre gravity enabler tarvelled on the track across segments
Logic: Isolates the master tracking position of the "Centre" cart, which acts as the trigger for all system-wide tilt mechanisms.
Type: Calculated (Math Output)
Render on Grids: Rotational Torque
Mathematical Formula:
$$d_{ce} = P_{TAR,ce}$$ Python Logic:
v["TAR Centre Enabler Distance (m)"]Live Evaluation: [ROUTE: GRID] 2.9825 = 2.9825
|
| ☰ | \( P_{circ} \) | Enabler Circumference Distance (m) | 0.00 |
View Help GuidePurpose: Determines distance travelled by a gravity enabler on the rounded corner
Logic: Strips away the straightaway distances to isolate exactly how far the enabler has travelled within the curve itself.
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:
IF(v["Track Section"]==2,IF(v["Distance on track (m)"]<v["Physical End Corner1 (m)"],v["Distance on track (m)"]-v["Physical End Straight1 (m)"],v["Distance on track (m)"]-v["Physical End Straight2 (m)"]),0)Live Evaluation: [ROUTE: GRID] IF(1.0000==2,IF(0.0000<12.4000,0.0000-6.0000,0.0000-18.4000),0) = 0.0000
|
| ☰ | \( \alpha \) | Enabler Circumference Angle (degree) | 0.00 |
View Help GuidePurpose: 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/2.0372) = 0.0000
|
| ☰ | \( \theta_{eff,static} \) | Static Effective Angle for parallel force (degree) | 32.00 |
View Help GuidePurpose: Intermediate calculation for Effective Angle considering the track slant
Logic: Combines the enabler's position on the curve with the current tilt of the track to find the un-normalized force angle.
Type: Calculated (Math Output)
Render on Grids: Rotational Torque
Mathematical Formula:
$$\theta_{eff,static} = IF(\alpha==0,\theta_{slant},\theta_{slant}+\alpha)$$ Python Logic:
IF(v["Enabler Circumference Angle (degree)"]==0,v["Track Slant (degree)"],v["Track Slant (degree)"]+v["Enabler Circumference Angle (degree)"])Live Evaluation: [ROUTE: GRID] IF(0.0000==0,32.0000,32.0000+0.0000) = 32.0000
|
| ☰ | \( \theta_{eff} \) | Effective Angle for Parallel Force (degree) | 32.00 |
View Help GuidePurpose: Determinging the correct effective parallel force angle based on the geometry of the GMEG design
Logic: Normalizes the static angle based on whether the train is on a straight, and flips the geometric signs based on which cycle (side of the track) the enabler is traversing.
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:
IF(v["Track Section"] == 1, abs(v["Track Slant (degree)"]), IF(v["Cycle"] == 1, IF(v["Static Effective Angle for parallel force (degree)"] < 90, v["Static Effective Angle for parallel force (degree)"], 180 - v["Static Effective Angle for parallel force (degree)"]), -IF(v["Static Effective Angle for parallel force (degree)"] < 90, v["Static Effective Angle for parallel force (degree)"], 180 - v["Static Effective Angle for parallel force (degree)"])))Live Evaluation: [ROUTE: GRID] IF(1.0000 == 1, abs(32.0000), IF(1.0000 == 1, IF(32.0000 < 90, 32.0000, 180 - 32.0000), -IF(32.0000 < 90, 32.0000, 180 - 32.0000))) = 32.0000
|
| ☰ | \( X_{flat} \) | X flat (m) | -3.00 |
View Help GuidePurpose: Horizontal position with the track in a horizontal position
Logic: Calculates the raw horizontal (X) coordinate of the enabler assuming a completely flat, non-tilted track using basic trigonometry.
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:
IF(v["Track Section"]==1, IF(v["Distance on track (m)"]<v["Physical End Corner1 (m)"],
v["Distance on track (m)"]-(v["Straight track length (m)"]/2),(v["Straight track length (m)"]/2)-(v["Distance on track (m)"]-v["Physical End Corner1 (m)"])),
IF(v["Distance on track (m)"]<v["Physical End Corner1 (m)"],
(v["Straight track length (m)"]/2)+(v["Internal Gear Radius (m)"]*SIN(RADIANS(v["Enabler Circumference Angle (degree)"]))),-(v["Straight track length (m)"]/2)-(v["Internal Gear Radius (m)"]*SIN(RADIANS(v["Enabler Circumference Angle (degree)"])))))Live Evaluation: [ROUTE: GRID] IF(1.0000==1, IF(0.0000<12.4000,
0.0000-(6.0000/2),(6.0000/2)-(0.0000-12.4000)),
IF(0.0000<12.4000,
(6.0000/2)+(2.0372*SIN(RADIANS(0.0000))),-(6.0000/2)-(2.0372*SIN(RADIANS(0.0000))))) = -3.0000
|
| ☰ | \( Y_{flat} \) | Y flat (m) | 2.04 |
View Help GuidePurpose: Vertical position with the track in a horizontal position
Logic: Calculates the raw vertical (Y) coordinate of the enabler assuming a completely flat, non-tilted track.
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:
IF(v["Track Section"]==1,
IF(v["Distance on track (m)"]<v["Physical End Corner1 (m)"],v["Internal Gear Radius (m)"],-v["Internal Gear Radius (m)"]),
IF(v["Distance on track (m)"]<v["Physical End Corner1 (m)"],v["Internal Gear Radius (m)"]*COS(RADIANS(v["Enabler Circumference Angle (degree)"])),-v["Internal Gear Radius (m)"]*COS(RADIANS(v["Enabler Circumference Angle (degree)"]))))Live Evaluation: [ROUTE: GRID] IF(1.0000==1,
IF(0.0000<12.4000,2.0372,-2.0372),
IF(0.0000<12.4000,2.0372*COS(RADIANS(0.0000)),-2.0372*COS(RADIANS(0.0000)))) = 2.0372
|
| ☰ | \( X_{final} \) | Horizontal Distance X final (m) | -1.46 |
View Help GuidePurpose: 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] (-3.0000*COS(RADIANS(-32.0000)))-(2.0372*SIN(RADIANS(-32.0000))) = -1.4646
|
| ☰ | \( Y_{final} \) | Vertical Distance Y final (m) | 3.32 |
View Help GuidePurpose: 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] (-3.0000*SIN(RADIANS(-32.0000)))+(2.0372*COS(RADIANS(-32.0000))) = 3.3174
|
| ☰ | \( F_g \) | Gravitational Force Fg (N) | 24,747.95 |
View Help GuidePurpose: 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] (2272.7273+250.0000)*9.8100 = 24,747.9545
|
| ☰ | \( E_p \) | Gravitational Potential Energy GPE per Enabler (J) | 64,748.76 |
View Help GuidePurpose: 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] ((((2272.7273*9.8100*3.3174)*0.9500)*0.9700)*(1-0.0500)) = 64,748.7575
|
| ☰ | \( \Sigma E_{\text{gpe, enablers}} \) | Total Gravitational Potential Energy GPE of all Enablers (J) | 64,748.76 |
View Help GuidePurpose: 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] 64748.7575 = 64,748.7575
|
| ☰ | \( F_p \) | GMEG Parallel Force Fp (N) | 13,114.42 |
View Help GuidePurpose: 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] 24747.9545*SIN(RADIANS(32.0000)) = 13,114.4179
|
| ☰ | \( m_{en,p} \) | Parallel mass per Enabler (kg) | 1,336.84 |
View Help GuidePurpose: 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] 13114.4179/9.8100 = 1,336.8418
|
| ☰ | \( \tau_{GMEG} \) | GMEG Nm Output (Nm) | 26,716.47 |
View Help GuidePurpose: 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] 13114.4179*2.0372 = 26,716.4727
|
| ☰ | \( \eta_{\text{op}} \) | Operational Efficiency (%) | 0.89 |
View Help GuidePurpose: 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) | 23,734.91 |
View Help GuidePurpose: 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] 26716.4727* 0.8884 = 23,734.9143
|
| ☰ | \( \Sigma\tau_{GMEG} \) | Total GMEG Output per Segment (Nm) | 23,734.91 |
View Help GuidePurpose: 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} = IF(N_{en} == 1, \tau_{GMEG,final}, v_pre\Sigma\tau_{GMEG} + \tau_{GMEG,final})$$ Python Logic:
IF(v["Enabler Number"] == 1, v["Final GMEG Output (Nm)"], v_prev["Total GMEG Output per Segment (Nm)"] + v["Final GMEG Output (Nm)"])Live Evaluation: [ROUTE: GRID] IF(v["Enabler Number"] == 1, 23734.9143, 0.0000 + 23734.9143) = 23,734.9143
|
| ☰ | \( \tau_{def} \) | Torque Deficit (Nm) | 1,863.19 |
View Help GuidePurpose: 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] 23734.9143-(240588.9592/11.0000) = 1,863.1908
|
| ☰ | \( \Sigma \tau_{\text{deficit}} \) | Total Torque Deficit (Nm) | 1,863.19 |
View Help GuidePurpose: 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] 1863.1908 = 1,863.1908
|
| ☰ | \( \tau_{gear} \) | Gear System Torque (Nm) | 0.00 |
View Help GuidePurpose: Torque experienced by the DLLS per enabler during rotation cycles
Logic: Calculates the torque acting on the swiveling system by multiplying the gravitational force by the true horizontal lever arm (X_final)
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:
IF(v["Status"]==1,0,v["Horizontal Distance X final (m)"]*v["Gravitational Force Fg (N)"])Live Evaluation: [ROUTE: GRID] IF(1.0000==1,0,-1.4646*24747.9545) = 0.0000
|
| ☰ | \( \tau \) | Absolute Gear System Torque (Nm) | 0.00 |
View Help GuidePurpose: Absolute values to represent positive values for torque experienced by the DLLS
Logic: Normalizes the gear system torque for accurate aggregation regardless of orientation.
Type: Calculated (Math Output)
Render on Grids: Rotational Torque
Mathematical Formula:
$$` = IF(\text{Status}==1,0,ABS(\tau_{gear}))$$ Python Logic:
IF(v["Status"]==1,0,ABS(v["Gear System Torque (Nm)"]))Live Evaluation: [ROUTE: GRID] IF(1.0000==1,0,ABS(0.0000)) = 0.0000
|
| ☰ | \( \tau_{gear,train} \) | Enabler train Absolute Gear System Torque (Nm) | 0.00 |
View Help GuidePurpose: 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 GuidePurpose: Work done by the DLLS for that segment time frame, based on the angle per segment
Logic: Converts rotational torque into kinetic energy (Joules) expended during the rotation phase.
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:
IF(v["Status"]==1,0,v["Absolute Gear System Torque (Nm)"]*v["Angle Per Segment radians (rad/s)"])Live Evaluation: [ROUTE: GRID] IF(1.0000==1,0,0.0000*0.0175) = 0.0000
|
| ☰ | \( TW_{DLLS} \) | Total Work Done by DLLS Joule per Segment (J) | 0.00 |
View Help GuidePurpose: 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 GuidePurpose: Modelling inertia during a track arc rotation based on each enablers' position on the track
Logic: Calculates the rotational inertia using I=mr2, where the radius is the enabler's true shifted horizontal position (X_final)
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:
IF(v["Status"]==1,0,((v["TOTAL WEIGHT (KG)"]/v["Number of Gravity Enablers"])*(v["Horizontal Distance X final (m)"]^2)))Live Evaluation: [ROUTE: GRID] IF(1.0000==1,0,((27750.0000/11.0000)*(-1.4646^2))) = 0.0000
|
| ☰ | \( I_{train} \) | Enabler train Moment of inertia (kg.m2) | 0.00 |
View Help GuidePurpose: 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 | ||||
| ☰ | \( d_{track} \) | Distance on track (m) | 0.60 |
View Help GuidePurpose: Determining the position of an enabler on the full track length
Logic: Pulls the absolute spatial location of the enabler from the master tracking loop (from the Spatial Blueprints).
Type: Calculated (Math Output)
Render on Grids: Rotational Torque
Mathematical Formula:
$$d_{track} = d_{track}$$ Python Logic:
v["Distance on track (m)"]Live Evaluation: [ROUTE: GRID] 0.5965 = 0.5965
|
| ☰ | \( d_{ce} \) | Centre Enabler Distance (m) | 2.98 |
View Help GuidePurpose: Distance centre gravity enabler tarvelled on the track across segments
Logic: Isolates the master tracking position of the "Centre" cart, which acts as the trigger for all system-wide tilt mechanisms.
Type: Calculated (Math Output)
Render on Grids: Rotational Torque
Mathematical Formula:
$$d_{ce} = P_{TAR,ce}$$ Python Logic:
v["TAR Centre Enabler Distance (m)"]Live Evaluation: [ROUTE: GRID] 2.9825 = 2.9825
|
| ☰ | \( P_{circ} \) | Enabler Circumference Distance (m) | 0.00 |
View Help GuidePurpose: Determines distance travelled by a gravity enabler on the rounded corner
Logic: Strips away the straightaway distances to isolate exactly how far the enabler has travelled within the curve itself.
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:
IF(v["Track Section"]==2,
IF(v["Distance on track (m)"]<v["Physical End Corner1 (m)"],v["Distance on track (m)"]-v["Physical End Straight1 (m)"],v["Distance on track (m)"]-v["Physical End Straight2 (m)"]), 0)Live Evaluation: [ROUTE: GRID] IF(1.0000==2,
IF(0.5965<12.4000,0.5965-6.0000,0.5965-18.4000), 0) = 0.0000
|
| ☰ | \( \alpha \) | Enabler Circumference Angle (degree) | 0.00 |
View Help GuidePurpose: 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/2.0372) = 0.0000
|
| ☰ | \( \theta_{eff,static} \) | Static Effective Angle for parallel force (degree) | 32.00 |
View Help GuidePurpose: Intermediate calculation for Effective Angle considering the track slant
Logic: Combines the enabler's position on the curve with the current tilt of the track to find the un-normalized force angle.
Type: Calculated (Math Output)
Render on Grids: Rotational Torque
Mathematical Formula:
$$\theta_{eff,static} = IF(\alpha==0,\theta_{slant},\theta_{slant}+\alpha)$$ Python Logic:
IF(v["Enabler Circumference Angle (degree)"]==0,v["Track Slant (degree)"],v["Track Slant (degree)"]+v["Enabler Circumference Angle (degree)"])Live Evaluation: [ROUTE: GRID] IF(0.0000==0,32.0000,32.0000+0.0000) = 32.0000
|
| ☰ | \( \theta_{eff} \) | Effective Angle for Parallel Force (degree) | 32.00 |
View Help GuidePurpose: Determinging the correct effective parallel force angle based on the geometry of the GMEG design
Logic: Normalizes the static angle based on whether the train is on a straight, and flips the geometric signs based on which cycle (side of the track) the enabler is traversing.
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:
IF(v["Track Section"] == 1, abs(v["Track Slant (degree)"]), IF(v["Cycle"] == 1, IF(v["Static Effective Angle for parallel force (degree)"] < 90, v["Static Effective Angle for parallel force (degree)"], 180 - v["Static Effective Angle for parallel force (degree)"]), -IF(v["Static Effective Angle for parallel force (degree)"] < 90, v["Static Effective Angle for parallel force (degree)"], 180 - v["Static Effective Angle for parallel force (degree)"])))Live Evaluation: [ROUTE: GRID] IF(1.0000 == 1, abs(32.0000), IF(1.0000 == 1, IF(32.0000 < 90, 32.0000, 180 - 32.0000), -IF(32.0000 < 90, 32.0000, 180 - 32.0000))) = 32.0000
|
| ☰ | \( X_{flat} \) | X flat (m) | -2.40 |
View Help GuidePurpose: Horizontal position with the track in a horizontal position
Logic: Calculates the raw horizontal (X) coordinate of the enabler assuming a completely flat, non-tilted track using basic trigonometry.
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:
IF(v["Track Section"]==1, IF(v["Distance on track (m)"]<v["Physical End Corner1 (m)"],v["Distance on track (m)"]-(v["Straight track length (m)"]/2),(v["Straight track length (m)"]/2)-(v["Distance on track (m)"]-v["Physical End Corner1 (m)"])),
IF(v["Distance on track (m)"]<v["Physical End Corner1 (m)"],(v["Straight track length (m)"]/2)+(v["Internal Gear Radius (m)"]*SIN(RADIANS(v["Enabler Circumference Angle (degree)"]))),-(v["Straight track length (m)"]/2)-(v["Internal Gear Radius (m)"]*SIN(RADIANS(v["Enabler Circumference Angle (degree)"])))))Live Evaluation: [ROUTE: GRID] IF(1.0000==1, IF(0.5965<12.4000,0.5965-(6.0000/2),(6.0000/2)-(0.5965-12.4000)),
IF(0.5965<12.4000,(6.0000/2)+(2.0372*SIN(RADIANS(0.0000))),-(6.0000/2)-(2.0372*SIN(RADIANS(0.0000))))) = -2.4035
|
| ☰ | \( Y_{flat} \) | Y flat (m) | 2.04 |
View Help GuidePurpose: Vertical position with the track in a horizontal position
Logic: Calculates the raw vertical (Y) coordinate of the enabler assuming a completely flat, non-tilted track.
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:
IF(v["Track Section"]==1,
IF(v["Distance on track (m)"]<v["Physical End Corner1 (m)"],v["Internal Gear Radius (m)"],-v["Internal Gear Radius (m)"]),IF(v["Distance on track (m)"]<v["Physical End Corner1 (m)"],v["Internal Gear Radius (m)"]*COS(RADIANS(v["Enabler Circumference Angle (degree)"])),-v["Internal Gear Radius (m)"]*COS(RADIANS(v["Enabler Circumference Angle (degree)"]))))Live Evaluation: [ROUTE: GRID] IF(1.0000==1,
IF(0.5965<12.4000,2.0372,-2.0372),IF(0.5965<12.4000,2.0372*COS(RADIANS(0.0000)),-2.0372*COS(RADIANS(0.0000)))) = 2.0372
|
| ☰ | \( X_{final} \) | Horizontal Distance X final (m) | -0.96 |
View Help GuidePurpose: 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.4035*COS(RADIANS(-32.0000)))-(2.0372*SIN(RADIANS(-32.0000))) = -0.9587
|
| ☰ | \( Y_{final} \) | Vertical Distance Y final (m) | 3.00 |
View Help GuidePurpose: 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.4035*SIN(RADIANS(-32.0000)))+(2.0372*COS(RADIANS(-32.0000))) = 3.0013
|
| ☰ | \( F_g \) | Gravitational Force Fg (N) | 24,747.95 |
View Help GuidePurpose: 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] (2272.7273+250.0000)*9.8100 = 24,747.9545
|
| ☰ | \( E_p \) | Gravitational Potential Energy GPE per Enabler (J) | 58,579.18 |
View Help GuidePurpose: 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] (((2272.7273*9.8100*3.0013) *0.9500)*0.9700*(1-0.0500)) = 58,579.1799
|
| ☰ | \( \Sigma E_{\text{gpe, enablers}} \) | Total Gravitational Potential Energy GPE of all Enablers (J) | 123,327.94 |
View Help GuidePurpose: 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] 58579.1799+64748.7575 = 123,327.9373
|
| ☰ | \( F_p \) | GMEG Parallel Force Fp (N) | 13,114.42 |
View Help GuidePurpose: 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] 24747.9545*SIN(RADIANS(32.0000)) = 13,114.4179
|
| ☰ | \( m_{en,p} \) | Parallel mass per Enabler (kg) | 1,336.84 |
View Help GuidePurpose: 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] 13114.4179/9.8100 = 1,336.8418
|
| ☰ | \( \tau_{GMEG} \) | GMEG Nm Output (Nm) | 26,716.47 |
View Help GuidePurpose: 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] 13114.4179*2.0372 = 26,716.4727
|
| ☰ | \( \eta_{loss} \) | Operational Efficiency (%) | 0.89 |
View Help GuidePurpose: 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) | 23,734.91 |
View Help GuidePurpose: 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] 26716.4727*0.8884 = 23,734.9143
|
| ☰ | \( \Sigma\tau_{GMEG} \) | Total GMEG Output per Segment (Nm) | 47,469.83 |
View Help GuidePurpose: 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] 23734.9143 + 23734.9143 = 47,469.8287
|
| ☰ | \( \tau_{def} \) | Torque Deficit (Nm) | 1,863.19 |
View Help GuidePurpose: 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] 23734.9143-(240588.9592/11.0000) = 1,863.1908
|
| ☰ | \( \Sigma \tau_{\text{deficit}} \) | Total Torque Deficit (Nm) | 3,726.38 |
View Help GuidePurpose: 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] 1863.1908+1863.1908 = 3,726.3816
|
| ☰ | \( \tau_{gear} \) | Gear System Torque (Nm) | 0.00 |
View Help GuidePurpose: Torque experienced by the DLLS per enabler during rotation cycles
Logic: Calculates the torque acting on the swiveling system by multiplying the gravitational force by the true horizontal lever arm (X_final)
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:
IF(v["Status"]==1,0,v["Horizontal Distance X final (m)"]*v["Gravitational Force Fg (N)"])Live Evaluation: [ROUTE: GRID] IF(1.0000==1,0,-0.9587*24747.9545) = 0.0000
|
| ☰ | \( \tau \) | Absolute Gear System Torque (Nm) | 0.00 |
View Help GuidePurpose: Absolute values to represent positive values for torque experienced by the DLLS
Logic: Normalizes the gear system torque for accurate aggregation regardless of orientation.
Type: Calculated (Math Output)
Render on Grids: Rotational Torque
Mathematical Formula:
$$` = IF(\text{Status}==1,0,ABS(\tau_{gear}))$$ Python Logic:
IF(v["Status"]==1,0,ABS(v["Gear System Torque (Nm)"]))Live Evaluation: [ROUTE: GRID] IF(1.0000==1,0,ABS(0.0000)) = 0.0000
|
| ☰ | \( \tau_{gear,train} \) | Enabler train Absolute Gear System Torque (Nm) | 0.00 |
View Help GuidePurpose: 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 GuidePurpose: Work done by the DLLS for that segment time frame, based on the angle per segment
Logic: Converts rotational torque into kinetic energy (Joules) expended during the rotation phase.
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:
IF(v["Status"]==1,0,v["Absolute Gear System Torque (Nm)"]*v["Angle Per Segment radians (rad/s)"])Live Evaluation: [ROUTE: GRID] IF(1.0000==1,0,0.0000*0.0175) = 0.0000
|
| ☰ | \( TW_{DLLS} \) | Total Work Done by DLLS Joule per Segment (J) | 0.00 |
View Help GuidePurpose: 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 GuidePurpose: Modelling inertia during a track arc rotation based on each enablers' position on the track
Logic: Calculates the rotational inertia using I=mr2, where the radius is the enabler's true shifted horizontal position (X_final)
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:
IF(v["Status"]==1,0,((v["TOTAL WEIGHT (KG)"]/v["Number of Gravity Enablers"])*(v["Horizontal Distance X final (m)"]^2)))Live Evaluation: [ROUTE: GRID] IF(1.0000==1,0,((27750.0000/11.0000)*(-0.9587^2))) = 0.0000
|
| ☰ | \( I_{train} \) | Enabler train Moment of inertia (kg.m2) | 0.00 |
View Help GuidePurpose: 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 | ||||
| ☰ | \( d_{track} \) | Distance on track (m) | 0.13 |
View Help GuidePurpose: Determining the position of an enabler on the full track length
Logic: Pulls the absolute spatial location of the enabler from the master tracking loop (from the Spatial Blueprints).
Type: Calculated (Math Output)
Render on Grids: Rotational Torque
Mathematical Formula:
$$d_{track} = d_{track}$$ Python Logic:
v["Distance on track (m)"]Live Evaluation: [ROUTE: GRID] 0.1300 = 0.1300
|
| ☰ | \( d_{ce} \) | Centre Enabler Distance (m) | 3.11 |
View Help GuidePurpose: Distance centre gravity enabler tarvelled on the track across segments
Logic: Isolates the master tracking position of the "Centre" cart, which acts as the trigger for all system-wide tilt mechanisms.
Type: Calculated (Math Output)
Render on Grids: Rotational Torque
Mathematical Formula:
$$d_{ce} = P_{TAR,ce}$$ Python Logic:
v["TAR Centre Enabler Distance (m)"]Live Evaluation: [ROUTE: GRID] 3.1125 = 3.1125
|
| ☰ | \( P_{circ} \) | Enabler Circumference Distance (m) | 0.00 |
View Help GuidePurpose: Determines distance travelled by a gravity enabler on the rounded corner
Logic: Strips away the straightaway distances to isolate exactly how far the enabler has travelled within the curve itself.
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:
IF(v["Track Section"]==2,IF(
v["Distance on track (m)"]<v["Physical End Corner1 (m)"],v["Distance on track (m)"]-v["Physical End Straight1 (m)"],v["Distance on track (m)"]-v["Physical End Straight2 (m)"]),0)Live Evaluation: [ROUTE: GRID] IF(1.0000==2,IF(
0.1300<12.4000,0.1300-6.0000,0.1300-18.4000),0) = 0.0000
|
| ☰ | \( \alpha \) | Enabler Circumference Angle (degree) | 0.00 |
View Help GuidePurpose: 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/2.0372) = 0.0000
|
| ☰ | \( \theta_{eff,static} \) | Static Effective Angle for parallel force (degree) | 32.00 |
View Help GuidePurpose: Intermediate calculation for Effective Angle considering the track slant
Logic: Combines the enabler's position on the curve with the current tilt of the track to find the un-normalized force angle.
Type: Calculated (Math Output)
Render on Grids: Rotational Torque
Mathematical Formula:
$$\theta_{eff,static} = IF(\alpha==0,\theta_{slant},\theta_{slant}+\alpha)$$ Python Logic:
IF(v["Enabler Circumference Angle (degree)"]==0,v["Track Slant (degree)"],v["Track Slant (degree)"]+v["Enabler Circumference Angle (degree)"])Live Evaluation: [ROUTE: GRID] IF(0.0000==0,32.0000,32.0000+0.0000) = 32.0000
|
| ☰ | \( \theta_{eff} \) | Effective Angle for Parallel Force (degree) | 32.00 |
View Help GuidePurpose: Determinging the correct effective parallel force angle based on the geometry of the GMEG design
Logic: Normalizes the static angle based on whether the train is on a straight, and flips the geometric signs based on which cycle (side of the track) the enabler is traversing.
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:
IF(v["Track Section"] == 1, abs(v["Track Slant (degree)"]), IF(v["TAR Transformed Enabler Distance (m)"]<v["RotZone1 End (m)"],IF(v["Static Effective Angle for parallel force (degree)"] < 90, v["Static Effective Angle for parallel force (degree)"], 180 - v["Static Effective Angle for parallel force (degree)"]),IF(v["TAR Transformed Enabler Distance (m)"]<v["RotZone2 End (m)"],-IF(v["Static Effective Angle for parallel force (degree)"] < 90, v["Static Effective Angle for parallel force (degree)"], 180 - v["Static Effective Angle for parallel force (degree)"]), 0.0)))Live Evaluation: [ROUTE: GRID] IF(1.0000 == 1, abs(32.0000), IF(0.2600<13.3600,IF(32.0000 < 90, 32.0000, 180 - 32.0000),IF(0.2600<25.7600,-IF(32.0000 < 90, 32.0000, 180 - 32.0000), 0.0))) = 32.0000
|
| ☰ | \( X_{flat} \) | X flat (m) | -2.87 |
View Help GuidePurpose: Horizontal position with the track in a horizontal position
Logic: Calculates the raw horizontal (X) coordinate of the enabler assuming a completely flat, non-tilted track using basic trigonometry.
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:
IF(v["Track Section"]==1,
IF(v["Distance on track (m)"]<v["Physical End Corner1 (m)"],v["Distance on track (m)"]-(v["Straight track length (m)"]/2),(v["Straight track length (m)"]/2)-(v["Distance on track (m)"]-v["Physical End Corner1 (m)"])),
IF(v["Distance on track (m)"]<v["Physical End Corner1 (m)"],(v["Straight track length (m)"]/2)+(v["Internal Gear Radius (m)"]*SIN(RADIANS(v["Enabler Circumference Angle (degree)"]))),-(v["Straight track length (m)"]/2)-(v["Internal Gear Radius (m)"]*SIN(RADIANS(v["Enabler Circumference Angle (degree)"])))))Live Evaluation: [ROUTE: GRID] IF(1.0000==1,
IF(0.1300<12.4000,0.1300-(6.0000/2),(6.0000/2)-(0.1300-12.4000)),
IF(0.1300<12.4000,(6.0000/2)+(2.0372*SIN(RADIANS(0.0000))),-(6.0000/2)-(2.0372*SIN(RADIANS(0.0000))))) = -2.8700
|
| ☰ | \( Y_{flat} \) | Y flat (m) | 2.04 |
View Help GuidePurpose: Vertical position with the track in a horizontal position
Logic: Calculates the raw vertical (Y) coordinate of the enabler assuming a completely flat, non-tilted track.
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:
IF(v["Track Section"]==1,
IF(v["Distance on track (m)"]<v["Physical End Corner1 (m)"],v["Internal Gear Radius (m)"],-v["Internal Gear Radius (m)"]),
IF(v["Distance on track (m)"]<v["Physical End Corner1 (m)"],v["Internal Gear Radius (m)"]*COS(RADIANS(v["Enabler Circumference Angle (degree)"])),-v["Internal Gear Radius (m)"]*COS(RADIANS(v["Enabler Circumference Angle (degree)"]))))Live Evaluation: [ROUTE: GRID] IF(1.0000==1,
IF(0.1300<12.4000,2.0372,-2.0372),
IF(0.1300<12.4000,2.0372*COS(RADIANS(0.0000)),-2.0372*COS(RADIANS(0.0000)))) = 2.0372
|
| ☰ | \( X_{final} \) | Horizontal Distance X final (m) | -1.35 |
View Help GuidePurpose: 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.8700*COS(RADIANS(-32.0000)))-(2.0372*SIN(RADIANS(-32.0000))) = -1.3544
|
| ☰ | \( Y_{final} \) | Vertical Distance Y final (m) | 3.25 |
View Help GuidePurpose: 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.8700*SIN(RADIANS(-32.0000)))+(2.0372*COS(RADIANS(-32.0000))) = 3.2485
|
| ☰ | \( F_g \) | Gravitational Force Fg (N) | 24,747.95 |
View Help GuidePurpose: 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] (2272.7273+250.0000)*9.8100 = 24,747.9545
|
| ☰ | \( E_p \) | Gravitational Potential Energy GPE per Enabler (J) | 63,404.17 |
View Help GuidePurpose: 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] (((2272.7273*9.8100*3.2485)*0.9500)*0.9700)*(1-0.0500) = 63,404.1722
|
| ☰ | \( \Sigma E_{\text{gpe, enablers}} \) | Total Gravitational Potential Energy GPE of all Enablers (J) | 63,404.17 |
View Help GuidePurpose: 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] 63404.1722 = 63,404.1722
|
| ☰ | \( F_p \) | GMEG Parallel Force Fp (N) | 13,114.42 |
View Help GuidePurpose: 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] 24747.9545*SIN(RADIANS(32.0000)) = 13,114.4179
|
| ☰ | \( m_{en,p} \) | Parallel mass per Enabler (kg) | 1,336.84 |
View Help GuidePurpose: 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] 13114.4179/9.8100 = 1,336.8418
|
| ☰ | \( \tau_{GMEG} \) | GMEG Nm Output (Nm) | 26,716.47 |
View Help GuidePurpose: 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] 13114.4179*2.0372 = 26,716.4727
|
| ☰ | \( \eta_{loss} \) | Operational Efficiency (%) | 0.89 |
View Help GuidePurpose: 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) | 23,734.91 |
View Help GuidePurpose: 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] 26716.4727*0.8884 = 23,734.9143
|
| ☰ | \( \Sigma\tau_{GMEG} \) | Total GMEG Output per Segment (Nm) | 23,734.91 |
View Help GuidePurpose: 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] 23734.9143 = 23,734.9143
|
| ☰ | \( \tau_{def} \) | Torque Deficit (Nm) | 1,863.19 |
View Help GuidePurpose: 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] 23734.9143-(240588.9592/11.0000) = 1,863.1908
|
| ☰ | \( \Sigma \tau_{\text{deficit}} \) | Total Torque Deficit (Nm) | 1,863.19 |
View Help GuidePurpose: 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] 1863.1908 = 1,863.1908
|
| ☰ | \( \tau_{gear} \) | Gear System Torque (Nm) | 0.00 |
View Help GuidePurpose: Torque experienced by the DLLS per enabler during rotation cycles
Logic: Calculates the torque acting on the swiveling system by multiplying the gravitational force by the true horizontal lever arm (X_final)
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:
IF(v["Status"]==1,0,v["Horizontal Distance X final (m)"]*v["Gravitational Force Fg (N)"])Live Evaluation: [ROUTE: GRID] IF(1.0000==1,0,-1.3544*24747.9545) = 0.0000
|
| ☰ | \( \tau \) | Absolute Gear System Torque (Nm) | 0.00 |
View Help GuidePurpose: Absolute values to represent positive values for torque experienced by the DLLS
Logic: Normalizes the gear system torque for accurate aggregation regardless of orientation.
Type: Calculated (Math Output)
Render on Grids: Rotational Torque
Mathematical Formula:
$$` = IF(\text{Status}==1,0,ABS(\tau_{gear}))$$ Python Logic:
IF(v["Status"]==1,0,ABS(v["Gear System Torque (Nm)"]))Live Evaluation: [ROUTE: GRID] IF(1.0000==1,0,ABS(0.0000)) = 0.0000
|
| ☰ | \( \tau_{gear,train} \) | Enabler train Absolute Gear System Torque (Nm) | 0.00 |
View Help GuidePurpose: 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 GuidePurpose: Work done by the DLLS for that segment time frame, based on the angle per segment
Logic: Converts rotational torque into kinetic energy (Joules) expended during the rotation phase.
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:
IF(v["Status"]==1,0,v["Absolute Gear System Torque (Nm)"]*v["Angle Per Segment radians (rad/s)"])Live Evaluation: [ROUTE: GRID] IF(1.0000==1,0,0.0000*0.0175) = 0.0000
|
| ☰ | \( TW_{DLLS} \) | Total Work Done by DLLS Joule per Segment (J) | 0.00 |
View Help GuidePurpose: 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 GuidePurpose: Modelling inertia during a track arc rotation based on each enablers' position on the track
Logic: Calculates the rotational inertia using I=mr2, where the radius is the enabler's true shifted horizontal position (X_final)
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:
IF(v["Status"]==1,0,((v["TOTAL WEIGHT (KG)"]/v["Number of Gravity Enablers"])*(v["Horizontal Distance X final (m)"]^2)))Live Evaluation: [ROUTE: GRID] IF(1.0000==1,0,((27750.0000/11.0000)*(-1.3544^2))) = 0.0000
|
| ☰ | \( I_{train} \) | Enabler train Moment of inertia (kg.m2) | 0.00 |
View Help GuidePurpose: 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 | ||||
| ☰ | \( d_{track} \) | Distance on track (m) | 0.73 |
View Help GuidePurpose: Determining the position of an enabler on the full track length
Logic: Pulls the absolute spatial location of the enabler from the master tracking loop (from the Spatial Blueprints).
Type: Calculated (Math Output)
Render on Grids: Rotational Torque
Mathematical Formula:
$$d_{track} = d_{track}$$ Python Logic:
v["Distance on track (m)"]Live Evaluation: [ROUTE: GRID] 0.7265 = 0.7265
|
| ☰ | \( d_{ce} \) | Centre Enabler Distance (m) | 3.11 |
View Help GuidePurpose: Distance centre gravity enabler tarvelled on the track across segments
Logic: Isolates the master tracking position of the "Centre" cart, which acts as the trigger for all system-wide tilt mechanisms.
Type: Calculated (Math Output)
Render on Grids: Rotational Torque
Mathematical Formula:
$$d_{ce} = P_{TAR,ce}$$ Python Logic:
v["TAR Centre Enabler Distance (m)"]Live Evaluation: [ROUTE: GRID] 3.1125 = 3.1125
|
| ☰ | \( P_{circ} \) | Enabler Circumference Distance (m) | 0.00 |
View Help GuidePurpose: Determines distance travelled by a gravity enabler on the rounded corner
Logic: Strips away the straightaway distances to isolate exactly how far the enabler has travelled within the curve itself.
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:
IF(v["Track Section"]==2,IF(
v["Distance on track (m)"]<v["Physical End Corner1 (m)"],v["Distance on track (m)"]-v["Physical End Straight1 (m)"],v["Distance on track (m)"]-v["Physical End Straight2 (m)"]),0)Live Evaluation: [ROUTE: GRID] IF(1.0000==2,IF(
0.7265<12.4000,0.7265-6.0000,0.7265-18.4000),0) = 0.0000
|
| ☰ | \( \alpha \) | Enabler Circumference Angle (degree) | 0.00 |
View Help GuidePurpose: 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/2.0372) = 0.0000
|
| ☰ | \( \theta_{eff,static} \) | Static Effective Angle for parallel force (degree) | 32.00 |
View Help GuidePurpose: Intermediate calculation for Effective Angle considering the track slant
Logic: Combines the enabler's position on the curve with the current tilt of the track to find the un-normalized force angle.
Type: Calculated (Math Output)
Render on Grids: Rotational Torque
Mathematical Formula:
$$\theta_{eff,static} = IF(\alpha==0,\theta_{slant},\theta_{slant}+\alpha)$$ Python Logic:
IF(v["Enabler Circumference Angle (degree)"]==0,v["Track Slant (degree)"],v["Track Slant (degree)"]+v["Enabler Circumference Angle (degree)"])Live Evaluation: [ROUTE: GRID] IF(0.0000==0,32.0000,32.0000+0.0000) = 32.0000
|
| ☰ | \( \theta_{eff} \) | Effective Angle for Parallel Force (degree) | 32.00 |
View Help GuidePurpose: Determinging the correct effective parallel force angle based on the geometry of the GMEG design
Logic: Normalizes the static angle based on whether the train is on a straight, and flips the geometric signs based on which cycle (side of the track) the enabler is traversing.
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:
IF(v["Track Section"] == 1, abs(v["Track Slant (degree)"]), IF(v["TAR Transformed Enabler Distance (m)"]<v["RotZone1 End (m)"],IF(v["Static Effective Angle for parallel force (degree)"] < 90, v["Static Effective Angle for parallel force (degree)"], 180 - v["Static Effective Angle for parallel force (degree)"]),IF(v["TAR Transformed Enabler Distance (m)"]<v["RotZone2 End (m)"],-IF(v["Static Effective Angle for parallel force (degree)"] < 90, v["Static Effective Angle for parallel force (degree)"], 180 - v["Static Effective Angle for parallel force (degree)"]), 0.0)))Live Evaluation: [ROUTE: GRID] IF(1.0000 == 1, abs(32.0000), IF(0.8565<13.3600,IF(32.0000 < 90, 32.0000, 180 - 32.0000),IF(0.8565<25.7600,-IF(32.0000 < 90, 32.0000, 180 - 32.0000), 0.0))) = 32.0000
|
| ☰ | \( X_{flat} \) | X flat (m) | -2.27 |
View Help GuidePurpose: Horizontal position with the track in a horizontal position
Logic: Calculates the raw horizontal (X) coordinate of the enabler assuming a completely flat, non-tilted track using basic trigonometry.
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:
IF(v["Track Section"]==1,
IF(v["Distance on track (m)"]<v["Physical End Corner1 (m)"],v["Distance on track (m)"]-(v["Straight track length (m)"]/2),(v["Straight track length (m)"]/2)-(v["Distance on track (m)"]-v["Physical End Corner1 (m)"])),
IF(v["Distance on track (m)"]<v["Physical End Corner1 (m)"],(v["Straight track length (m)"]/2)+(v["Internal Gear Radius (m)"]*SIN(RADIANS(v["Enabler Circumference Angle (degree)"]))),-(v["Straight track length (m)"]/2)-(v["Internal Gear Radius (m)"]*SIN(RADIANS(v["Enabler Circumference Angle (degree)"])))))Live Evaluation: [ROUTE: GRID] IF(1.0000==1,
IF(0.7265<12.4000,0.7265-(6.0000/2),(6.0000/2)-(0.7265-12.4000)),
IF(0.7265<12.4000,(6.0000/2)+(2.0372*SIN(RADIANS(0.0000))),-(6.0000/2)-(2.0372*SIN(RADIANS(0.0000))))) = -2.2735
|
| ☰ | \( Y_{flat} \) | Y flat (m) | 2.04 |
View Help GuidePurpose: Vertical position with the track in a horizontal position
Logic: Calculates the raw vertical (Y) coordinate of the enabler assuming a completely flat, non-tilted track.
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:
IF(v["Track Section"]==1,
IF(v["Distance on track (m)"]<v["Physical End Corner1 (m)"],v["Internal Gear Radius (m)"],-v["Internal Gear Radius (m)"]),
IF(v["Distance on track (m)"]<v["Physical End Corner1 (m)"],v["Internal Gear Radius (m)"]*COS(RADIANS(v["Enabler Circumference Angle (degree)"])),-v["Internal Gear Radius (m)"]*COS(RADIANS(v["Enabler Circumference Angle (degree)"]))))Live Evaluation: [ROUTE: GRID] IF(1.0000==1,
IF(0.7265<12.4000,2.0372,-2.0372),
IF(0.7265<12.4000,2.0372*COS(RADIANS(0.0000)),-2.0372*COS(RADIANS(0.0000)))) = 2.0372
|
| ☰ | \( X_{final} \) | Horizontal Distance X final (m) | -0.85 |
View Help GuidePurpose: 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.2735*COS(RADIANS(-32.0000)))-(2.0372*SIN(RADIANS(-32.0000))) = -0.8485
|
| ☰ | \( Y_{final} \) | Vertical Distance Y final (m) | 2.93 |
View Help GuidePurpose: 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.2735*SIN(RADIANS(-32.0000)))+(2.0372*COS(RADIANS(-32.0000))) = 2.9324
|
| ☰ | \( F_g \) | Gravitational Force Fg (N) | 24,747.95 |
View Help GuidePurpose: 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] (2272.7273+250.0000)*9.8100 = 24,747.9545
|
| ☰ | \( E_p \) | Gravitational Potential Energy GPE per Enabler (J) | 57,234.59 |
View Help GuidePurpose: 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] (((2272.7273*9.8100*2.9324)*0.9500)*0.9700)*(1-0.0500) = 57,234.5946
|
| ☰ | \( \Sigma E_{\text{gpe, enablers}} \) | Total Gravitational Potential Energy GPE of all Enablers (J) | 120,638.77 |
View Help GuidePurpose: 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] 57234.5946+63404.1722 = 120,638.7669
|
| ☰ | \( F_p \) | GMEG Parallel Force Fp (N) | 13,114.42 |
View Help GuidePurpose: 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] 24747.9545*SIN(RADIANS(32.0000)) = 13,114.4179
|
| ☰ | \( m_{en,p} \) | Parallel mass per Enabler (kg) | 1,336.84 |
View Help GuidePurpose: 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] 13114.4179/9.8100 = 1,336.8418
|
| ☰ | \( \tau_{GMEG} \) | GMEG Nm Output (Nm) | 26,716.47 |
View Help GuidePurpose: 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] 13114.4179*2.0372 = 26,716.4727
|
| ☰ | \( \eta_{loss} \) | Operational Efficiency (%) | 0.89 |
View Help GuidePurpose: 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) | 23,734.91 |
View Help GuidePurpose: 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] 26716.4727*0.8884 = 23,734.9143
|
| ☰ | \( \Sigma\tau_{GMEG} \) | Total GMEG Output per Segment (Nm) | 47,469.83 |
View Help GuidePurpose: 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] 23734.9143+23734.9143 = 47,469.8287
|
| ☰ | \( \tau_{def} \) | Torque Deficit (Nm) | 1,863.19 |
View Help GuidePurpose: 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] 23734.9143-(240588.9592/11.0000) = 1,863.1908
|
| ☰ | \( \tau_{\tau_def} \) | Total Torque Deficit (Nm) | 3,726.38 |
View Help GuidePurpose: 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] 1863.1908+1863.1908 = 3,726.3816
|
| ☰ | \( \tau_{gear} \) | Gear System Torque (Nm) | 0.00 |
View Help GuidePurpose: Torque experienced by the DLLS per enabler during rotation cycles
Logic: Calculates the torque acting on the swiveling system by multiplying the gravitational force by the true horizontal lever arm (X_final)
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:
IF(v["Status"]==1,0,v["Horizontal Distance X final (m)"]*v["Gravitational Force Fg (N)"])Live Evaluation: [ROUTE: GRID] IF(1.0000==1,0,-0.8485*24747.9545) = 0.0000
|
| ☰ | \( \tau \) | Absolute Gear System Torque (Nm) | 0.00 |
View Help GuidePurpose: Absolute values to represent positive values for torque experienced by the DLLS
Logic: Normalizes the gear system torque for accurate aggregation regardless of orientation.
Type: Calculated (Math Output)
Render on Grids: Rotational Torque
Mathematical Formula:
$$` = IF(\text{Status}==1,0,ABS(\tau_{gear}))$$ Python Logic:
IF(v["Status"]==1,0,ABS(v["Gear System Torque (Nm)"]))Live Evaluation: [ROUTE: GRID] IF(1.0000==1,0,ABS(0.0000)) = 0.0000
|
| ☰ | \( \tau_{gear,train} \) | Enabler train Absolute Gear System Torque (Nm) | 0.00 |
View Help GuidePurpose: 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 GuidePurpose: Work done by the DLLS for that segment time frame, based on the angle per segment
Logic: Converts rotational torque into kinetic energy (Joules) expended during the rotation phase.
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:
IF(v["Status"]==1,0,v["Absolute Gear System Torque (Nm)"]*v["Angle Per Segment radians (rad/s)"])Live Evaluation: [ROUTE: GRID] IF(1.0000==1,0,0.0000*0.0175) = 0.0000
|
| ☰ | \( TW_{DLLS} \) | Total Work Done by DLLS Joule per Segment (J) | 0.00 |
View Help GuidePurpose: 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 GuidePurpose: Modelling inertia during a track arc rotation based on each enablers' position on the track
Logic: Calculates the rotational inertia using I=mr2, where the radius is the enabler's true shifted horizontal position (X_final)
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:
IF(v["Status"]==1,0,((v["TOTAL WEIGHT (KG)"]/v["Number of Gravity Enablers"])*(v["Horizontal Distance X final (m)"]^2)))Live Evaluation: [ROUTE: GRID] IF(1.0000==1,0,((27750.0000/11.0000)*(-0.8485^2))) = 0.0000
|
| ☰ | \( I_{train} \) | Enabler train Moment of inertia (kg.m2) | 0.00 |
View Help GuidePurpose: 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 GuidePurpose: 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/(32.0000*2) = 0.0156
|
| ☰ | \( t_{total} \) | Total time (s) | 0.02 |
View Help GuidePurpose: 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.0156 = 0.0156
|
| ☰ | \( W_g \) | Work Done by Gravity (J) | 1,704.87 |
View Help GuidePurpose: 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] 13114.4179*0.1300 = 1,704.8743
|
| ☰ | \( E_{trans} \) | DLLS Energy transferred to GMEG (J) | 0.00 |
View Help GuidePurpose: 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) | 85.24 |
View Help GuidePurpose: 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} = ABS(W_g \times \mu)$$ Python Logic:
ABS(v["Work Done by Gravity (J)"]*v["Friction factor (%)"])Live Evaluation: [ROUTE: GRID] ABS(1704.8743*0.0500) = 85.2437
|
| ☰ | \( E_{req} \) | GMEG Operational Requirement (J) | 1,313.23 |
View Help GuidePurpose: 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] (924.5116*1000)*(1/(32.0000*2)/11.0000) = 1,313.2268
|
| ☰ | \( E_{bal} \) | Energy Balance (J) | 306.40 |
View Help GuidePurpose: 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] 1704.8743+0.0000-85.2437-1313.2268 = 306.4038
|
| ☰ | \( E_k \) | KE for Train (J) | 306.40 |
View Help GuidePurpose: 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] 306.4038 = 306.4038
|
| ☰ | \( E_{k,op} \) | Total KE for Train at Operational Speed (J) | 306.40 |
View Help GuidePurpose: 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] 306.4038 = 306.4038
|
| ☰ | \( E_{bal,start} \) | Startup State Externally Powered Energy Balance (J) | 1,619.63 |
View Help GuidePurpose: 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] 1704.8743+0.0000-85.2437 = 1,619.6306
|
| ☰ | \( \Sigma E_{bal,start} \) | Startup State Externally Powered Accumulative Energy Balance (J) | 1,619.63 |
View Help GuidePurpose: 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}$$ Python Logic:
v["Startup State Externally Powered Energy Balance (J)"]Live Evaluation: [ROUTE: GRID] 1619.6306 = 1,619.6306
|
| ☰ | \( v_{start} \) | Startup State Externally Powered Velocity (m/s) | 0.34 |
View Help GuidePurpose: 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["Startup State Externally Powered Accumulative Energy Balance (J)"]/v["TOTAL WEIGHT (KG)"])Live Evaluation: [ROUTE: GRID] SQRT(2*1619.6306/27750.0000) = 0.3417
|
| ☰ | \( E_{bal,op} \) | Operational State Steady Velocity Energy Balance (J) | 306.40 |
View Help GuidePurpose: 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] 1704.8743+0.0000-85.2437-1313.2268 = 306.4038
|
| ☰ | \( \Sigma E_{bal,op} \) | Operational State Steady Velocity Accumulative Energy Balance (J) | 306.40 |
View Help GuidePurpose: 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] 306.4038 = 306.4038
|
| ☰ | \( v_{op} \) | Operational State Steady Velocity (m/s) | 0.15 |
View Help GuidePurpose: 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(2*v["Operational State Steady Velocity Accumulative Energy Balance (J)"]/v["TOTAL WEIGHT (KG)"])Live Evaluation: [ROUTE: GRID] SQRT(2*306.4038/27750.0000) = 0.1486
|
| ☰ | \( E_{in,supp} \) | Additional Support System Input (J) | 0.00 |
View Help GuidePurpose: 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/ALive Evaluation: N/A (Input Variable)
|
| ☰ | \( E_{bal,supp} \) | Additional Support System Energy Balance (J) | 0.00 |
View Help GuidePurpose: 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/ALive Evaluation: N/A (Input Variable)
|
| ☰ | \( \Sigma E_{bal,supp} \) | Additional Support System Accumulative Energy Balance (J) | 0.00 |
View Help GuidePurpose: 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/ALive Evaluation: N/A (Input Variable)
|
| ☰ | \( v_{supp} \) | Additional Support System Velocity (m/s) | 0.00 |
View Help GuidePurpose: 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/ALive Evaluation: N/A (Input Variable)
|
| ▼ 5. ENERGY BALANCE BLUEPRINTS - S1 E2 Loop | ||||
| ☰ | \( t_{seg} \) | Time per segment (s) | 0.02 |
View Help GuidePurpose: 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.0156 = 0.0156
|
| ☰ | \( t_{total} \) | Total time (s) | 0.02 |
View Help GuidePurpose: 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.0156 = 0.0156
|
| ☰ | \( W_g \) | Work Done by Gravity (J) | 1,704.87 |
View Help GuidePurpose: 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] 13114.4179*0.1300 = 1,704.8743
|
| ☰ | \( E_{trans} \) | DLLS Energy transferred to GMEG (J) | 0.00 |
View Help GuidePurpose: 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) | 85.24 |
View Help GuidePurpose: 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] 1704.8743*0.0500 = 85.2437
|
| ☰ | \( E_{req} \) | GMEG Operational Requirement (J) | 1,313.23 |
View Help GuidePurpose: 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] (924.5116*1000)*(1/(32.0000*2)/11.0000) = 1,313.2268
|
| ☰ | \( E_{bal} \) | Energy Balance (J) | 306.40 |
View Help GuidePurpose: 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] 1704.8743+0.0000-85.2437-1313.2268 = 306.4038
|
| ☰ | \( E_k \) | KE for Train (J) | 306.40 |
View Help GuidePurpose: 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] 306.4038 = 306.4038
|
| ☰ | \( E_{k,op} \) | Total KE for Train at Operational Speed (J) | 612.81 |
View Help GuidePurpose: 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] 306.4038+306.4038 = 612.8077
|
| ☰ | \( E_{bal,start} \) | Startup State Externally Powered Energy Balance (J) | 1,619.63 |
View Help GuidePurpose: 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] 1704.8743+0.0000-85.2437 = 1,619.6306
|
| ☰ | \( \Sigma E_{bal,start} \) | Startup State Externally Powered Accumulative Energy Balance (J) | 3,239.26 |
View Help GuidePurpose: 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["Startup State Externally Powered Energy Balance (J)"]+v_prev["Startup State Externally Powered Accumulative Energy Balance (J)"]Live Evaluation: [ROUTE: GRID] 1619.6306+1619.6306 = 3,239.2612
|
| ☰ | \( v_{start} \) | Startup State Externally Powered Velocity (m/s) | 0.48 |
View Help GuidePurpose: 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["Startup State Externally Powered Accumulative Energy Balance (J)"]/v["TOTAL WEIGHT (KG)"])Live Evaluation: [ROUTE: GRID] SQRT(2*3239.2612/27750.0000) = 0.4832
|
| ☰ | \( E_{bal,op} \) | Operational State Steady Velocity Energy Balance (J) | 306.40 |
View Help GuidePurpose: 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] 1704.8743+0.0000-85.2437-1313.2268 = 306.4038
|
| ☰ | \( \Sigma E_{bal,op} \) | Operational State Steady Velocity Accumulative Energy Balance (J) | 612.81 |
View Help GuidePurpose: 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] 306.4038+306.4038 = 612.8077
|
| ☰ | \( v_{op} \) | Operational State Steady Velocity (m/s) | 0.21 |
View Help GuidePurpose: 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(2*v["Operational State Steady Velocity Accumulative Energy Balance (J)"]/v["TOTAL WEIGHT (KG)"])Live Evaluation: [ROUTE: GRID] SQRT(2*612.8077/27750.0000) = 0.2102
|
| ☰ | \( E_{in,supp} \) | Additional Support System Input (J) | 0.00 |
View Help GuidePurpose: 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/ALive Evaluation: N/A (Input Variable)
|
| ☰ | \( E_{bal,supp} \) | Additional Support System Energy Balance (J) | 0.00 |
View Help GuidePurpose: 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/ALive Evaluation: N/A (Input Variable)
|
| ☰ | \( \Sigma E_{bal,supp} \) | Additional Support System Accumulative Energy Balance (J) | 0.00 |
View Help GuidePurpose: 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/ALive Evaluation: N/A (Input Variable)
|
| ☰ | \( v_{supp} \) | Additional Support System Velocity (m/s) | 0.00 |
View Help GuidePurpose: 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/ALive Evaluation: N/A (Input Variable)
|
| ▼ 5. ENERGY BALANCE BLUEPRINTS - S2 E1 Transition | ||||
| ☰ | \( t_{seg} \) | Time per segment (s) | 0.02 |
View Help GuidePurpose: 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.1300/8.3200 = 0.0156
|
| ☰ | \( t_{total} \) | Total time (s) | 0.03 |
View Help GuidePurpose: 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.0156+0.0156 = 0.0312
|
| ☰ | \( W_g \) | Work Done by Gravity (J) | 1,704.87 |
View Help GuidePurpose: 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] 13114.4179*0.1300 = 1,704.8743
|
| ☰ | \( E_{trans} \) | DLLS Energy transferred to GMEG (J) | 0.00 |
View Help GuidePurpose: 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) | 85.24 |
View Help GuidePurpose: 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] 1704.8743*0.0500 = 85.2437
|
| ☰ | \( E_{req} \) | GMEG Operational Requirement (J) | 1,313.23 |
View Help GuidePurpose: 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] (924.5116*1000)*(1/(32.0000*2)/11.0000) = 1,313.2268
|
| ☰ | \( E_{bal} \) | Energy Balance (J) | 306.40 |
View Help GuidePurpose: 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] 1704.8743+0.0000-85.2437-1313.2268 = 306.4038
|
| ☰ | \( E_k \) | KE for Train (J) | 306.40 |
View Help GuidePurpose: 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] 306.4038 = 306.4038
|
| ☰ | \( E_{k,op} \) | Total KE for Train at Operational Speed (J) | 306.40 |
View Help GuidePurpose: 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] 306.4038 = 306.4038
|
| ☰ | \( E_{bal,start} \) | Startup State Externally Powered Energy Balance (J) | 1,619.63 |
View Help GuidePurpose: 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] 1704.8743+0.0000-85.2437 = 1,619.6306
|
| ☰ | \( \Sigma E_{bal,start} \) | Startup State Externally Powered Accumulative Energy Balance (J) | 19,435.57 |
View Help GuidePurpose: 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["Startup State Externally Powered Energy Balance (J)"]+v_prev["Startup State Externally Powered Accumulative Energy Balance (J)"]Live Evaluation: [ROUTE: GRID] 1619.6306+17815.9367 = 19,435.5673
|
| ☰ | \( v_{start} \) | Startup State Externally Powered Velocity (m/s) | 0.48 |
View Help GuidePurpose: 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["Startup State Externally Powered Accumulative Energy Balance (J)"]/v["TOTAL WEIGHT (KG)"])Live Evaluation: [ROUTE: GRID] SQRT(2*3239.2612/27750.0000) = 0.4832
|
| ☰ | \( E_{bal,op} \) | Operational State Steady Velocity Energy Balance (J) | 306.40 |
View Help GuidePurpose: 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] 1704.8743+0.0000-85.2437-1313.2268 = 306.4038
|
| ☰ | \( \Sigma E_{bal,op} \) | Operational State Steady Velocity Accumulative Energy Balance (J) | 3,676.85 |
View Help GuidePurpose: 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] 306.4038+3370.4422 = 3,676.8460
|
| ☰ | \( v_{op} \) | Operational State Steady Velocity (m/s) | 0.21 |
View Help GuidePurpose: 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(2*v["Operational State Steady Velocity Accumulative Energy Balance (J)"]/v["TOTAL WEIGHT (KG)"])Live Evaluation: [ROUTE: GRID] SQRT(2*612.8077/27750.0000) = 0.2102
|
| ☰ | \( E_{in,supp} \) | Additional Support System Input (J) | 0.00 |
View Help GuidePurpose: 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/ALive Evaluation: N/A (Input Variable)
|
| ☰ | \( E_{bal,supp} \) | Additional Support System Energy Balance (J) | 0.00 |
View Help GuidePurpose: 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/ALive Evaluation: N/A (Input Variable)
|
| ☰ | \( \Sigma E_{bal,supp} \) | Additional Support System Accumulative Energy Balance (J) | 0.00 |
View Help GuidePurpose: 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/ALive Evaluation: N/A (Input Variable)
|
| ☰ | \( v_{supp} \) | Additional Support System Velocity (m/s) | 0.00 |
View Help GuidePurpose: 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/ALive Evaluation: N/A (Input Variable)
|
| ▼ 5. ENERGY BALANCE BLUEPRINTS - S2 E2 Cascade | ||||
| ☰ | \( t_{seg} \) | Time per segment (s) | 0.02 |
View Help GuidePurpose: 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.0156 = 0.0156
|
| ☰ | \( t_{total} \) | Total time (s) | 0.03 |
View Help GuidePurpose: 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.0312 = 0.0312
|
| ☰ | \( W_g \) | Work Done by Gravity (J) | 1,704.87 |
View Help GuidePurpose: 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] 13114.4179*0.1300 = 1,704.8743
|
| ☰ | \( E_{trans} \) | DLLS Energy transferred to GMEG (J) | 0.00 |
View Help GuidePurpose: 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) | 85.24 |
View Help GuidePurpose: 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] 1704.8743*0.0500 = 85.2437
|
| ☰ | \( E_{req} \) | GMEG Operational Requirement (J) | 1,313.23 |
View Help GuidePurpose: 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] (924.5116*1000)*(1/(32.0000*2)/11.0000) = 1,313.2268
|
| ☰ | \( E_{bal} \) | Energy Balance (J) | 306.40 |
View Help GuidePurpose: 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] 1704.8743+0.0000-85.2437-1313.2268 = 306.4038
|
| ☰ | \( E_k \) | KE for Train (J) | 306.40 |
View Help GuidePurpose: 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] 306.4038 = 306.4038
|
| ☰ | \( E_{k,op} \) | Total KE for Train at Operational Speed (J) | 612.81 |
View Help GuidePurpose: 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] 306.4038+306.4038 = 612.8077
|
| ☰ | \( E_{bal,start} \) | Startup State Externally Powered Energy Balance (J) | 1,619.63 |
View Help GuidePurpose: 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] 1704.8743+0.0000-85.2437 = 1,619.6306
|
| ☰ | \( \Sigma E_{bal,start} \) | Startup State Externally Powered Accumulative Energy Balance (J) | 4,858.89 |
View Help GuidePurpose: 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["Startup State Externally Powered Energy Balance (J)"]+v_prev["Startup State Externally Powered Accumulative Energy Balance (J)"]Live Evaluation: [ROUTE: GRID] 1619.6306+3239.2612 = 4,858.8918
|
| ☰ | \( v_{start} \) | Startup State Externally Powered Velocity (m/s) | 1.23 |
View Help GuidePurpose: 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["Startup State Externally Powered Accumulative Energy Balance (J)"]/v["TOTAL WEIGHT (KG)"])Live Evaluation: [ROUTE: GRID] SQRT(2 *21055.1979/27750.0000) = 1.2319
|
| ☰ | \( E_{bal,op} \) | Operational State Steady Velocity Energy Balance (J) | 306.40 |
View Help GuidePurpose: 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] 1704.8743+0.0000-85.2437-1313.2268 = 306.4038
|
| ☰ | \( \Sigma E_{bal,op} \) | Operational State Steady Velocity Accumulative Energy Balance (J) | 919.21 |
View Help GuidePurpose: 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] 306.4038+612.8077 = 919.2115
|
| ☰ | \( v_{op} \) | Operational State Steady Velocity (m/s) | 0.54 |
View Help GuidePurpose: 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(2*v["Operational State Steady Velocity Accumulative Energy Balance (J)"]/v["TOTAL WEIGHT (KG)"])Live Evaluation: [ROUTE: GRID] SQRT(2*3983.2498/27750.0000) = 0.5358
|
| ☰ | \( E_{in,supp} \) | Additional Support System Input (J) | 0.00 |
View Help GuidePurpose: 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/ALive Evaluation: N/A (Input Variable)
|
| ☰ | \( E_{bal,supp} \) | Additional Support System Energy Balance (J) | 0.00 |
View Help GuidePurpose: 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/ALive Evaluation: N/A (Input Variable)
|
| ☰ | \( \Sigma E_{bal,supp} \) | Additional Support System Accumulative Energy Balance (J) | 0.00 |
View Help GuidePurpose: 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/ALive Evaluation: N/A (Input Variable)
|
| ☰ | \( v_{supp} \) | Additional Support System Velocity (m/s) | 0.00 |
View Help GuidePurpose: 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/ALive Evaluation: N/A (Input Variable)
|
| ▼ 6. OPERATIONAL TOTALS | ||||
| ☰ | \( \Sigma \tau_{\text{seg, gmeg}} \) | Segment Total GMEG Output (Nm) | 261,084.06 |
View Help GuidePurpose: 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) = 261,084.0577
|
| ☰ | \( W_{\text{seg, work}} \) | Segment Work Done by DLLS Joule (J) | 0.00 |
View Help GuidePurpose: 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 GuidePurpose: 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) | 372,909.56 |
View Help GuidePurpose: 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) = 372,909.5639
|
| ☰ | \( I_{\text{seg, train}} \) | Segment Enabler train Moment of inertia (kg.m2) | 0.00 |
View Help GuidePurpose: 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) | 3,370.44 |
View Help GuidePurpose: 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) = 3,370.4422
|
| ☰ | \( v_{\text{seg, start}} \) | Segment Startup State Externally Powered Velocity (m/s) | 1.13 |
View Help GuidePurpose: 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", "Startup State Externally Powered Velocity (m/s)", N_{seg})$$ Python Logic:
GET_SEGMENT_FINAL("Energy Balance", "Startup State Externally Powered Velocity (m/s)", v["Segment Number"])Live Evaluation: [ROUTE: GRID] GET_SEGMENT_FINAL("Energy Balance", "Startup State Externally Powered Velocity (m/s)", 1.0000) = 1.1332
|
| ☰ | \( \eta_{\text{seg, op}} \) | Segment Operational State Steady Velocity (m/s) | 0.49 |
View Help GuidePurpose: 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.4929
|