Hydraulic System Sizing

Hydraulic System Sizing (vehicle-design/sizing/hydraulic-system-sizing)

Use when the task is sizing the aircraft hydraulic power system from flight-control and utility actuation demand: converting each actuator demand into a flow from the piston area and rod speed, aggregating the worst-case simultaneous demand group, sizing the pump flow with leakage make-up and the pump drive power from system pressure, flow and efficiency, sizing the emergency accumulator gas volume from the adiabatic gas law between charged and depleted pressure given the usable volume, and sizing the reservoir from leakage make-up over a hold time with margin. This leaf implements the model in pure Python, stdlib only, in scripts/hydraulic_system_sizing_logic.py. It pairs with vehicle-design/sizing/control-surface-sizing and vehicle-design/sizing/spoiler-sizing as the demand side (the surfaces and their hinge moment loads that this leaf's pump feeds) and with vehicle-design/sizing/landing-gear-sizing as a utility actuation consumer.

Domain quick reference

• Actuator flow: Q_a = A_p * v_rod in m3/s (piston area times rod speed), with L/min = Q_a * 60000.
• Simultaneous demand: Q_sim = n_sim * Q_a, the worst case with n_sim of the identical actuators moving together.
• Pump flow: Q_pump = Q_sim + Q_leak (system leakage make-up, L/min); the pump volume rate is Q_pump / 60000 in m3/s.
• Pump power: P = p_pa * Q / eta, where p_pa = p_psi * 6894.757 Pa and eta is the pump total efficiency in (0, 1].
• Accumulator: the emergency accumulator gas follows p1 * V1^n = p2 * V2^n between charged pressure p1 and depleted pressure p2 with V2 - V1 = V_usable. Closed form: ratio = (p1/p2)^(1/n), V1 = V_usable / (ratio - 1), V2 = V1 + V_usable. The closure is evaluated in SI (p in Pa, V in m3); on the worked example both sides equal 2434.17.
• Reservoir volume: V_res = Q_leak * t_hold * margin, the leakage make-up volume over the hold time with the design margin.
• Units: pressures entered in psi and converted internally to Pa, flows in L/min and m3/s, volumes in L.
• FAR 25 frames the transport category hydraulic system context; the relations above are standard engineering methodology, summary-only.

Workflow

1. Fix the operating point: system pressure p_psi, the identical actuator group (piston area A_p, rod speed v_rod, n_actuators, n_simultaneous) and the system leakage.
2. Get the per-actuator flow with actuator_flow; doubling the piston area doubles the flow.
3. Aggregate the worst case with simultaneous_demand (n_sim * flow).
4. Size the pump with pump_flow: simultaneous demand plus leakage, which also returns the pump flow in m3/s. The simultaneity count cannot exceed the actuator count.
5. Size the pump drive with pump_power from the system pressure and the pump volume rate over the total efficiency.
6. Size the emergency accumulator with accumulator_volumes: charged and depleted pressures, the usable volume and the gas exponent n (nitrogen, 1.4 adiabatic); the p1 * V1^n = p2 * V2^n closure_check is returned for identity verification.
7. Size the reservoir with reservoir_volume from leakage, hold time and margin.
8. Run the whole chain in one call with hydraulic_system_summary for the complete sizing dict, then confirm the deterministic checks with the contract test scripts/test_hydraulic_system_sizing.py.

Worked example

Reference system: 3000 psi, six actuators of 0.0025 m2 piston area at 0.30 m/s rod speed, 4 simultaneous, leakage 15 L/min, pump efficiency 0.85, accumulator 1.0 L usable between 3000 and 1500 psi with n = 1.4, reservoir hold 2 minutes at 1.2 margin. Real module outputs:

• actuator_flow(0.0025, 0.30): flow_m3s = 0.00075, flow_lpm = 45.0.
• simultaneous_demand(45.0, 4): 180.0 L/min (all six: 270.0 L/min).
• pump_flow(45.0, 6, 4, 15.0): simultaneous_lpm = 180.0, pump_flow_lpm = 195.0, pump_flow_m3s = 0.00325.
• pump_power(3000.0, 0.00325, 0.85): pressure_pa = 20684271.0 (pressure_mpa = 20.6843), power_w = 79086.9 (79087 W), power_kw = 79.0869.
• accumulator_volumes(3000.0, 1500.0, 1.0, 1.4): ratio = 2^(1/1.4) = 1.64067, charged_gas_volume_l = 1.5609, depleted_gas_volume_l = 2.5609; the closure sides p1 * V1^n = p2 * V2^n both equal 2434.17 in SI units and closure_check = 4.5e-13 (match 0.0).
• reservoir_volume(15.0, 2.0, 1.2): 36.0 L.
• hydraulic_system_summary(0.0025, 0.30, 6, 4, 3000.0, 0.85, 3000.0, 1500.0, 1.0): all 13 keys above in one dict.

Pitfalls

• Aggregating more actuators than exist: the worst-case simultaneous demand is n_sim * Q_a with n_sim capped by the actuator count (4 of 6 in the worked example); n_simultaneous above n_actuators raises ValueError.
• Sizing the pump without the leakage make-up: pump flow is the simultaneous demand plus the system leakage (195.0 vs 180.0 L/min in the worked example), so a zero-leakage assumption under-sizes the pump unless the system really has no leakage.
• Reading the accumulator at the wrong pressure pair: the gas volumes come from p1 * V1^n = p2 * V2^n between the CHARGED and DEPLETED pressures with V2 - V1 = V_usable (1.5609 and 2.5609 L in the worked example); the closure check must match zero or the pressure pair is inconsistent.
• Forgetting the depleted pressure must stay below the charged: a depleted pressure at or above the charged pressure is rejected - there is no expansion left to drive the fluid.
• Mixing psi and Pa at the power step: pump_power converts the psi input internally (3000 psi = 20.68 MPa); the p * Q / eta product only holds in consistent SI.
• Dropping the simultaneity concept for a single average: the pump must cover the worst simultaneous group, not the average actuator demand, or the control surfaces starve in the worst case.

Verification

• Confirm actuator_flow(0.0025, 0.30) returns flow_lpm 45.0 and that doubling the area doubles the flow.
• Confirm pump_flow(45.0, 6, 4, 15.0) returns 195.0 L/min and that zero leakage returns the 180.0 L/min simultaneous demand.
• Confirm pump_power(3000.0, 0.00325, 0.85) returns power_kw 79.0869; efficiency 1.0 gives the p * Q product exactly and 0.5 doubles it.
• Confirm the accumulator closure identity p1 * V1^n = p2 * V2^n to 1e-9 relative on the worked case and on a second pair (for example 4000/2000 psi with 2 L usable), and that the depleted volume minus the charged volume equals the usable volume.
• Confirm every non-positive area, speed, flow, count, pressure, usable volume and margin below 1 raises ValueError, together with n_simultaneous above n_actuators, efficiency outside (0, 1] and depleted pressure at or above charged pressure.
• Run the contract test offline: python3 scripts/test_hydraulic_system_sizing.py (34 tests, deterministic).

Related leaves

• vehicle-design/sizing/control-surface-sizing: the demand side, the surface geometry and the hinge moment on the actuator this leaf's pump feeds.
• vehicle-design/sizing/environmental-control-sizing: sibling aircraft-subsystem sizing leaf in the same pack.
• vehicle-design/sizing/landing-gear-sizing: a utility actuation consumer drawing on the hydraulic power system.
• propulsion/turbomachinery/rocket-turbopump: the rocket pump boundary, out of scope for aircraft hydraulic pumps.

Behavior contract (gate 3)

Run the deterministic contract test (stdlib unittest, offline):

python3 scripts/test_hydraulic_system_sizing.py

The test covers the worked-example anchors (45.0 L/min actuator flow, 180 L/min simultaneous demand, 195 L/min pump flow at 0.00325 m3/s, 79.0869 kW at 20.6843 MPa over 0.85 efficiency, 1.5609 L charged and 2.5609 L depleted accumulator volumes, 36.0 L reservoir), the accumulator p1 * V1^n = p2 * V2^n closure identity to 1e-9 relative with the closure_check matching zero, depleted minus charged volume equaling the usable volume, the isothermal n = 1 case, dict key contracts, run-to-run determinism, and ValueError rejection of every non-physical input in the validation list.

Compliance

• Standards referenced, not reproduced: FAR 25 frames the hydraulic system installation and power requirements context; the sizing relations above are standard engineering methodology, summary-only per standards-map.yaml.
• compliance: STANDARDS-REF, gated: false.