320 lines
17 KiB
C++
320 lines
17 KiB
C++
#include "FluidSim/Scenario.hpp"
|
|
#include "FluidSim/SimulationRingBuffer.hpp"
|
|
#include <array>
|
|
#include "FluidSim/Atmosphere.hpp"
|
|
#include "FluidSim/Crankcase.hpp"
|
|
#include "FluidSim/DynoCurve.hpp"
|
|
#include "FluidSim/TwoStrokeCylinder.hpp"
|
|
#include "FluidSim/TwoStrokeScenario.hpp"
|
|
#include "FluidSim/OutdoorExhaustReverb.hpp"
|
|
#include "FluidSim/HelmholtzScenario.hpp"
|
|
#include "FluidSim/PulseTestScenario.hpp"
|
|
#include "FluidSim/Units.hpp"
|
|
#include "FluidSim/Desktop/PedalControl.hpp"
|
|
#include "FluidSim/Desktop/PipePath.hpp"
|
|
#include "FluidSim/Desktop/PressurePalette.hpp"
|
|
|
|
#include <cmath>
|
|
#include <iostream>
|
|
#include <stdexcept>
|
|
|
|
namespace {
|
|
void require(bool condition, const char* message) {
|
|
if (!condition) {
|
|
std::cerr << "FAIL: " << message << '\n';
|
|
throw std::runtime_error(message);
|
|
}
|
|
}
|
|
}
|
|
|
|
int main() {
|
|
using namespace fluidsim::port;
|
|
|
|
Ecu fixed_idle;
|
|
fixed_idle.idle_control=Ecu::IdleControl::FixedOpening;
|
|
fixed_idle.idle_base_opening=.049f;
|
|
fixed_idle.overrun_fuel_cut_enabled=false;
|
|
for(float rpm : {0.f,500.f,3000.f,9000.f}) {
|
|
for(int i=0;i<4410;++i) fixed_idle.step(1.f/44100,0,rpm);
|
|
require(std::abs(fixed_idle.throttle_opening()-.049f)<1e-5f,
|
|
"fixed carb idle must not vary with RPM");
|
|
}
|
|
for(int i=0;i<4410;++i) fixed_idle.step(1.f/44100,.2f,3000);
|
|
require(std::abs(fixed_idle.throttle_opening()-.2f)<1e-5f,"pedal must open above carb stop");
|
|
for(int i=0;i<4410;++i) fixed_idle.step(1.f/44100,.01f,3000);
|
|
require(std::abs(fixed_idle.throttle_opening()-.049f)<1e-5f,"release must return to carb stop");
|
|
for(auto preset : {FourStrokePreset::Twin,FourStrokePreset::SaabB205,FourStrokePreset::AmericanV8}) {
|
|
FourStrokeScenario starter(44100,preset);
|
|
starter.crankshaft.omega=0;
|
|
starter.set_starter(true);
|
|
starter.process();
|
|
require(starter.crankshaft.omega>0,"starter must turn every four-stroke crank from rest");
|
|
starter.set_starter(false);
|
|
require(!starter.starter_engaged,"starter release must disengage");
|
|
}
|
|
{
|
|
TwoStrokeConfig config; config.idle_slide_opening=.071f;
|
|
TwoStrokeScenario starter(44100,config);
|
|
require(starter.ecu.idle_base_opening==.071f,"scenario must configure carb idle stop");
|
|
starter.crankshaft.omega=0; starter.set_starter(true); starter.process();
|
|
require(starter.crankshaft.omega>0,"starter must turn two-stroke crank from rest");
|
|
starter.set_starter(false);
|
|
}
|
|
|
|
desktop::PedalControl pedal;
|
|
for(int i=0;i<100;++i)pedal.advance(.0025f,true,false);
|
|
require(std::abs(pedal.value()-.5f)<1e-5f,"W pedal travel must be halfway after 0.25 seconds");
|
|
for(int i=0;i<100;++i)pedal.advance(.0025f,true,false);
|
|
require(std::abs(pedal.value()-1)<1e-5f,"W must reach full pedal in 0.5 seconds");
|
|
for(int i=0;i<200;++i)pedal.advance(.0025f,false,false);
|
|
require(pedal.value()<1e-5f,"keyboard release must return pedal in 0.5 seconds");
|
|
pedal.set(.8f);
|
|
for(int i=0;i<200;++i)pedal.advance(.0025f,false,true);
|
|
require(pedal.value()==0,"S must release pedal");
|
|
desktop::PipePath path({{0,{0,0,0}},{.25f,{.2f,.1f,0}},{1,{1,0,.1f}}});
|
|
auto knot=path.position(.25f),direction=path.tangent(.25f);
|
|
require(std::abs(knot.x-.2f)<1e-6f && std::abs(knot.y-.1f)<1e-6f,"pipe path must interpolate its metre-referenced control point");
|
|
require(std::abs(direction.x*direction.x+direction.y*direction.y+direction.z*direction.z-1)<1e-4f,"pipe path tangent must be normalized");
|
|
auto atm=desktop::pressure_tint(101325),vac=desktop::pressure_tint(0),peak=desktop::pressure_tint(1000000);
|
|
require(atm.y>.8f && vac.z>.99f && peak.x>.99f,"pressure palette must show atmosphere green, vacuum blue, spikes red");
|
|
Ecu fast_actuator;
|
|
for(int i=0;i<230;++i)fast_actuator.step(1.f/44100,1,5000);
|
|
require(fast_actuator.throttle_opening()>.99f,"throttle actuator must settle within about 5 ms");
|
|
for(int i=0;i<230;++i)fast_actuator.step(1.f/44100,0,5000);
|
|
require(fast_actuator.throttle_opening()<.01f,"throttle actuator must close within about 5 ms");
|
|
Ecu idle_actuator;
|
|
for(int i=0;i<441;++i)idle_actuator.step(1.f/44100,0,1000);
|
|
require(idle_actuator.idle_active() && idle_actuator.throttle_opening()>0,"zero UI pedal must retain ECU idle authority");
|
|
|
|
Ecu controller;
|
|
controller.throttle_time_constant=.08f;controller.throttle_rate=2;
|
|
constexpr float ecu_dt = 1.0f / 44100.0f;
|
|
controller.step(ecu_dt, 1.0f, 2000.0f);
|
|
require(controller.throttle_opening() > 0.0f && controller.throttle_opening() <= 2.0f * ecu_dt,
|
|
"ECU throttle must obey its per-second travel limit");
|
|
for (int i = 0; i < 44100; ++i) controller.step(ecu_dt, 1.0f, 2000.0f);
|
|
require(controller.throttle_opening() > 0.99f && controller.target_afr() < 13.0f,
|
|
"ECU must reach full opening and enrich the high-load mixture");
|
|
const float before_close = controller.throttle_opening();
|
|
controller.step(ecu_dt, 0.0f, 2000.0f);
|
|
require(controller.throttle_opening() >= before_close - 2.01f * ecu_dt,
|
|
"ECU must also rate-limit throttle closing");
|
|
controller.step(ecu_dt, 1.0f, 10001.0f);
|
|
require(controller.fuel_cut() && controller.fuel_for_air(0.001f) == 0.0f,
|
|
"ECU rev limit must inhibit injection");
|
|
controller.step(ecu_dt, 1.0f, 9900.0f);
|
|
require(controller.rev_limited(), "ECU rev limiter must latch through hysteresis");
|
|
controller.rev_limit_enabled = false;
|
|
controller.step(ecu_dt, 1.0f, 15000.0f);
|
|
require(!controller.rev_limited() && !controller.fuel_cut() && controller.fuel_for_air(.001f) > 0,
|
|
"disabling a latched limiter must restore fuel above the old limit");
|
|
controller.rev_limit_enabled = true;
|
|
controller.step(ecu_dt, 1.0f, 9700.0f);
|
|
require(!controller.fuel_cut() && controller.fuel_for_air(0.001f) > 0.0f,
|
|
"ECU must resume injection below the rev recovery threshold");
|
|
controller.step(ecu_dt, 0.0f, 4000.0f);
|
|
require(controller.fuel_cut(), "closed-pedal overrun must cut injection");
|
|
controller.step(ecu_dt, 0.0f, 1300.0f);
|
|
require(!controller.fuel_cut() && controller.idle_active(), "idle catch must restore injection");
|
|
controller.step(ecu_dt, 0.0f, std::nanf(""));
|
|
require(controller.sensor_fault() && controller.fuel_cut(), "invalid sensor data must inhibit fuel");
|
|
|
|
// Unit-rate playback must preserve every sample across callback boundaries.
|
|
SimulationRingBuffer audio_ring(8);
|
|
for (int i = 0; i < 8; ++i) audio_ring.write(float(i), -float(i));
|
|
std::array<float, 4> left{}, right{};
|
|
require(audio_ring.read_interpolated(left, right, 1.0) == 4,
|
|
"unit-rate ring read must fill a block");
|
|
for (int i = 0; i < 4; ++i)
|
|
require(left[i] == float(i) && right[i] == -float(i), "ring must preserve stereo samples");
|
|
require(audio_ring.read_interpolated(left, right, 1.0) == 3,
|
|
"ring underrun must stop before unavailable interpolation lookahead");
|
|
for (int i = 8; i < 12; ++i) audio_ring.write(float(i), -float(i));
|
|
require(audio_ring.read_interpolated(left, right, 1.0) == 4 && left[0] == 7.0f && left[3] == 10.0f,
|
|
"ring must resume continuously after underrun and wraparound");
|
|
SoundProcessor linear_source(44100, 1.0f);
|
|
linear_source.process(0.0f);
|
|
const float response = linear_source.process(0.01f);
|
|
SoundProcessor doubled_source(44100, 1.0f);
|
|
doubled_source.process(0.0f);
|
|
require(std::abs(doubled_source.process(0.02f) - 2.0f * response) < 1e-5f,
|
|
"radiation source must remain linear instead of saturating");
|
|
|
|
|
|
require(std::abs(units::celsius(25.0) - 298.15) < 1e-9 &&
|
|
std::abs(units::area_from_diameter(0.02) - static_cast<double>(pi) * 1e-4) < 1e-12,
|
|
"unit helpers must preserve the C# conversions");
|
|
DynoCurve dyno_curve;
|
|
dyno_curve.update(1000.0f, 10.0f, 50.0f);
|
|
dyno_curve.update(1150.0f, 22.0f, 80.0f);
|
|
require(dyno_curve.bins().size() == 24 &&
|
|
std::abs(dyno_curve.bins()[21].power_kw - 14.0f) < 1e-5f &&
|
|
std::abs(dyno_curve.bins()[22].torque_nm - 70.0f) < 1e-5f,
|
|
"dyno history must interpolate skipped 50-RPM bins like the C# scenario base");
|
|
dyno_curve.update(1150.0f, 5.0f, 40.0f);
|
|
require(std::abs(dyno_curve.bins()[23].power_kw - 22.0f) < 1e-5f &&
|
|
std::abs(dyno_curve.bins()[23].torque_nm - 80.0f) < 1e-5f,
|
|
"dyno bins must retain their peak power and torque");
|
|
dyno_curve.reset();
|
|
require(dyno_curve.bins().empty(), "dyno reset must clear accumulated history");
|
|
Crankshaft crank;
|
|
FourStrokeCylinder cylinder;
|
|
cylinder.initialize(crank);
|
|
require(std::abs(cylinder.compute_volume(0.0f) - cylinder.clearance_volume()) < 1e-8f,
|
|
"cylinder volume at TDC must equal clearance volume");
|
|
require(std::abs(cylinder.compute_volume(pi) - cylinder.clearance_volume() - cylinder.swept_volume()) < 1e-8f,
|
|
"cylinder volume at BDC must include the swept volume");
|
|
|
|
TwoStrokeCylinder two_stroke{0.054f, 0.0545f, 0.110f, 7.2f, 140.0f, 195.0f};
|
|
two_stroke.initialize(crank);
|
|
two_stroke.intake_valve_diameter = 0.030f;
|
|
two_stroke.intake_valve_lift = 0.010f;
|
|
two_stroke.exhaust_valve_diameter = 0.040f;
|
|
two_stroke.exhaust_valve_lift = 0.010f;
|
|
require(two_stroke.valve_area(180.0f, true) > 0.0f &&
|
|
two_stroke.valve_area(0.0f, true) == 0.0f,
|
|
"two-stroke transfer port must open around BDC only");
|
|
require(two_stroke.valve_area(180.0f, false) > 0.0f &&
|
|
two_stroke.valve_area(0.0f, false) == 0.0f,
|
|
"two-stroke exhaust port must open around BDC only");
|
|
|
|
TwoStrokeScenario two_stroke_scenario;
|
|
two_stroke_scenario.set_throttle(0.25f);
|
|
for (int i = 0; i < 2000; ++i) two_stroke_scenario.process();
|
|
const auto two_stroke_state = two_stroke_scenario.snapshot();
|
|
require(std::isfinite(two_stroke_state.rpm) && std::isfinite(two_stroke_state.cylinder_pressure) &&
|
|
std::isfinite(two_stroke_state.crankcase_pressure) && std::isfinite(two_stroke_state.intake_pressure),
|
|
"two-stroke scenario must remain finite while running");
|
|
|
|
Crankcase crankcase{crank, 0.02725f, 0.110f, 0.054f, 150e-6f};
|
|
two_stroke.set_crankcase(crankcase);
|
|
crankcase.pre_step(1.0f / 44100.0f);
|
|
require(std::isfinite(crankcase.pressure()) && crankcase.pressure() > 0.0f &&
|
|
crankcase.volume() > 0.0f,
|
|
"crankcase must retain a finite thermodynamic state");
|
|
|
|
Atmosphere atmosphere;
|
|
require(std::abs(atmosphere.port.pressure - 101325.0f) < 1e-3f &&
|
|
std::abs(atmosphere.port.air_fraction - 1.0f) < 1e-6f,
|
|
"atmosphere must expose ambient air through its port");
|
|
|
|
OutdoorExhaustReverb reverb{44100};
|
|
bool reverb_tail = false;
|
|
for (int i = 0; i < 12000; ++i) {
|
|
const AudioFrame output = reverb.process_stereo(i == 0 ? 0.8f : 0.0f);
|
|
require(std::isfinite(output.left) && std::isfinite(output.right),
|
|
"outdoor reverb must remain finite after a transient");
|
|
if (i > 300 && (std::abs(output.left) > 1e-5f || std::abs(output.right) > 1e-5f)) reverb_tail = true;
|
|
}
|
|
require(reverb_tail, "outdoor reverb must produce a delayed reflection tail");
|
|
SoundProcessor flow_sound{44100, 1.0f};
|
|
for (int i = 0; i < 2000; ++i)
|
|
require(std::isfinite(flow_sound.process(i < 1000 ? 0.0f : 0.01f)),
|
|
"flow sound processor must remain finite for a flow step");
|
|
|
|
HelmholtzScenario helmholtz;
|
|
float resonator_peak = 0.0f;
|
|
for (int i = 0; i < 3000; ++i) {
|
|
const float sample = helmholtz.process();
|
|
require(std::isfinite(sample) && std::isfinite(helmholtz.cavity_pressure()),
|
|
"Helmholtz resonator must remain finite while discharging");
|
|
resonator_peak = std::max(resonator_peak, std::abs(sample));
|
|
}
|
|
require(resonator_peak > 0.0f, "overpressurized Helmholtz cavity must excite the neck");
|
|
|
|
PulseTestScenario pulse_test;
|
|
for (int i = 0; i < 3000; ++i) {
|
|
const float sample = pulse_test.process();
|
|
require(std::isfinite(sample) && std::isfinite(pulse_test.pipe().state(0).pressure),
|
|
"pulse test pipe must remain finite while the pressure pulse travels");
|
|
}
|
|
|
|
Volume0D chamber{1e-3f};
|
|
Port& chamber_port = chamber.create_port();
|
|
std::vector<Pipe1D> pipes;
|
|
pipes.emplace_back(1e-3f, 0.1f, 4);
|
|
BoundarySystem boundary{pipes};
|
|
float closed_area = 0.0f;
|
|
boundary.add_orifice(chamber_port, 0, false, closed_area);
|
|
const float initial_pressure = chamber.pressure();
|
|
boundary.resolve(1e-5f);
|
|
require(chamber_port.mass_flow == 0.0f, "closed orifice must have zero mass flow");
|
|
require(std::abs(chamber.pressure() - initial_pressure) < 1e-2f,
|
|
"resolving a closed orifice must not alter the chamber state");
|
|
|
|
Volume0D equal_pressure_volume{1e-3f};
|
|
Port& equal_pressure_port = equal_pressure_volume.create_port();
|
|
equal_pressure_port.density = 1.0f;
|
|
std::vector<Pipe1D> equal_pressure_pipes;
|
|
equal_pressure_pipes.emplace_back(1e-3f, 0.1f, 4);
|
|
BoundarySystem equal_pressure_boundary{equal_pressure_pipes};
|
|
float equal_pressure_area = 1e-4f;
|
|
equal_pressure_boundary.add_orifice(equal_pressure_port, 0, false, equal_pressure_area);
|
|
equal_pressure_boundary.resolve(1e-6f);
|
|
require(std::abs(equal_pressure_pipes.front().right_ghost.rho - equal_pressure_port.density) < 1e-6f,
|
|
"equal-pressure orifices must retain the volume-side density in the ghost state");
|
|
|
|
Volume0D configurable_volume{1e-3f, 150000.0f, 350.0f, 300.0f, 1.3f};
|
|
auto& configurable_port = configurable_volume.create_port();
|
|
require(std::abs(configurable_volume.temperature() - 350.0f) < 0.01f &&
|
|
std::abs(configurable_port.enthalpy - 1.3f / 0.3f * 300.0f * 350.0f) < 1.0f,
|
|
"0-D volumes must honor configurable gamma and gas constant");
|
|
configurable_volume.set_pressure(200000.0f, 400.0f);
|
|
require(std::abs(configurable_volume.pressure() - 200000.0f) < 0.1f &&
|
|
std::abs(configurable_volume.temperature() - 400.0f) < 1e-3f,
|
|
"setting volume pressure and temperature must update conserved mass and energy");
|
|
configurable_volume.energy_relaxation_rate = 0.0f;
|
|
configurable_volume.volume_change_rate = 0.01f;
|
|
const float before_volume_work = configurable_volume.pressure();
|
|
configurable_volume.update_state(1e-3f);
|
|
require(configurable_volume.pressure() < before_volume_work &&
|
|
std::abs(configurable_volume.pressure() - before_volume_work * std::pow(1.0f / 1.01f, 1.3f)) < 1.0f,
|
|
"moving-volume work must conserve the closed adiabatic p V^gamma invariant");
|
|
|
|
Pipe1D profiled_pipe{{0.001f, 0.002f, 0.003f}, {0.1f, 0.2f, 0.3f}};
|
|
require(std::abs(profiled_pipe.cell_mass(1) - 1.225f * 0.002f * 0.2f) < 1e-8f &&
|
|
std::abs(profiled_pipe.minimum_cell_length() - 0.1f) < 1e-8f,
|
|
"profiled pipes must retain each cell's area and length for mass/CFL calculations");
|
|
|
|
Vehicle bike;
|
|
bike.set_first_gear();
|
|
const float rpm = 10000.0f;
|
|
const float first_gear_speed = (rpm * 2.0f * pi / 60.0f) / bike.total_gear_ratio() * bike.wheel_radius * 3.6f;
|
|
require(first_gear_speed > 55.0f && first_gear_speed < 65.0f,
|
|
"first gear should be geared for about 60 km/h at the rev limit");
|
|
Vehicle neutral;
|
|
neutral.update(500.0f, 0.04f, 1e-3f);
|
|
require(neutral.speed == 0.0f, "neutral must isolate the driveline");
|
|
bike.clutch_input = 0.0f;
|
|
for (int i = 0; i < 2000; ++i) bike.update(500.0f, 0.04f, 1e-3f);
|
|
require(bike.speed > 0.0f && bike.kinetic_energy() > 0.0f,
|
|
"clutch impulse must transfer engine angular momentum into the vehicle");
|
|
|
|
FourStrokeTwinScenario scenario;
|
|
scenario.throttle = 0.35f;
|
|
for (int i = 0; i < 10000; ++i) scenario.process();
|
|
require(std::isfinite(scenario.crankshaft.omega) && scenario.crankshaft.omega > 0.0f,
|
|
"twin scenario must retain a finite running crank speed");
|
|
require(std::isfinite(scenario.intake_plenum.pressure()) && std::isfinite(scenario.exhaust_collector.pressure()),
|
|
"shared intake and exhaust volumes must remain finite");
|
|
require(scenario.cylinder1.pressure > 0.0f && scenario.cylinder2.pressure > 0.0f,
|
|
"both cylinders must retain positive pressure");
|
|
|
|
FourStrokeTwinScenario idling;
|
|
for (int i = 0; i < 6 * 44100; ++i) idling.process();
|
|
const auto idle_state = idling.snapshot();
|
|
require(idle_state.idle_control && idle_state.rpm > 1000.0f && idle_state.rpm < 3000.0f,
|
|
"ECU idle control must sustain the unloaded twin without artificial torque");
|
|
require(idle_state.throttle > 0.0f && idle_state.pedal == 0.0f,
|
|
"idle control must open the butterfly independently of the pedal");
|
|
|
|
for (int i = 0; i < 1000; ++i) {
|
|
const AudioFrame frame = scenario.process();
|
|
require(std::isfinite(frame.left) && std::isfinite(frame.right),
|
|
"the integrated fluid-derived audio path must remain finite");
|
|
}
|
|
|
|
std::cout << "FluidSim C++ physics tests passed\n";
|
|
return 0;
|
|
}
|