| ▼ Enabler Details | ||||
| ☰ | \( R_{\text{swing}} \) | Enabler Swing Radius | 0.000000 |
View Help GuidePurpose: Determing the space needed for a free swivelling enabler
Logic: Pulled directly from the Track sheet to ensure the mathematical spacing perfectly matches the physical safety clearances modeled later.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
N/A Python Logic:
N/ALive Evaluation: N/A
|
| ☰ | \( L_{\text{gap}} \) | Enabler gap length (m) |
View Help GuidePurpose: Space between enablers in the train
Logic: Ensures the cylinders have enough breathing room (with a safety buffer) so they don't grind against each other as the chain bends around the gears.
Type: Manual Entry
Render on Grids: None
Mathematical Formula:
$$\text{User Input}$$ Python Logic:
N/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( L_{\text{train}} \) | Enabler train length (m) | 6.561500 |
View Help GuidePurpose: Total enabler train length to influence rotational torque calculations
Logic: Tells us how much of the track is physically loaded at any given time. This drives the torque calculations as the train snakes through the curves and straightaways.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$L_{\text{train}} = N_{\text{enablers}} \times L_{\text{gap}}$$ Python Logic:
v["Number of Gravity Enablers"]*v["Enabler gap length (m)"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 11.0000*0.5965 = 6.5615
|
| ▼ Gravity | ||||
| ☰ | \( N \) | Gravitational Field Strength (N/kg) |
View Help GuidePurpose: How much force Earth pulls with for every kilogram of an enabler's mass
Logic: Adjustable setting for modelling the gravitational potential based on the gravitational field strength in different environments
Type: Manual Entry
Render on Grids: None
Mathematical Formula:
$$\text{User Input}$$ Python Logic:
N/ALive Evaluation: N/A (Input Variable)
|
|
| ▼ GMEG Power Input | ||||
| ☰ | \( M_{\text{payload}} \) | Weight used (kg) |
View Help GuidePurpose: User input for determining weight input
Logic: This is the primary fuel for our gravity engine. It sets the baseline for all downward gravitational force calculations.
Type: Manual Entry
Render on Grids: None
Mathematical Formula:
$$\text{User Input}$$ Python Logic:
N/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( N_{\text{enablers}} \) | Number of Gravity Enablers |
View Help GuidePurpose: Adjustable gravity enabler train configuration
Logic: Breaks the total mass into an articulating "train" so it can snake around the track curves instead of being one rigid, unbendable block.
Type: Manual Entry
Render on Grids: None
Mathematical Formula:
$$\text{User Input}$$ Python Logic:
N/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( C_{\text{pos}} \) | Centre enabler | 5.500000 |
View Help GuidePurpose: Determining central enabler
Logic: Used to map the center of mass for the entire train, which is critical for tracking its position and torque output as it moves around the track.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$C_{\text{pos}} = ((N_{\text{enablers}}/2)-1)+1$$ Python Logic:
((v["Number of Gravity Enablers"]/2)-1)+1Live Evaluation: [ROUTE: STATIC/GLOBAL] ((11.0000/2)-1)+1 = 5.5000
|
| ☰ | \( N_{\text{centre}} \) | Absolute Centre Enabler | 6.000000 |
View Help GuidePurpose: Central enabler number
Logic: You cannot track "enabler 5.5", so this gives us the exact physical link to track for the system's pivot and balance equations.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$N_{\text{centre}} = ROUNDUP(C_{\text{pos}},0)$$ Python Logic:
=ROUNDUP(v["Centre enabler"],0)Live Evaluation: [ROUTE: STATIC/GLOBAL] ROUNDUP(5.5000,0) = 6.0000
|
| ☰ | \( N_{\text{row, centre}} \) | Centre enabler row | 0.000000 |
View Help GuidePurpose: Row position of the centre enabler
Logic: Tells Excel exactly where to look to pull the dynamic torque and position data for the middle of the moving train.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$N_{\text{row, centre}} = 0$$ Python Logic:
0Live Evaluation: [ROUTE: STATIC/GLOBAL] 0 = 0.0000
|
| ☰ | \( W_{\text{unit}} \) | Weight per gravity enabler (kg) | 2,272.727273 |
View Help GuidePurpose: Weight per gravity enabler for torque calculations
Logic: Divides the total payload evenly to calculate the localized torque each individual link applies to the internal gear.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$W_{\text{unit}} = M_{\text{payload}}/N_{\text{enablers}}$$ Python Logic:
=v["Weight used (kg)"]/v["Number of Gravity Enablers"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 25,000.0000/11.0000 = 2,272.7273
|
| ☰ | \( N_{\text{sides}} \) | Sides per gravity enabler |
View Help GuidePurpose: Gravitational balance factor
Logic: Splits the mass evenly across the left and right tracks to ensure the train stays perfectly balanced and doesn't twist the central drive chain.
Type: Manual Entry
Render on Grids: None
Mathematical Formula:
$$\text{User Input}$$ Python Logic:
N/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( M_{\text{side}} \) | Weight Per side (kg) | 1,136.363636 |
View Help GuidePurpose: Weight per side on gravity enabler for dimensional calculations
Logic: Used to calculate the physical dimensions (volume) of the weight blocks required on each side of the chain.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$M_{\text{side}} = M_{\text{unit}}/N_{\text{sides}}$$ Python Logic:
v["Weight per gravity enabler (kg)"]/v["Sides per gravity enabler"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 2,272.7273/2.0000 = 1,136.3636
|
| ☰ | \( \rho_{\text{steel}} \) | Steel density (kg/m³) |
View Help GuidePurpose: Material density specification
Logic: Translates our required mass (kg) into an actual physical size (cubic meters) so we can ensure the steel blocks fit inside the track cavity.
Type: Manual Entry
Render on Grids: None
Mathematical Formula:
$$\text{User Input}$$ Python Logic:
N/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( V_{\text{side}} \) | Volume per side (m3) | 0.144760 |
View Help GuidePurpose: Volume of gravity enabler based on material density
Logic: Determines how bulky the steel blocks need to be to achieve the target payload weight.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$V_{\text{side}} = M_{\text{side}}/\rho_{\text{steel}}$$ Python Logic:
v["Weight Per side (kg)"]/v["Steel density (kg/m³)"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 1,136.3636/7,850.0000 = 0.1448
|
| ☰ | \( L_{\text{enab, len}} \) | Length (m) |
View Help GuidePurpose: Defines the total length of the gravity enabler side weight based on the track width.
Logic: Constrains the dimension based on the available track width, forcing the simulator to adjust the diameter to make the required volume fit.
Type: Manual Entry
Render on Grids: None
Mathematical Formula:
$$\text{User Input}$$ Python Logic:
N/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( W_{\text{enab, width}} \) | Enabler diameter (m) | 0.578892 |
View Help GuidePurpose: Sizing of each individual enabler to determine the length of the train
Logic: Automatically sizes the cylinder so it hits the exact required weight while fitting within the track width constraint.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$W_{\text{enab, width}} = 2 \times \sqrt{M_{\text{unit}}/ (\pi \times \rho_{\text{steel}} \times L_{\text{enab, len}}))$$ Python Logic:
=2 * SQRT(v["Weight per gravity enabler (kg)"]/ (PI() * v["Steel density (kg/m³)"]* v["Length (m)"]))Live Evaluation: [ROUTE: STATIC/GLOBAL] 2 * SQRT(2,272.7273/ (PI() * 7,850.0000* 1.1000)) = 0.5789
|
| ☰ | \( H_{\text{enab}} \) | Height (m) | 0.289446 |
View Help GuidePurpose: Height of the enabler
Logic: Defines how far the weight extends outward (its radius), which dictates how much clearance we need so adjacent enablers don't crash into each other.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$H_{\text{enab}} = W_{\text{enab, width}}/2$$ Python Logic:
=v["Enabler diameter (m)"]/2Live Evaluation: [ROUTE: STATIC/GLOBAL] 0.5789/2 = 0.2894
|
| ☰ | \( M_{\text{holder}} \) | Gravity enabler holder weight (kg) |
View Help GuidePurpose: Manual input but to be determined later by track calculator
Logic: Adds the "parasitic" mass of the bearings, pins, and frame so our calculations reflect the true total weight moving through the system.
Type: Manual Entry
Render on Grids: None
Mathematical Formula:
$$\text{User Input}$$ Python Logic:
N/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( M_{\text{support}} \) | Total Gravity enabler holder weight (kg) | 2,750.000000 |
View Help GuidePurpose: Proposed weight of supportive gravity enabler train
Logic: Aggregates the structural hardware mass to add to the payload mass for a realistic system total.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$M_{\text{support}} = M_{\text{holder}} \times N_{\text{enablers}}$$ Python Logic:
v["Gravity enabler holder weight (kg)"]*v["Number of Gravity Enablers"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 250.0000*11.0000 = 2,750.0000
|
| ☰ | \( M_{\text{total}} \) | TOTAL WEIGHT (KG) | 27,750.000000 |
View Help GuidePurpose: Total weight of gravity enabler train
Logic: The master gravity variable. This is the final, true mass that the system uses to calculate input force and inertial loads.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$M_{\text{total}} = M_{\text{payload}}+M_{\text{support}}$$ Python Logic:
v["Weight used (kg)"]+v["Total Gravity enabler holder weight (kg)"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 25,000.0000+2,750.0000 = 27,750.0000
|
| ☰ | \( F_{\text{total}} \) | Force (N) | 272,227.500000 |
View Help GuidePurpose: Total weight of gravity enabler train in the gravitational field
Logic: Converts the raw mass (kg) into actual gravitational force (Newtons) by multiplying by Earth's gravity (9.81). This is the raw energy entering the machine.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$F_{\text{total}} = M_{\text{total}} \times N$$ Python Logic:
v["TOTAL WEIGHT (KG)"]*v["Gravitational Field Strength (N/kg)"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 27,750.0000*9.8100 = 272,227.5000
|
| ▼ Internal gear | ||||
| ☰ | \( L_{\text{link}} \) | Chain link (m) |
View Help GuidePurpose: Size of chain link
Logic: Acts as the base unit of measurement for sizing the internal gears and track components. Everything scales mathematically from the size of this link.
Type: Manual Entry
Render on Grids: None
Mathematical Formula:
$$\text{User Input}$$ Python Logic:
N/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( Z_{\text{int}} \) | Internal Gear teeth |
View Help GuidePurpose: Set number of teeth of internal gear
Logic: Multiplies with the chain link size to lock in the exact circumference of the gears, dictating the overall scale of the machine's turnaround points.
Type: Manual Entry
Render on Grids: None
Mathematical Formula:
$$\text{User Input}$$ Python Logic:
N/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( C_{\text{int}} \) | Internal Gear Circumference (m) | 12.800000 |
View Help GuidePurpose: Total length around the internal gear
Logic: Defines the track's turnaround footprint. This distance dictates how long the curved ends of the track need to be to perfectly wrap around the gear.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$C_{\text{int}} = L_{\text{link}} \times Z_{\text{int}}$$ Python Logic:
v["Chain link (m)"]*v["Internal Gear teeth"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 0.1000*128.0000 = 12.8000
|
| ☰ | \( C_{\text{half}} \) | Half Internal Gear Circumference (m) | 6.400000 |
View Help GuidePurpose: Circumference length of rounded corner
Logic: Represents the exact physical distance the enabler train travels while navigating a single curved end-cap.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$C_{\text{half}} = C_{\text{int}}/2$$ Python Logic:
v["Internal Gear Circumference (m)"]/2Live Evaluation: [ROUTE: STATIC/GLOBAL] 12.8000/2 = 6.4000
|
| ☰ | \( C_{\text{corner, dist}} \) | Half semi corner Circumference (m) | 3.200000 |
View Help GuidePurpose: Distance from centre to end of rounded corner
Logic: Maps the transition points of the enabler train as it moves from the straight track into the peak of the curve, which is crucial for dynamic load timing.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$C_{\text{corner, dist}} = C_{\text{half}}/2$$ Python Logic:
v["Half Internal Gear Circumference (m)"]/2Live Evaluation: [ROUTE: STATIC/GLOBAL] 6.4000/2 = 3.2000
|
| ☰ | \( Ratio_{\text{half/train}} \) | Half Internal Gear Circumference (m) to Ratio to enabler train length | 0.975387 |
View Help GuidePurpose: Ratio of enabler train to rounded corner, must be more than 1
Logic: Ensures the entire train can fit inside the curve without spilling too much over into the straight sections. The aim is always to have this as close to or at least 1 or higher where possible
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$Ratio_{\text{half/train}} = C_{\text{half}}/L_{\text{train}}$$ Python Logic:
v["Half Internal Gear Circumference (m)"]/v["Enabler train length (m)"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 6.4000/6.5615 = 0.9754
|
| ☰ | \( D_{\text{int}} \) | Internal Gear Diameter (m) | 4.074367 |
View Help GuidePurpose: Diameter measurement for height of track
Logic: Directly sets the vertical gap between the top and bottom straight runs of the track. It defines how tall the inner skeleton needs to be.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$D_{\text{int}} = C_{\text{int}}/\pi$$ Python Logic:
v["Internal Gear Circumference (m)"]/PI()Live Evaluation: [ROUTE: STATIC/GLOBAL] 12.8000/PI() = 4.0744
|
| ☰ | \( R_{\text{int}} \) | Internal Gear Radius (m) | 2.037183 |
View Help GuidePurpose: Radius for torque and side-to-side length of track
Logic: This is the main "Lever Arm" for the machine. It is the master variable used to convert the linear chain pull into rotational torque.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$R_{\text{int}} = D_{\text{int}}/2$$ Python Logic:
v["Internal Gear Diameter (m)"]/2Live Evaluation: [ROUTE: STATIC/GLOBAL] 4.0744/2 = 2.0372
|
| ☰ | \( n_{\text{rps}} \) | Internal Gear rotations per second |
View Help GuidePurpose: Manual setting of internal gear rotations per second
Logic: The master speed controller for the GMEG. This drives all downstream velocity, momentum, and kinetic energy calculations.
Type: Manual Entry
Render on Grids: None
Mathematical Formula:
$$\text{User Input}$$ Python Logic:
N/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( n_{\text{rpm}} \) | Internal Gear RPM | 39.000000 |
View Help GuidePurpose: GMEG operational RPM
Logic: A standard engineering metric used to map gear ratios and sync the GMEG output with the downstream generators and flywheels.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$n_{\text{rpm}} = n_{\text{rps}} \times 60$$ Python Logic:
v["Internal Gear rotations per second"]*60Live Evaluation: [ROUTE: STATIC/GLOBAL] 0.6500*60 = 39.0000
|
| ☰ | \( \omega_{\text{int}} \) | Internal Gear angular velocity radians per second | 4.084070 |
View Help GuidePurpose: Angular velocity of internal gear
Logic: The pure physics variable required for all rotational kinetic energy, centrifugal force, and dynamic torque equations.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$\omega_{\text{int}} = n_{\text{rps}} \times 2 \times \pi$$ Python Logic:
=v["Internal Gear rotations per second"]*2*PI()Live Evaluation: [ROUTE: STATIC/GLOBAL] 0.6500*2*PI() = 4.0841
|
| ☰ | \( L_{\text{seg}} \) | Distance travelled per segment (m) | 0.130000 |
View Help GuidePurpose: Segment based calculations
Logic: Breaks the continuous motion into tiny, bite-sized chunks so the simulator can accurately calculate torque changes segment-by-segment instead of guessing averages.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$L_{\text{seg}} = v/(\theta_{\text{tilt}} \times 2)$$ Python Logic:
v["Operational Velocity (m/s)"]/(v["Angle tilt (degrees)"]*2)Live Evaluation: [ROUTE: STATIC/GLOBAL] 8.3200/(32.0000*2) = 0.1300
|
| ☰ | \( \theta_{\text{tilt}} \) | Angle tilt (degrees) |
View Help GuidePurpose: Adjustable input for GMEG operation and output
Logic: Resolves gravity into lateral and vertical components. The steeper the angle, the more raw gravitational force is harvested to push the enablers down the track.
Type: Manual Entry
Render on Grids: None
Mathematical Formula:
$$\text{User Input}$$ Python Logic:
N/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( F_{\text{in}} \) | Internal Gear Force in (N) | 144,258.596504 |
View Help GuidePurpose: Reduced input force due to angle of track
Logic: Multiplies the total train weight by gravity, then scales it down based on the tilt angle. This is the raw linear input force before mechanical losses.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$F_{\text{in}} = (M_{\text{total}} \times N) \times \sin(\text{rad}(\theta_{\text{tilt}}))$$ Python Logic:
=(v["TOTAL WEIGHT (KG)"] * v["Gravitational Field Strength (N/kg)"]) * SIN(RADIANS(v["Angle tilt (degrees)"]))Live Evaluation: [ROUTE: STATIC/GLOBAL] (27,750.0000 * 9.8100) * SIN(RADIANS(32.0000)) = 144,258.5965
|
| ☰ | \( \eta_{\text{gear}} \) | Gear efficiency (%) |
View Help GuidePurpose: Gear efficiency rating
Logic: No gear is perfect. This applies an engineering penalty to the power transfer so we aren't claiming impossible, 100% efficient physics.
Type: Manual Entry
Render on Grids: None
Mathematical Formula:
$$\text{User Input}$$ Python Logic:
N/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( \eta_{\text{bearing}} \) | Bearing efficiency friction factor (%) |
View Help GuidePurpose: Bearing efficiency setting
Logic: Ensures our output numbers account for real-world mechanical drag under heavy loads.
Type: Manual Entry
Render on Grids: None
Mathematical Formula:
$$\text{User Input}$$ Python Logic:
N/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( \tau_{\text{op}} \) | Operational Torque (Nm) | 270,811.525412 |
View Help GuidePurpose: Reduced input force due to inefficiencies
Logic: Takes the raw input force, applies it to the gear radius lever arm, and strips out the friction penalties to give us the actual mechanical output torque.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$\tau_{\text{op}} = R_{\text{int}} \times F_{\text{in}} \times \eta_{\text{gear}} \times \eta_{\text{bearing}}$$ Python Logic:
=v["Internal Gear Radius (m)"]*v["Internal Gear Force in (N)"]*v["Gear efficiency (%)"]*v["Bearing efficiency friction factor (%)"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 2.0372*144,258.5965*0.9500*0.9700 = 270,811.5254
|
| ☰ | \( \eta_{\text{GMEG}} \) | GMEG Efficiency (%) |
View Help GuidePurpose: Control available kinetic energy with an internal load
Logic: A conservative safety net acting as an interal resistance. It prevents us from overestimating the final usable power we can extract from the machine while leaving enough head room to enable movement.
Type: Manual Entry
Render on Grids: None
Mathematical Formula:
$$\text{User Input}$$ Python Logic:
N/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( F_{\text{out}} \) | GMEG Force Out (N) | 118,098.829169 |
View Help GuidePurpose: Useful force to be transferred out
Logic: The net usable force that can be mathematically transferred into the next stage of the drivetrain (the outer gear).
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$F_{\text{out}} = F_{\text{in}} \times \eta_{\text{gear}} \times \eta_{\text{bearing}} \times \eta_{\text{GMEG}}$$ Python Logic:
v["Internal Gear Force in (N)"]*v["Gear efficiency (%)"]*v["Bearing efficiency friction factor (%)"]*v["GMEG Efficiency (%)"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 144,258.5965*0.9500*0.9700*0.8884 = 118,098.8292
|
| ☰ | \( \tau_{\text{out}} \) | GMEG Output Torque (Nm) | 240,588.959176 |
View Help GuidePurpose: Useful torque to be transferred out
Logic: This is the bottom-line performance metric of the GMEG module. It serves as the primary input "fuel" for the generator and flywheel calculations.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$\tau_{\text{out}} = \tau_{\text{op}} \times \eta_{\text{GMEG}}$$ Python Logic:
v["Operational Torque (Nm)"]*v["GMEG Efficiency (%)"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 270,811.5254*0.8884 = 240,588.9592
|
| ▼ Rotational Torque Output | ||||
| ☰ | \( Z_{\text{outer}} \) | Outer gear teeth |
View Help GuidePurpose: Setting the size of the first transfer gear
Logic: Needed to physically size the gear train that pulls rotational power out of the main GMEG loop and routes it toward the generator.
Type: Manual Entry
Render on Grids: None
Mathematical Formula:
$$\text{User Input}$$ Python Logic:
N/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( C_{\text{outer}} \) | Outer gear Circumference (m) | 12.800000 |
View Help GuidePurpose: Sizing of the gear for design
Logic: Sizes the outer gear for torque transfer
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$C_{\text{outer}} = C_{\text{int}}$$ Python Logic:
v["Internal Gear Circumference (m)"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 12.8000 = 12.8000
|
| ☰ | \( D_{\text{outer}} \) | Outer gear Diameter (m) | 4.074367 |
View Help GuidePurpose: Determining the height of the gear for design
Logic: Because this gear shares a shaft with the inner gear, they share the same rotational torque and RPM. This radius allows you to keep a 1:1 ratio or size it differently to scale the mechanical advantage and velocity for the next stage of the system.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$D_{\text{outer}} = D_{\text{int}}$$ Python Logic:
v["Internal Gear Diameter (m)"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 4.0744 = 4.0744
|
| ☰ | \( R_{\text{outer}} \) | Outer gear Radius (m) | 2.037183 |
View Help GuidePurpose: Determining radius of outer gear
Logic: Sets the baseline for the drivetrain. The tooth count dictates our gear ratios, deciding whether we are multiplying speed or multiplying torque.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$R_{\text{outer}} = R_{\text{int}}$$ Python Logic:
v["Internal Gear Radius (m)"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 2.0372 = 2.0372
|
| ☰ | \( n_{\text{outer, rps}} \) | Outer gear rotations per second | 0.650000 |
View Help GuidePurpose: Replicating GMEG speed
Logic: Its slaved to the main internal gear (1:1), meaning it spins at the exact same rate as the main drive. This confirms the baseline speed before we step it up.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$n_{\text{outer, rps}} = n_{\text{rps}}$$ Python Logic:
v["Internal Gear rotations per second"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 0.6500 = 0.6500
|
| ☰ | \( \omega_{\text{outer}} \) | Outer gear angular velocity radians per second | 4.084070 |
View Help GuidePurpose: Angular velocity of outer gear
Logic: Converts standard rotations into the strict mathematical units required to calculate kinetic energy and dynamic power.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$\omega_{\text{outer}} = n_{\text{outer, rps}} \times 2 \times \pi$$ Python Logic:
=v["Outer gear rotations per second"]*2*PI()Live Evaluation: [ROUTE: STATIC/GLOBAL] 0.6500*2*PI() = 4.0841
|
| ☰ | \( F_{\text{transfer}} \) | Outer Gear Force in (N) | 118,098.829169 |
View Help GuidePurpose: Reduced input force due to angle of track
Logic: Carries the raw pushing power generated by the running weights over to the transmission stage.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$F_{\text{transfer}} = F_{\text{out}}$$ Python Logic:
v["GMEG Force Out (N)"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 118,098.8292 = 118,098.8292
|
| ☰ | \( \tau_{\text{transfer}} \) | Outer Gear Torque in (Nm) | 240,588.959176 |
View Help GuidePurpose: Torque transfer
Logic: Carries the verified mechanical turning power (after internal friction losses) into the drivetrain.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$\tau_{\text{transfer}} = \tau_{\text{out}}$$ Python Logic:
v["GMEG Output Torque (Nm)"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 240,588.9592 = 240,588.9592
|
| ☰ | \( GR_{\text{transfer}} \) | Gear ratio | 1.000000 |
View Help GuidePurpose: Gear ratio between the outer and central gears
Logic: Determines how the system trades speed for torque. A ratio of 1 means no change, but the math is built to handle future tuning.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$GR_{\text{transfer}} = Z_{\text{outer}}/Z_{\text{int}}$$ Python Logic:
v["Outer gear teeth"]/v["Internal Gear teeth"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 128.0000/128.0000 = 1.0000
|
| ☰ | \( C_{\text{central}} \) | Central gear Circumference (m) | 12.800000 |
View Help GuidePurpose: Custom sizing of the gear for design
Logic: Physical sizing for the intermediary stage of the transmission.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$C_{\text{central}} = C_{\text{int}}$$ Python Logic:
v["Internal Gear Circumference (m)"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 12.8000 = 12.8000
|
| ☰ | \( D_{\text{central}} \) | Central gear Diameter (m) | 4.074367 |
View Help GuidePurpose: Determining the height of the gear for design
Logic: Used for spatial planning and clearance checks within the housing.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$D_{\text{central}} = D_{\text{int}}$$ Python Logic:
v["Internal Gear Diameter (m)"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 4.0744 = 4.0744
|
| ☰ | \( R_{\text{central}} \) | Central gear Radius (m) | 2.037183 |
View Help GuidePurpose: Determining radius of outer gear
Logic: Used to calculate how the torque shifts as it passes through this middle stage of the drivetrain.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$R_{\text{central}} = R_{\text{int}}$$ Python Logic:
v["Internal Gear Radius (m)"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 2.0372 = 2.0372
|
| ☰ | \( Z_{\text{central}} \) | Central gear teeth | 128.000000 |
View Help GuidePurpose: Relication of outer gear to ensure 1:1 torque transfer
Logic: Currently set to match the outer gear, creating a 1:1 ratio. This extends the physical reach of the drivetrain without altering the torque/speed curve yet.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$Z_{\text{central}} = Z_{\text{outer}}$$ Python Logic:
v["Outer gear teeth"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 128.0000 = 128.0000
|
| ☰ | \( n_{\text{central, rps}} \) | Central gear rotations per second | 0.650000 |
View Help GuidePurpose: Replicating GMEG speed
Logic: Confirms that the 1:1 transfer keeps the rotational speed identical to the main drive loop at this stage.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$n_{\text{central, rps}} = n_{\text{rps}}$$ Python Logic:
v["Internal Gear rotations per second"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 0.6500 = 0.6500
|
| ☰ | \( \omega_{\text{central}} \) | Central gear angular velocity radians per second | 4.084070 |
View Help GuidePurpose: Angular velocity of central gear
Logic: Keeps the math in strict physics units for downstream power calculations.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$\omega_{\text{central}} = \omega_{\text{int}}$$ Python Logic:
v["Internal Gear angular velocity radians per second"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 4.0841 = 4.0841
|
| ☰ | \( F_{\text{friction}} \) | Central Gear Force in (N) | 118,098.829169 |
View Help GuidePurpose: Reduced input force due to angle of track
Logic: Adjusts the pushing force based on the gear ratio. Even though it's 1:1 right now, this formula ensures the simulator adapts automatically if we change gear sizes later.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$F_{\text{friction}} = F_{\text{transfer}}$$ Python Logic:
v["Outer Gear Force in (N)"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 118,098.8292 = 118,098.8292
|
| ☰ | \( \tau_{\text{friction}} \) | Central Gear Torque in (Nm) | 240,588.959176 |
View Help GuidePurpose: Torque transfer
Logic: Adjusts the rotational power based on the gear ratio to track what is actually being delivered toward the final output stage.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$\tau_{\text{friction}} = \tau_{\text{transfer}}$$ Python Logic:
v["Outer Gear Torque in (Nm)"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 240,588.9592 = 240,588.9592
|
| ☰ | \( \eta_{\text{fric}} \) | Gear frictional efficiencies (%) |
View Help GuidePurpose: System inefficiencies
Logic: Engineering rigor. No gears are perfect. We have to assume some power is lost as heat and noise when metal teeth grind against each other.
Type: Manual Entry
Render on Grids: None
Mathematical Formula:
$$\text{User Input}$$ Python Logic:
N/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( F_{\text{useful}} \) | Central Gear Force Out (N) | 114,555.864294 |
View Help GuidePurpose: Reduced input force due to angle of track
Logic: What's actually left to push the generator after the mechanical penalties of the gear train.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$F_{\text{useful}} = F_{\text{friction}} \times \eta_{\text{fric}}$$ Python Logic:
v["Central Gear Force in (N)"]*v["Gear frictional efficiencies (%)"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 118,098.8292*0.9700 = 114,555.8643
|
| ☰ | \( \tau_{\text{useful}} \) | Torque in (Nm) | 233,371.290401 |
View Help GuidePurpose: Torque transfer
Logic: The true mechanical turning power available right before the final connection to the generator shaft.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$\tau_{\text{useful}} = \tau_{\text{friction}} \times \eta_{\text{fric}}$$ Python Logic:
v["Central Gear Torque in (Nm)"]*v["Gear frictional efficiencies (%)"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 240,588.9592*0.9700 = 233,371.2904
|
| ☰ | \( GR_{\text{gen}} \) | Central to Output Gear ratio | 32.000000 |
View Help GuidePurpose: Gear ratio between the outer and central gears
Logic: This is where the magic happens. We use this ratio to step up the speed (RPM) dramatically to feed the generator exactly what it needs to produce optimal electricity.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$GR_{\text{gen}} = Z_{\text{central}}/Z_{\text{output}}$$ Python Logic:
v["Central gear teeth"]/v["Output Gear teeth"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 128.0000/4.0000 = 32.0000
|
| ☰ | \( Z_{\text{output}} \) | Output Gear teeth |
View Help GuidePurpose: Size of connecting magnetic generator shaft
Logic: A much smaller gear here means it has to spin much faster to keep up with the big central gear. This is how we multiply our RPMs.
Type: Manual Entry
Render on Grids: None
Mathematical Formula:
$$\text{User Input}$$ Python Logic:
N/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( C_{\text{output}} \) | Output Gear Circumference (m) | 0.400000 |
View Help GuidePurpose: Size of connecting magnetic generator shaft
Logic: Physical design dimension for the generator hookup.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$C_{\text{output}} = Z_{\text{output}} \times L_{\text{link}}$$ Python Logic:
v["Output Gear teeth"]*v["Chain link (m)"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 4.0000*0.1000 = 0.4000
|
| ☰ | \( D_{\text{output}} \) | Output Gear Diameter (m) | 0.127324 |
View Help GuidePurpose: Size of connecting magnetic generator shaft
Logic: Space clearance mapping around the generator input shaft.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$D_{\text{output}} = C_{\text{output}}/\pi$$ Python Logic:
v["Output Gear Circumference (m)"]/PI()Live Evaluation: [ROUTE: STATIC/GLOBAL] 0.4000/PI() = 0.1273
|
| ☰ | \( R_{\text{output}} \) | Output Gear Radius (m) | 0.063662 |
View Help GuidePurpose: Size of connecting magnetic generator shaft
Logic: Used for the final calculation of how much twisting force (torque) is successfully injected into the generator.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$R_{\text{output}} = D_{\text{output}}/2$$ Python Logic:
v["Output Gear Diameter (m)"]/2Live Evaluation: [ROUTE: STATIC/GLOBAL] 0.1273/2 = 0.0637
|
| ☰ | \( Z_{\text{rate, central}} \) | Central gear teeth per second | 83.200000 |
View Help GuidePurpose: Number of teeth of central gear moved over 1 second
Logic: A stepping-stone calculation. We use the amount of teeth moving past per second to figure out exactly how fast the smaller output gear will be forced to spin.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$Z_{\text{rate, central}} = Z_{\text{central}} \times n_{\text{rps}}$$ Python Logic:
v["Central gear teeth"]*v["Internal Gear rotations per second"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 128.0000*0.6500 = 83.2000
|
| ☰ | \( n_{\text{gen, rps}} \) | Output gear rotations per second | 20.800000 |
View Help GuidePurpose: Magnetic generator revolutions per second
Logic: Uses the tooth-passing rate to calculate the final multiplied rotational speed of the generator.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$n_{\text{gen, rps}} = Z_{\text{rate, central}}/Z_{\text{output}}$$ Python Logic:
v["Central gear teeth per second"]/v["Output Gear teeth"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 83.2000/4.0000 = 20.8000
|
| ☰ | \( n_{\text{gen, rpm}} \) | Output gear (RPM) | 1,248.000000 |
View Help GuidePurpose: Magentic generator output speed
Logic: Generators are rated in RPM. This matches our mechanical output directly against standard commercial generator power curves.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$n_{\text{gen, rpm}} = n_{\text{gen, rps}} \times 60$$ Python Logic:
v["Output gear rotations per second"]*60Live Evaluation: [ROUTE: STATIC/GLOBAL] 20.8000*60 = 1,248.0000
|
| ☰ | \( \omega_{\text{gen}} \) | Output gear radians | 130.690254 |
View Help GuidePurpose: Output radians
Logic: Required to calculate the final electrical power output in kilowatts.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$\omega_{\text{gen}} = ((2 \times \pi) \times n_{\text{gen, rpm}})/60$$ Python Logic:
=((2*PI())*v["Output gear (RPM)"])/60Live Evaluation: [ROUTE: STATIC/GLOBAL] ((2*PI())*1,248.0000)/60 = 130.6903
|
| ☰ | \( t_{\text{op}} \) | Time (s) |
View Help GuidePurpose: Set time for machine operation
Logic: Used if we need to calculate total energy (Joules) generated over a set period, rather than just instantaneous power (Watts).
Type: Manual Entry
Render on Grids: None
Mathematical Formula:
$$\text{User Input}$$ Python Logic:
N/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( \tau_{\text{gen, gross}} \) | Output Torque (Nm) | 7,292.852825 |
View Help GuidePurpose: GMEG output torque into generator
Logic: Because we stepped up the speed dramatically, we sacrifice some torque. This calculates exactly what twisting power remains after the RPM multiplication.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$\tau_{\text{gen, gross}} = \tau_{\text{useful}}/GR_{\text{gen}}$$ Python Logic:
v["Torque in (Nm)"]/v["Central to Output Gear ratio"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 233,371.2904/32.0000 = 7,292.8528
|
| ☰ | \( \eta_{\text{gen}} \) | Generator efficiency (%) |
View Help GuidePurpose: System inefficiencies
Logic: No generator turns 100% of mechanical rotation into electricity. This penalty accounts for heat and electromagnetic losses inside the alternator itself.
Type: Manual Entry
Render on Grids: None
Mathematical Formula:
$$\text{User Input}$$ Python Logic:
N/ALive Evaluation: N/A (Input Variable)
|
|
| ☰ | \( \tau_{\text{gen, net}} \) | Final output torque (Nm) | 7,074.067240 |
View Help GuidePurpose: Final GMEG output torque into generator for power calculations
Logic: Strips away the generator's electrical inefficiencies so our final power calculation is totally honest and verified.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$\tau_{\text{gen, net}} = \tau_{\text{gen, gross}} \times \eta_{\text{gen}}$$ Python Logic:
v["Output Torque (Nm)"]*v["Generator efficiency (%)"]Live Evaluation: [ROUTE: STATIC/GLOBAL] 7,292.8528*0.9700 = 7,074.0672
|
| ☰ | \( P_{\text{out}} \) | Magnetic Generator Power Output (kW) | 924.511647 |
View Help GuidePurpose: GMEG Generator output
Logic: The bottom line. Combines the final torque and speed, divides by 1000, and gives us the usable electrical power sent to the grid or batteries.
Type: Calculated (Math Output)
Render on Grids: None
Mathematical Formula:
$$P_{\text{out}} = (\tau_{\text{gen, net}} \times \omega_{\text{gen}})/1000$$ Python Logic:
=(v["Final output torque (Nm)"]*v["Output gear radians"])/1000Live Evaluation: [ROUTE: STATIC/GLOBAL] (7,074.0672*130.6903)/1000 = 924.5116
|