133 lines
5.4 KiB
C++
133 lines
5.4 KiB
C++
#pragma once
|
|
|
|
#include "FluidSim/AudioProcessing.hpp"
|
|
#include "FluidSim/Atmosphere.hpp"
|
|
#include "FluidSim/Engine.hpp"
|
|
#include "FluidSim/Ecu.hpp"
|
|
#include "FluidSim/Fluid.hpp"
|
|
#include "FluidSim/MechanicalSoundProcessor.hpp"
|
|
#include "FluidSim/OutdoorAudio.hpp"
|
|
#include "FluidSim/Solver.hpp"
|
|
#include "FluidSim/Vehicle.hpp"
|
|
#include "FluidSim/MotorcycleTest.hpp"
|
|
#include "FluidSim/Turbocharger.hpp"
|
|
#include <memory>
|
|
#include <array>
|
|
#include <cstdint>
|
|
#include <mutex>
|
|
#include <vector>
|
|
|
|
namespace fluidsim::port {
|
|
|
|
enum class ScenarioKind { Twin, TwoStroke, SaabB205, TurboTwin, AmericanV8 };
|
|
enum class FourStrokePreset { Twin, SaabB205, AmericanV8 };
|
|
|
|
struct ScenarioSnapshot {
|
|
bool turbo_enabled{};
|
|
float boost_target{}, wastegate_duty{};
|
|
TurboSnapshot turbo{};
|
|
int cylinder_count{2};
|
|
float rev_limit_rpm{10000};
|
|
std::array<float, 8> cylinder_pressures{}, piston_fractions{}, intake_areas{}, exhaust_areas{};
|
|
std::uint64_t solver_substeps{}, boundary_iterations{};
|
|
float rpm{}, speed_kmh{}, kinetic_energy{}, average_power{}, average_torque{};
|
|
float cylinder_pressure1{}, cylinder_pressure2{};
|
|
float cylinder_temperature1{}, cylinder_temperature2{};
|
|
float cylinder_piston_fraction1{}, cylinder_piston_fraction2{};
|
|
float valve1_intake_area{}, valve1_exhaust_area{}, valve2_intake_area{}, valve2_exhaust_area{};
|
|
float intake_pressure{}, exhaust_pressure{};
|
|
float throttle{}, pedal{}, target_afr{}, clutch{}, intake_flow{}, exhaust_flow{};
|
|
bool idle_control{}, fuel_cut{}, two_stroke{}, reed_open{};
|
|
bool racing_exhaust{};
|
|
float crankcase_pressure{};
|
|
OutdoorScene audio_scene{OutdoorScene::Wall};
|
|
int gear{};
|
|
bool rev_limit1{}, rev_limit2{}, mechanical_sound_enabled{};
|
|
std::array<std::vector<GasState>, 22> pipe_states;
|
|
std::array<std::vector<float>, 22> pipe_areas, pipe_lengths;
|
|
void capture_pipes(const std::vector<Pipe1D>& pipes) {
|
|
for (std::size_t k = 0; k < pipes.size(); ++k) {
|
|
pipe_areas[k] = pipes[k].cell_areas;
|
|
pipe_lengths[k] = pipes[k].cell_lengths;
|
|
pipe_states[k].reserve(pipes[k].cells.size());
|
|
for (std::size_t i = 0; i < pipes[k].cells.size(); ++i)
|
|
pipe_states[k].push_back(pipes[k].state(static_cast<int>(i)));
|
|
}
|
|
}
|
|
};
|
|
|
|
// Shared four-stroke topology: independent runners/headers and shared plenums.
|
|
// Presets include a 600 cc twin, B205-sized inline-four and American 5.0 V8.
|
|
class FourStrokeScenario : public MotorcycleTest {
|
|
public:
|
|
explicit FourStrokeScenario(int sample_rate = 44100, FourStrokePreset preset = FourStrokePreset::Twin,
|
|
bool turbo_enabled = false);
|
|
const FourStrokePreset preset;
|
|
int cylinder_count() const { return preset == FourStrokePreset::AmericanV8 ? 8 : preset == FourStrokePreset::SaabB205 ? 4 : 2; }
|
|
std::array<FourStrokeCylinder*, 8> cylinders() { return {&cylinder1, &cylinder2, &cylinder3, &cylinder4,
|
|
&cylinder5, &cylinder6, &cylinder7, &cylinder8}; }
|
|
AudioFrame process();
|
|
void set_controls(float throttle_value, float load_value, float clutch_value);
|
|
void toggle_mechanical_sound();
|
|
void set_audio_scene(OutdoorScene scene);
|
|
void set_monitor_filter(bool enabled);
|
|
AudioFrame dry_audio() const;
|
|
AudioFrame unfiltered_audio() const;
|
|
void shift_up();
|
|
void shift_down();
|
|
void set_neutral();
|
|
void set_first_gear();
|
|
ScenarioSnapshot snapshot() const;
|
|
|
|
float throttle{};
|
|
bool mechanical_sound_enabled{};
|
|
float mechanical_mix{0.02f};
|
|
Ecu ecu{};
|
|
std::unique_ptr<Turbocharger> turbo;
|
|
Crankshaft crankshaft{};
|
|
FourStrokeCylinder cylinder1{}, cylinder2{}, cylinder3{}, cylinder4{};
|
|
FourStrokeCylinder cylinder5{}, cylinder6{}, cylinder7{}, cylinder8{};
|
|
Atmosphere intake_atmosphere{};
|
|
Volume0D intake_plenum{1.0e-3f, 101325.0f, 300.0f};
|
|
Volume0D exhaust_collector{0.15e-3f, 101325.0f, 700.0f};
|
|
Volume0D second_bank_collector{1.5e-3f, 101325.0f, 700.0f};
|
|
std::vector<Pipe1D> pipes;
|
|
float intake_flow{}, exhaust_flow{};
|
|
float last_mix_l{}, last_mix_r{};
|
|
std::uint64_t sample_count{};
|
|
|
|
private:
|
|
float intake_boundary_area_{}, throttle_area_{}, runner_area_{}, header_area_{}, tail_area_{};
|
|
std::array<float, 8> intake_valve_areas_{}, exhaust_valve_areas_{};
|
|
float dt_{};
|
|
BoundarySystem boundaries_;
|
|
Solver solver_;
|
|
OutdoorAudio audio_;
|
|
MechanicalSoundProcessor mechanical_sound_;
|
|
mutable std::mutex mutex_;
|
|
|
|
static float area_for_diameter(float diameter);
|
|
static std::vector<Pipe1D> create_pipes(FourStrokePreset preset, bool turbo_enabled);
|
|
};
|
|
|
|
using FourStrokeTwinScenario = FourStrokeScenario;
|
|
class AmericanV8Scenario : public FourStrokeScenario {
|
|
public:
|
|
explicit AmericanV8Scenario(int sample_rate = 44100)
|
|
: FourStrokeScenario(sample_rate, FourStrokePreset::AmericanV8) {}
|
|
};
|
|
class TurboTwinScenario : public FourStrokeScenario {
|
|
public:
|
|
explicit TurboTwinScenario(int sample_rate = 44100) : FourStrokeScenario(sample_rate, FourStrokePreset::Twin, true) {}
|
|
};
|
|
class SaabB205Scenario : public FourStrokeScenario {
|
|
public:
|
|
explicit SaabB205Scenario(int sample_rate = 44100) : FourStrokeScenario(sample_rate, FourStrokePreset::SaabB205) {}
|
|
};
|
|
class SaabTurboScenario : public FourStrokeScenario {
|
|
public:
|
|
explicit SaabTurboScenario(int sample_rate = 44100) : FourStrokeScenario(sample_rate, FourStrokePreset::SaabB205, true) {}
|
|
};
|
|
|
|
} // namespace fluidsim::port
|