359 lines
19 KiB
C++
359 lines
19 KiB
C++
#include "FluidSim/Scenario.hpp"
|
|
#include "FluidSim/Constants.hpp"
|
|
#include "FluidSim/ScenarioGeometry.hpp"
|
|
#include "FluidSim/ScenarioCatalog.hpp"
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <stdexcept>
|
|
|
|
namespace fluidsim::port {
|
|
FourStrokeScenario::FourStrokeScenario(int sample_rate, FourStrokePreset preset)
|
|
: FourStrokeScenario(sample_rate,preset_engine_definition(preset)) {}
|
|
|
|
FourStrokeScenario::FourStrokeScenario(int sample_rate,const ScenarioExample& definition)
|
|
: FourStrokeScenario(sample_rate,definition.engine,definition.exhaust,definition.junctions) {}
|
|
|
|
FourStrokeScenario::FourStrokeScenario(int sample_rate, EngineConfig configuration, ExhaustConfig exhaust, JunctionConfig fittings)
|
|
: exhaust_config(exhaust), junction_config(fittings), engine_config(resolve_engine_geometry(std::move(configuration),exhaust,fittings)),
|
|
intake_plenum(engine_config.plenum_volume,101325,300),
|
|
exhaust_collector(engine_config.collector_volume,101325,700),
|
|
pipes(create_pipes(engine_config,exhaust)), dt_(1.f/std::max(sample_rate,1)),
|
|
boundaries_(pipes), solver_(pipes,boundaries_), audio_(sample_rate,[&] {
|
|
OutdoorAudioConfig config;
|
|
config.dual_exhaust=engine_config.dual_outlets();
|
|
config.valve_contact_enabled=true;
|
|
return config;
|
|
}()) {
|
|
const auto& engine=engine_config;
|
|
geometry_=std::make_shared<PhysicalGeometry>(engine.geometry);
|
|
active_tuning_=std::make_shared<EngineConfig>(engine_config);
|
|
const auto& junctions=junction_config;
|
|
if(junctions.model!="volume" && junctions.model!="characteristic" && junctions.model!="legacy")
|
|
throw std::invalid_argument("invalid junction model");
|
|
const bool v8=engine.american_headers(),staged=engine.staged_headers();
|
|
const int count=cylinder_count();
|
|
static_cast<CrankshaftConfig&>(crankshaft)=engine.crankshaft;
|
|
static_cast<EcuConfig&>(ecu)=engine.ecu;
|
|
static_cast<VehicleConfig&>(vehicle)=engine.vehicle;
|
|
crankshaft.omega=engine.initial_rpm*2*pi/60;
|
|
starter_torque=engine.starter_torque;
|
|
solver_.minimum_substeps=engine.minimum_substeps;
|
|
if(engine.carbureted) {
|
|
carb_=std::make_unique<Carburetor>(engine.throttle_diameter);
|
|
static_cast<CarburetorConfig&>(*carb_)=engine.fuel;
|
|
// Carburetors keep metering fuel during both limiter and overrun cuts.
|
|
ecu.rev_limit_fuel_cut_enabled=false;
|
|
ecu.overrun_fuel_cut_enabled=false;
|
|
ecu.overrun_ignition_cut_enabled=true;
|
|
intake_plenum.add_fuel_mass(intake_plenum.mass()/14.7f);
|
|
}
|
|
vehicle.set_neutral();
|
|
vehicle.clutch_input = clutch;
|
|
const auto engines = cylinders();
|
|
for (int i=0;i<count;++i) {
|
|
auto& c=*engines[i];
|
|
static_cast<CylinderConfig&>(c)=engine.cylinder;
|
|
c.set_valve_profiles(active_tuning_->intake_cam,engine.intake_valve,active_tuning_->exhaust_cam,engine.exhaust_valve);
|
|
c.phase=engine.phase_degrees.at(i)*pi/180;
|
|
c.transported_fuel=engine.carbureted;
|
|
c.rev_limit_enabled = ecu.rev_limit_enabled;
|
|
c.rev_limit_rpm = ecu.rev_limit_rpm;
|
|
c.rev_limit_hysteresis = 250;
|
|
c.rev_limit_cut_time = .020f;
|
|
c.ecu = &ecu;
|
|
c.initialize(crankshaft);
|
|
if (engine.initialize_phased_charge) {
|
|
// Initialize each phased cylinder at its actual piston position.
|
|
c.volume = c.compute_volume(c.phase);
|
|
c.air_mass = ambient_density * c.volume;
|
|
c.energy = 101325 * c.volume / (gamma - 1);
|
|
if(engine.carbureted) {c.fuel_mass=c.air_mass/15.7f;c.air_mass-=c.fuel_mass;}
|
|
c.update_state(0);
|
|
}
|
|
}
|
|
runner_area_ = pipes[1].area;
|
|
header_area_ = pipes[1+count].area;
|
|
tail_area_ = pipes[1+2*count].area;
|
|
for (auto& pipe : pipes) {
|
|
pipe.damping_multiplier = engine.pipe_damping;
|
|
pipe.energy_relaxation_rate = 0;
|
|
}
|
|
auto& throttle_port = intake_plenum.create_port();
|
|
throttle_port_=&throttle_port;
|
|
solver_.add_component(intake_plenum);
|
|
if(!v8 && !staged && junctions.model=="volume") solver_.add_component(exhaust_collector);
|
|
boundaries_.add_orifice(throttle_port, 0, false, throttle_area_, .7f);
|
|
for (int i = 0; i < count; ++i) {
|
|
auto& feed = intake_plenum.create_port();
|
|
// 1--4 and 5--8 are separate physical banks for this firing order.
|
|
|
|
solver_.add_component(*engines[i]);
|
|
boundaries_.add_orifice(feed, 1+i, true, runner_area_);
|
|
boundaries_.add_orifice(engines[i]->intake, 1+i, false, intake_valve_areas_[i]);
|
|
boundaries_.add_orifice(engines[i]->exhaust, 1+count+i, true, exhaust_valve_areas_[i]);
|
|
if (!v8 && !staged && junctions.model=="volume") boundaries_.add_orifice(exhaust_collector.create_port(), 1+count+i, false, header_area_);
|
|
}
|
|
// Node axes follow the last/first route segment, unless explicitly supplied.
|
|
ScenarioSnapshot geometry;
|
|
geometry.geometry=geometry_;
|
|
geometry.cylinder_count=count;geometry.layout=engine.layout;geometry.bank_angle=engine.bank_angle;
|
|
geometry.v8_headers=v8;geometry.staged_headers=staged;geometry.dual_exhaust=engine.dual_outlets();
|
|
geometry.h_pipe=junctions.h_pipe;geometry.silencers=engine.has_silenced_exhaust() && exhaust.enabled;geometry.exhaust_config=exhaust;
|
|
const auto routes=scenario_pipe_routes(geometry);
|
|
std::vector<bool> branch_used(junctions.branches.size(),false);
|
|
int junction_index=0;
|
|
auto junction=[&](std::span<const JunctionEnd> ends) {
|
|
if(junctions.model=="volume") {
|
|
const auto* box=engine.geometry.volume("junction_"+std::to_string(junction_index));
|
|
if(!box)throw std::invalid_argument("geometry missing junction_"+std::to_string(junction_index));
|
|
auto fitting=std::make_unique<Junction>(box->volume(),101325,700);
|
|
fitting->connect(boundaries_,pipes,ends);
|
|
solver_.add_component(*fitting);exhaust_junctions_.push_back(std::move(fitting));
|
|
} else {
|
|
std::vector<BoundarySystem::JunctionFace> faces;
|
|
for(const auto& e:ends) {
|
|
const auto& route=routes.at(e.pipe);
|
|
if(route.count<2) throw std::invalid_argument("junction branch has no route direction");
|
|
const auto a=route.points[e.left?0:route.count-1], b=route.points[e.left?1:route.count-2];
|
|
std::array<float,3> direction{b.x-a.x,b.y-a.y,b.z-a.z};
|
|
for(std::size_t j=0;j<junctions.branches.size();++j) {
|
|
const auto& override=junctions.branches[j];
|
|
if(override.pipe==e.pipe && override.left==e.left) { direction=override.direction;branch_used[j]=true; }
|
|
}
|
|
faces.push_back({e.pipe,e.left,direction});
|
|
}
|
|
boundaries_.add_junction(faces,junctions.model=="legacy"?BoundarySystem::JunctionMethod::LegacyRusanov:BoundarySystem::JunctionMethod::Characteristic,junctions.turning_loss);
|
|
}
|
|
++junction_index;
|
|
};
|
|
auto join=[&](std::initializer_list<JunctionEnd> ends) { junction(std::span(ends.begin(),ends.size())); };
|
|
if(v8) {
|
|
// Within each bank pair cylinders with the widest available firing gaps.
|
|
join({{9,false},{10,false},{17,true}});
|
|
join({{11,false},{12,false},{18,true}});
|
|
join({{13,false},{15,false},{19,true}});
|
|
join({{14,false},{16,false},{20,true}});
|
|
join({{17,false},{18,false},{21,true}});
|
|
join({{19,false},{20,false},{22,true}});
|
|
if(junctions.h_pipe) {
|
|
join({{21,false},{23,true},{25,true}});
|
|
join({{22,false},{24,true},{25,false}});
|
|
} else {
|
|
boundaries_.add_connection(21,false,23,true);
|
|
boundaries_.add_connection(22,false,24,true);
|
|
boundaries_.add_closed_end(25,true);boundaries_.add_closed_end(25,false);
|
|
}
|
|
boundaries_.add_radiating_open_end(23,false,101325,pipes[23].area);
|
|
boundaries_.add_radiating_open_end(24,false,101325,pipes[24].area);
|
|
} else if(staged) {
|
|
const int exit=1+2*count;
|
|
const bool dual=engine.dual_outlets();
|
|
const int groups=engine.header_groups(), secondary=exit+(dual?2:1);
|
|
for(int group=0;group<groups;++group) {
|
|
std::vector<JunctionEnd> ends;
|
|
for(int i=0;i<count;++i)
|
|
if(groups==1 || (i<(count+1)/2?0:1)==group) ends.push_back({1+count+i,false});
|
|
ends.push_back({secondary+group,true});junction(ends);
|
|
}
|
|
if(dual) {
|
|
// Preserve independent bank pulse trains all the way to their mouths.
|
|
for(int bank=0;bank<2;++bank) {
|
|
join({{secondary+bank,false},{exit+bank,true}});
|
|
boundaries_.add_radiating_open_end(exit+bank,false,101325,pipes[exit+bank].area);
|
|
}
|
|
} else {
|
|
std::vector<JunctionEnd> ends{{exit,true}};
|
|
for(int group=0;group<groups;++group) ends.push_back({secondary+group,false});
|
|
junction(ends);
|
|
boundaries_.add_radiating_open_end(exit,false,101325,pipes[exit].area);
|
|
}
|
|
} else {
|
|
const int exit=1+2*count;
|
|
if(junctions.model=="volume") {
|
|
auto& collector_out = exhaust_collector.create_port();
|
|
boundaries_.add_orifice(collector_out,exit,true,tail_area_);
|
|
} else {
|
|
std::vector<JunctionEnd> ends{{exit,true}};
|
|
for(int i=0;i<count;++i) ends.push_back({1+count+i,false});
|
|
junction(ends);
|
|
}
|
|
boundaries_.add_radiating_open_end(exit,false,101325,pipes[exit].area);
|
|
}
|
|
for(std::size_t i=0;i<branch_used.size();++i)
|
|
if(junctions.model!="volume" && !branch_used[i]) throw std::invalid_argument("junction direction override does not name an active characteristic/legacy junction branch");
|
|
boundaries_.add_radiating_open_end(0, true, 101325, pipes[0].area);
|
|
solver_.set_profiler(&profiler_);
|
|
audio_.set_source_positions(scenario_sound_sources(snapshot()));
|
|
}
|
|
|
|
AudioFrame FourStrokeScenario::process() {
|
|
const std::lock_guard guard(mutex_);
|
|
const bool profile=profiler_.begin_step();
|
|
ProfileScope total(&profiler_,profile,ProfileStage::Total);
|
|
float contact_impulse=0;
|
|
{ ProfileScope controls(&profiler_,profile,ProfileStage::Controls);
|
|
step_motorcycle(crankshaft, dt_, engine_config.maximum_load_torque);
|
|
ecu.step(dt_, throttle, crankshaft.omega * 60 / (2*pi));
|
|
const auto engines = cylinders();
|
|
for (int i = 0; i < cylinder_count(); ++i) {
|
|
auto& c = *engines[i];
|
|
c.pre_step(crankshaft, dt_, throttle);
|
|
contact_impulse+=c.take_contact_impulse();
|
|
const float degrees = std::fmod((crankshaft.angle+c.phase)*180/pi, 720.f);
|
|
intake_valve_areas_[i] = c.valve_area(degrees, true);
|
|
exhaust_valve_areas_[i] = c.valve_area(degrees, false);
|
|
}
|
|
const float opening = ecu.throttle_opening();
|
|
const float angle = opening * pi * .5f;
|
|
throttle_area_ = area_for_diameter(engine_config.throttle_diameter) * (1-std::cos(angle));
|
|
if(carb_) {
|
|
const auto inlet=pipes[0].state(int(pipes[0].cells.size())-1);
|
|
carb_->step(dt_,throttle,opening,crankshaft.omega*60/(2*pi),std::max(throttle_port_->mass_flow,0.f),inlet.rho,inlet.pressure,intake_plenum.pressure());
|
|
intake_plenum.add_fuel_mass(carb_->fuel_flow()*dt_);
|
|
}
|
|
}
|
|
solver_.step(dt_,profile);
|
|
intake_flow = boundaries_.open_end_mass_flow(engine_config.dual_outlets() ? 2 : 1);
|
|
exhaust_flow = boundaries_.open_end_mass_flow(0);
|
|
const float other_exhaust = engine_config.dual_outlets() ? boundaries_.open_end_mass_flow(1) : 0.f;
|
|
// Compact mouth radiation responds to volume velocity. Use ambient-equivalent
|
|
// mass flow so hot/cold donor-density changes do not enter the derivative.
|
|
const float intake_source = ambient_density * boundaries_.open_end_volume_flow(engine_config.dual_outlets() ? 2 : 1);
|
|
const float exhaust_source = ambient_density * boundaries_.open_end_volume_flow(0);
|
|
const float other_source = engine_config.dual_outlets() ? ambient_density * boundaries_.open_end_volume_flow(1) : 0.f;
|
|
const auto& sound=active_tuning_->valve_sound;
|
|
const float mode_omega=2*pi*sound.mode_hz;
|
|
valve_sound_velocity_+=contact_impulse/sound.effective_mass_kg;
|
|
valve_sound_velocity_+=(-mode_omega*mode_omega*valve_sound_displacement_-2*sound.damping_ratio*mode_omega*valve_sound_velocity_)*dt_;
|
|
valve_sound_displacement_+=valve_sound_velocity_*dt_;
|
|
const float valve_contact_source=ambient_density*sound.radiation_area*valve_sound_velocity_;
|
|
ProfileScope audio_profile(&profiler_,profile,ProfileStage::Audio);
|
|
const auto rendered = audio_.process(intake_source, exhaust_source, other_source,valve_contact_source);
|
|
// Count sampled frames only after the complete process call has finished.
|
|
if(profile) profiler_.finish_step(total.elapsed_ns());
|
|
exhaust_flow += other_exhaust;
|
|
++sample_count;
|
|
const auto bin=std::clamp(int(std::fmod((crankshaft.angle+cylinder1.phase)*180/pi,720.f)/4),0,179);
|
|
intake_lift_trace_[bin]=cylinder1.intake_lift();exhaust_lift_trace_[bin]=cylinder1.exhaust_lift();
|
|
intake_lift_trace_[180]=intake_lift_trace_[0];exhaust_lift_trace_[180]=exhaust_lift_trace_[0];
|
|
last_contact_impulse_=contact_impulse;
|
|
return rendered;
|
|
}
|
|
|
|
void FourStrokeScenario::set_tuning(const EngineConfig& tuning) {
|
|
validate_engine_config(tuning,"live tuning");
|
|
// The live editor only changes calibration. Geometry is rebuilt separately.
|
|
const auto& a=tuning.cylinder;const auto& b=engine_config.cylinder;
|
|
if(tuning.geometry!=engine_config.geometry || tuning.cylinders!=engine_config.cylinders || tuning.layout!=engine_config.layout ||
|
|
tuning.topology!=engine_config.topology || tuning.phase_degrees!=engine_config.phase_degrees ||
|
|
tuning.carbureted!=engine_config.carbureted || tuning.throttle_diameter!=engine_config.throttle_diameter ||
|
|
a.bore!=b.bore || a.stroke!=b.stroke || a.rod!=b.rod || a.compression!=b.compression ||
|
|
tuning.cells_per_meter!=engine_config.cells_per_meter || tuning.pipes!=engine_config.pipes || tuning.plenum_volume!=engine_config.plenum_volume ||
|
|
tuning.collector_volume!=engine_config.collector_volume ||
|
|
a.intake_valve_count!=b.intake_valve_count || a.exhaust_valve_count!=b.exhaust_valve_count ||
|
|
a.intake_valve_diameter!=b.intake_valve_diameter || a.exhaust_valve_diameter!=b.exhaust_valve_diameter)
|
|
throw std::invalid_argument("Live tuning cannot change engine geometry; rebuild the engine instead");
|
|
auto next=std::make_shared<const EngineConfig>(tuning);
|
|
auto calibration=tuning.ecu;
|
|
// The scenario lock spans exactly one process() call. Copy/validation and
|
|
// retirement of the old profile happen on the editing thread outside it.
|
|
std::shared_ptr<const EngineConfig> retired;
|
|
{
|
|
const std::lock_guard guard(mutex_);
|
|
retired=std::move(active_tuning_);active_tuning_=std::move(next);
|
|
std::swap(static_cast<EcuConfig&>(ecu),calibration);
|
|
if(carb_) {
|
|
static_cast<CarburetorConfig&>(*carb_)=tuning.fuel;
|
|
ecu.rev_limit_fuel_cut_enabled=false;ecu.overrun_fuel_cut_enabled=false;ecu.overrun_ignition_cut_enabled=true;
|
|
}
|
|
const auto engines=cylinders();
|
|
for(int i=0;i<cylinder_count();++i)
|
|
engines[i]->set_valve_profiles(active_tuning_->intake_cam,tuning.intake_valve,active_tuning_->exhaust_cam,tuning.exhaust_valve);
|
|
}
|
|
}
|
|
|
|
void FourStrokeScenario::set_pipe_solver(PipeSolver solver) {
|
|
const std::lock_guard guard(mutex_);
|
|
for(auto& pipe : pipes) pipe.solver=solver;
|
|
}
|
|
|
|
void FourStrokeScenario::set_audio_scene(OutdoorScene scene) {
|
|
const std::lock_guard<std::mutex> guard(mutex_); audio_.set_scene(scene);
|
|
}
|
|
void FourStrokeScenario::set_listener(AudioListener listener) {
|
|
const std::lock_guard guard(mutex_); audio_.set_listener(listener);
|
|
}
|
|
void FourStrokeScenario::set_monitor_filter(bool enabled) {
|
|
const std::lock_guard<std::mutex> guard(mutex_); audio_.set_monitor_filter(enabled);
|
|
}
|
|
AudioFrame FourStrokeScenario::dry_audio() const {
|
|
const std::lock_guard<std::mutex> guard(mutex_); return audio_.dry_frame();
|
|
}
|
|
AudioFrame FourStrokeScenario::unfiltered_audio() const {
|
|
const std::lock_guard<std::mutex> guard(mutex_); return audio_.unfiltered_frame();
|
|
}
|
|
|
|
void FourStrokeScenario::set_starter(bool engaged) {
|
|
const std::lock_guard guard(mutex_);
|
|
starter_engaged=engaged;
|
|
}
|
|
|
|
void FourStrokeScenario::set_controls(float throttle_value, float load_value, float clutch_value) {
|
|
const std::lock_guard<std::mutex> guard(mutex_);
|
|
throttle = std::clamp(throttle_value, 0.0f, 1.0f);
|
|
load = std::clamp(load_value, 0.0f, 1.0f);
|
|
clutch = std::clamp(clutch_value, 0.0f, 1.0f);
|
|
}
|
|
|
|
void FourStrokeScenario::shift_up() {
|
|
const std::lock_guard<std::mutex> guard(mutex_);
|
|
vehicle.shift_up();
|
|
}
|
|
|
|
void FourStrokeScenario::shift_down() {
|
|
const std::lock_guard<std::mutex> guard(mutex_);
|
|
vehicle.shift_down();
|
|
}
|
|
|
|
void FourStrokeScenario::set_neutral() {
|
|
const std::lock_guard<std::mutex> guard(mutex_);
|
|
vehicle.set_neutral();
|
|
}
|
|
|
|
void FourStrokeScenario::set_first_gear() {
|
|
const std::lock_guard<std::mutex> guard(mutex_);
|
|
vehicle.set_first_gear();
|
|
}
|
|
|
|
float FourStrokeScenario::area_for_diameter(float diameter) {
|
|
return pi * diameter * diameter * 0.25f;
|
|
}
|
|
|
|
std::vector<Pipe1D> FourStrokeScenario::create_pipes(const EngineConfig& engine,const ExhaustConfig& exhaust) {
|
|
validate_engine_config(engine);
|
|
std::vector<Pipe1D> pipes;
|
|
auto mesh_exhaust=exhaust;
|
|
if(engine.cells_per_meter>0) mesh_exhaust.cell_length=1/engine.cells_per_meter;
|
|
std::size_t index=0;
|
|
for(const auto& pipe:engine.pipes)for(int i=0;i<pipe.count;++i) {
|
|
const float length=engine.geometry.pipes.at(index++).length();
|
|
if(pipe.silenced) {
|
|
auto layout=mesh_exhaust;
|
|
const float original=layout.inlet_length+layout.outlet_length+(layout.enabled?layout.connecting_length+layout.resonator.length+layout.muffler.length:0);
|
|
const float scale=length/original;
|
|
layout.inlet_length*=scale;layout.outlet_length*=scale;layout.connecting_length*=scale;
|
|
layout.resonator.length*=scale;layout.resonator.volume*=scale;layout.muffler.length*=scale;layout.muffler.volume*=scale;
|
|
auto profile=make_silenced_exhaust(layout);
|
|
if(profile.cells.size()>4096) throw std::invalid_argument("silencer mesh exceeds 4096 cells");
|
|
pipes.push_back(std::move(profile));
|
|
}
|
|
else pipes.emplace_back(area_for_diameter(pipe.diameter),length,engine.cells_per_meter>0?mesh_cell_count(length,engine.cells_per_meter):pipe.cells);
|
|
}
|
|
std::size_t total=0;for(const auto& pipe:pipes)total+=pipe.cells.size();
|
|
if(total>32768) throw std::invalid_argument("network mesh exceeds 32768 cells");
|
|
return pipes;
|
|
}
|
|
|
|
} // namespace fluidsim::port
|