Helmholtz testing (no decay bug)
This commit is contained in:
@@ -2,18 +2,15 @@ using FluidSim.Interfaces;
|
||||
|
||||
namespace FluidSim.Components
|
||||
{
|
||||
/// <summary>
|
||||
/// Represents the ambient atmosphere – constant pressure/temperature reservoir.
|
||||
/// </summary>
|
||||
public class Atmosphere : IComponent
|
||||
{
|
||||
public double Pressure { get; set; } = 101325.0;
|
||||
public double Temperature { get; set; } = 300.0;
|
||||
public double GasConstant { get; set; } = 287.0;
|
||||
public double Gamma => 1.4;
|
||||
public float Pressure { get; set; } = 101325f;
|
||||
public float Temperature { get; set; } = 300f;
|
||||
public float GasConstant { get; set; } = 287f;
|
||||
public float Gamma => 1.4f;
|
||||
|
||||
public double Density => Pressure / (GasConstant * Temperature);
|
||||
public double SpecificEnthalpy => Gamma / (Gamma - 1.0) * Pressure / Density;
|
||||
public float Density => Pressure / (GasConstant * Temperature);
|
||||
public float SpecificEnthalpy => Gamma / (Gamma - 1f) * Pressure / Density;
|
||||
|
||||
public Port Port { get; }
|
||||
|
||||
@@ -25,9 +22,8 @@ namespace FluidSim.Components
|
||||
|
||||
public IReadOnlyList<Port> Ports => new[] { Port };
|
||||
|
||||
public void UpdateState(double dt)
|
||||
public void UpdateState(float dt)
|
||||
{
|
||||
// Atmosphere is static – just ensure the port reflects current values
|
||||
UpdatePort();
|
||||
}
|
||||
|
||||
@@ -37,7 +33,7 @@ namespace FluidSim.Components
|
||||
Port.Density = Density;
|
||||
Port.Temperature = Temperature;
|
||||
Port.SpecificEnthalpy = SpecificEnthalpy;
|
||||
Port.AirFraction = 1.0;
|
||||
Port.AirFraction = 1f;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,54 +1,52 @@
|
||||
// Components/Crankshaft.cs
|
||||
using System;
|
||||
|
||||
namespace FluidSim.Components
|
||||
{
|
||||
public class Crankshaft
|
||||
{
|
||||
public double AngularVelocity { get; set; } // rad/s
|
||||
public double CrankAngle { get; set; } // rad, 0 … 4π (four‑stroke cycle)
|
||||
public double PreviousAngle { get; set; } // ← now has public setter
|
||||
public float AngularVelocity; // rad/s
|
||||
public float CrankAngle; // rad, 0 … 4π
|
||||
public float PreviousAngle;
|
||||
|
||||
public double Inertia { get; set; } = 0.2;
|
||||
public double FrictionConstant { get; set; } = 0.0; // N·m
|
||||
public double FrictionViscous { get; set; } = 0.000; // N·m per rad/s
|
||||
public float Inertia = 0.2f;
|
||||
public float FrictionConstant; // N·m
|
||||
public float FrictionViscous; // N·m per rad/s
|
||||
|
||||
private double externalTorque;
|
||||
private float externalTorque;
|
||||
|
||||
public Crankshaft(double initialRPM = 400.0)
|
||||
public Crankshaft(float initialRPM = 400f)
|
||||
{
|
||||
AngularVelocity = initialRPM * 2.0 * Math.PI / 60.0;
|
||||
CrankAngle = 0.0;
|
||||
PreviousAngle = 0.0;
|
||||
AngularVelocity = initialRPM * 2f * MathF.PI / 60f;
|
||||
CrankAngle = 0f;
|
||||
PreviousAngle = 0f;
|
||||
}
|
||||
|
||||
public void AddTorque(double torque) => externalTorque += torque;
|
||||
public void AddTorque(float torque) => externalTorque += torque;
|
||||
|
||||
public void Step(double dt)
|
||||
public void Step(float dt)
|
||||
{
|
||||
// Catch NaN before it propagates
|
||||
if (double.IsNaN(AngularVelocity) || double.IsInfinity(AngularVelocity))
|
||||
AngularVelocity = 0.0;
|
||||
if (double.IsNaN(externalTorque) || double.IsInfinity(externalTorque))
|
||||
externalTorque = 0.0;
|
||||
if (float.IsNaN(AngularVelocity) || float.IsInfinity(AngularVelocity))
|
||||
AngularVelocity = 0f;
|
||||
if (float.IsNaN(externalTorque) || float.IsInfinity(externalTorque))
|
||||
externalTorque = 0f;
|
||||
|
||||
PreviousAngle = CrankAngle;
|
||||
|
||||
double friction = FrictionConstant * Math.Sign(AngularVelocity) + FrictionViscous * AngularVelocity;
|
||||
double netTorque = externalTorque - friction;
|
||||
double alpha = netTorque / Inertia;
|
||||
float friction = FrictionConstant * MathF.Sign(AngularVelocity)
|
||||
+ FrictionViscous * AngularVelocity;
|
||||
float netTorque = externalTorque - friction;
|
||||
float alpha = netTorque / Inertia;
|
||||
AngularVelocity += alpha * dt;
|
||||
|
||||
if (AngularVelocity < 0) AngularVelocity = 0;
|
||||
if (AngularVelocity < 0f) AngularVelocity = 0f;
|
||||
|
||||
CrankAngle += AngularVelocity * dt;
|
||||
if (CrankAngle >= 4f * MathF.PI)
|
||||
CrankAngle -= 4f * MathF.PI;
|
||||
else if (CrankAngle < 0f)
|
||||
CrankAngle += 4f * MathF.PI;
|
||||
|
||||
if (CrankAngle >= 4.0 * Math.PI)
|
||||
CrankAngle -= 4.0 * Math.PI;
|
||||
else if (CrankAngle < 0)
|
||||
CrankAngle += 4.0 * Math.PI;
|
||||
|
||||
externalTorque = 0.0;
|
||||
externalTorque = 0f;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -13,144 +13,103 @@ namespace FluidSim.Components
|
||||
private readonly Port[] _ports;
|
||||
IReadOnlyList<Port> IComponent.Ports => _ports;
|
||||
|
||||
// Geometry
|
||||
public double Bore { get; }
|
||||
public double Stroke { get; }
|
||||
public double ConRodLength { get; }
|
||||
public double CompressionRatio { get; }
|
||||
public float Bore { get; }
|
||||
public float Stroke { get; }
|
||||
public float ConRodLength { get; }
|
||||
public float CompressionRatio { get; }
|
||||
|
||||
// Valve timings (degrees, 0 = TDC compression, 720° full cycle)
|
||||
public double IVO { get; }
|
||||
public double IVC { get; }
|
||||
public double EVO { get; }
|
||||
public double EVC { get; }
|
||||
public float IVO, IVC, EVO, EVC; // degrees
|
||||
public float IntakeValveDiameter = 0.03f;
|
||||
public float ExhaustValveDiameter = 0.028f;
|
||||
public float IntakeValveLift = 0.005f;
|
||||
public float ExhaustValveLift = 0.005f;
|
||||
|
||||
// Valve geometry
|
||||
public double IntakeValveDiameter { get; set; } = 0.030;
|
||||
public double ExhaustValveDiameter { get; set; } = 0.028;
|
||||
public double IntakeValveLift { get; set; } = 0.005;
|
||||
public double ExhaustValveLift { get; set; } = 0.005;
|
||||
public float IntakeValveMaxArea => MathF.PI * IntakeValveDiameter * IntakeValveLift;
|
||||
public float ExhaustValveMaxArea => MathF.PI * ExhaustValveDiameter * ExhaustValveLift;
|
||||
|
||||
public double IntakeValveMaxArea => Math.PI * IntakeValveDiameter * IntakeValveLift;
|
||||
public double ExhaustValveMaxArea => Math.PI * ExhaustValveDiameter * ExhaustValveLift;
|
||||
public float SparkAdvance = 20f;
|
||||
public float WiebeA = 5f, WiebeM = 2f, WiebeDuration = 60f, WiebeStart = 5f;
|
||||
public float StoichiometricAFR = 14.7f;
|
||||
public float FuelLowerHeatingValue = 44e6f;
|
||||
public float EnergyVariationFraction = 0.05f;
|
||||
public float MisfireProbability = 0.01f;
|
||||
public float CylinderWallArea = 0.02f;
|
||||
public float HeatTransferCoefficient = 100f;
|
||||
public float AmbientTemperature = 300f;
|
||||
|
||||
// Ignition and combustion
|
||||
public double SparkAdvance { get; set; } = 20.0;
|
||||
public double WiebeA { get; set; } = 5.0;
|
||||
public double WiebeM { get; set; } = 2.0;
|
||||
public double WiebeDuration { get; set; } = 60.0;
|
||||
public double WiebeStart { get; set; } = 5.0;
|
||||
public float PhaseOffset; // rad
|
||||
|
||||
// Fuel
|
||||
public double StoichiometricAFR { get; set; } = 14.7;
|
||||
public double FuelLowerHeatingValue { get; set; } = 44e6;
|
||||
public float Volume => cylinderVolume;
|
||||
public float Pressure => (Gamma - 1f) * cylinderEnergy / MathF.Max(cylinderVolume, 1e-12f);
|
||||
public float Temperature => Pressure / MathF.Max(Density * GasConstant, 1e-12f);
|
||||
public float Density => Mass / MathF.Max(cylinderVolume, 1e-12f);
|
||||
public float Mass => _airMass + _exhaustMass;
|
||||
public float AirFraction => _airMass / MathF.Max(Mass, 1e-12f);
|
||||
public float PistonFraction => (cylinderVolume - clearanceVolume) / SweptVolume;
|
||||
|
||||
// Cycle‑to‑cycle randomness
|
||||
public double EnergyVariationFraction { get; set; } = 0.05;
|
||||
public double MisfireProbability { get; set; } = 0.01;
|
||||
|
||||
// Heat loss
|
||||
public double CylinderWallArea { get; set; } = 0.02;
|
||||
public double HeatTransferCoefficient { get; set; } = 100.0;
|
||||
public double AmbientTemperature { get; set; } = 300.0;
|
||||
|
||||
// ---- Multi‑cylinder support ----
|
||||
/// <summary>
|
||||
/// Phase offset (radians) added to the crankshaft angle for this cylinder.
|
||||
/// Used for multi‑cylinder engines; set to 0 for single‑cylinder.
|
||||
/// </summary>
|
||||
public double PhaseOffset { get; set; } = 0.0;
|
||||
|
||||
// State (public for drawing)
|
||||
public double Volume => cylinderVolume;
|
||||
public double Pressure => (Gamma - 1.0) * cylinderEnergy / Math.Max(cylinderVolume, 1e-12);
|
||||
public double Temperature => Pressure / Math.Max(Density * GasConstant, 1e-12);
|
||||
public double Density => Mass / Math.Max(cylinderVolume, 1e-12);
|
||||
public double Mass => _airMass + _exhaustMass;
|
||||
public double AirFraction => _airMass / Math.Max(Mass, 1e-12);
|
||||
public double PistonFraction => (cylinderVolume - clearanceVolume) / SweptVolume;
|
||||
|
||||
private double cylinderVolume;
|
||||
private double cylinderEnergy;
|
||||
private double _airMass;
|
||||
private double _exhaustMass;
|
||||
private double trappedAirMass;
|
||||
private double fuelMass;
|
||||
private double burnFraction;
|
||||
private bool combustionActive;
|
||||
private bool fuelInjected;
|
||||
|
||||
private double _energyFactor = 1.0;
|
||||
private float cylinderVolume, cylinderEnergy;
|
||||
private float _airMass, _exhaustMass;
|
||||
private float trappedAirMass, fuelMass, burnFraction;
|
||||
private bool combustionActive, fuelInjected;
|
||||
private float _energyFactor = 1f;
|
||||
private readonly Random _random = new Random();
|
||||
|
||||
private const double Gamma = 1.4;
|
||||
private const double GasConstant = 287.0;
|
||||
private const float Gamma = 1.4f;
|
||||
private const float GasConstant = 287f;
|
||||
private const float MaxPressurePa = 200e5f;
|
||||
private const float MaxTemperatureK = 3500f;
|
||||
|
||||
private const double MaxPressurePa = 200e5;
|
||||
private const double MaxTemperatureK = 3500.0;
|
||||
|
||||
public Cylinder(double bore, double stroke, double conRodLength, double compressionRatio,
|
||||
double ivo, double ivc, double evo, double evc, Crankshaft crankshaft)
|
||||
public Cylinder(float bore, float stroke, float conRodLength, float compressionRatio,
|
||||
float ivo, float ivc, float evo, float evc, Crankshaft crankshaft)
|
||||
{
|
||||
Bore = bore;
|
||||
Stroke = stroke;
|
||||
ConRodLength = conRodLength;
|
||||
Bore = bore; Stroke = stroke; ConRodLength = conRodLength;
|
||||
CompressionRatio = compressionRatio;
|
||||
IVO = ivo;
|
||||
IVC = ivc;
|
||||
EVO = evo;
|
||||
EVC = evc;
|
||||
|
||||
IVO = ivo; IVC = ivc; EVO = evo; EVC = evc;
|
||||
Crankshaft = crankshaft ?? throw new ArgumentNullException(nameof(crankshaft));
|
||||
|
||||
cylinderVolume = clearanceVolume;
|
||||
double initRho = 1.225;
|
||||
float initRho = 1.225f;
|
||||
_airMass = initRho * clearanceVolume;
|
||||
_exhaustMass = 0.0;
|
||||
cylinderEnergy = 101325.0 * clearanceVolume / (Gamma - 1.0);
|
||||
_exhaustMass = 0f;
|
||||
cylinderEnergy = 101325f * clearanceVolume / (Gamma - 1f);
|
||||
|
||||
IntakePort = new Port { Owner = this };
|
||||
ExhaustPort = new Port { Owner = this };
|
||||
_ports = new[] { IntakePort, ExhaustPort };
|
||||
}
|
||||
|
||||
// Derived volumes
|
||||
private double SweptVolume => Math.PI * 0.25 * Bore * Bore * Stroke;
|
||||
private double clearanceVolume => SweptVolume / (CompressionRatio - 1.0);
|
||||
private double CrankRadius => Stroke / 2.0;
|
||||
private double Obliquity => CrankRadius / ConRodLength;
|
||||
private float SweptVolume => MathF.PI * 0.25f * Bore * Bore * Stroke;
|
||||
private float clearanceVolume => SweptVolume / (CompressionRatio - 1f);
|
||||
private float CrankRadius => Stroke * 0.5f;
|
||||
private float Obliquity => CrankRadius / ConRodLength;
|
||||
|
||||
// Offset-aware crank angle in degrees
|
||||
private double CrankDeg =>
|
||||
((Crankshaft.CrankAngle + PhaseOffset) % (4.0 * Math.PI)) * 180.0 / Math.PI % 720.0;
|
||||
private float CrankDeg =>
|
||||
((Crankshaft.CrankAngle + PhaseOffset) % (4f * MathF.PI)) * 180f / MathF.PI % 720f;
|
||||
|
||||
public double ComputeVolume(double thetaRad)
|
||||
public float ComputeVolume(float thetaRad)
|
||||
{
|
||||
double r = CrankRadius;
|
||||
double l = ConRodLength;
|
||||
double cosTh = Math.Cos(thetaRad);
|
||||
double sinTh = Math.Sin(thetaRad);
|
||||
double term = Math.Sqrt(1.0 - Obliquity * Obliquity * sinTh * sinTh);
|
||||
double x = r * (1.0 - cosTh) + l * (1.0 - term);
|
||||
double area = Math.PI * 0.25 * Bore * Bore;
|
||||
float r = CrankRadius, l = ConRodLength;
|
||||
float cosTh = MathF.Cos(thetaRad), sinTh = MathF.Sin(thetaRad);
|
||||
float term = MathF.Sqrt(1f - Obliquity * Obliquity * sinTh * sinTh);
|
||||
float x = r * (1f - cosTh) + l * (1f - term);
|
||||
float area = MathF.PI * 0.25f * Bore * Bore;
|
||||
return clearanceVolume + area * x;
|
||||
}
|
||||
|
||||
private double ValveLift(double thetaDeg, double opens, double closes, double peakLift)
|
||||
private float ValveLift(float thetaDeg, float opens, float closes, float peakLift)
|
||||
{
|
||||
double deg = thetaDeg % 720.0;
|
||||
if (deg < 0) deg += 720.0;
|
||||
float deg = thetaDeg % 720f;
|
||||
if (deg < 0f) deg += 720f;
|
||||
float duration = closes - opens;
|
||||
if (duration <= 0f) return 0f;
|
||||
|
||||
double duration = closes - opens;
|
||||
if (duration <= 0) return 0.0;
|
||||
|
||||
double rampDur = duration * 0.25;
|
||||
double holdDur = duration - 2.0 * rampDur;
|
||||
float rampDur = duration * 0.25f;
|
||||
float holdDur = duration - 2f * rampDur;
|
||||
|
||||
if (deg >= opens && deg < opens + rampDur)
|
||||
{
|
||||
double t = (deg - opens) / rampDur;
|
||||
return peakLift * t * t * (3.0 - 2.0 * t);
|
||||
float t = (deg - opens) / rampDur;
|
||||
return peakLift * t * t * (3f - 2f * t);
|
||||
}
|
||||
else if (deg >= opens + rampDur && deg < opens + rampDur + holdDur)
|
||||
{
|
||||
@@ -158,54 +117,45 @@ namespace FluidSim.Components
|
||||
}
|
||||
else if (deg >= opens + rampDur + holdDur && deg <= closes)
|
||||
{
|
||||
double t = (deg - (opens + rampDur + holdDur)) / rampDur;
|
||||
return peakLift * (1.0 - t) * (1.0 - t) * (1.0 + 2.0 * t);
|
||||
float t = (deg - (opens + rampDur + holdDur)) / rampDur;
|
||||
return peakLift * (1f - t) * (1f - t) * (1f + 2f * t);
|
||||
}
|
||||
return 0.0;
|
||||
return 0f;
|
||||
}
|
||||
|
||||
public double IntakeValveArea =>
|
||||
Math.PI * IntakeValveDiameter * ValveLift(CrankDeg, IVO, IVC, IntakeValveLift);
|
||||
public float IntakeValveArea =>
|
||||
MathF.PI * IntakeValveDiameter * ValveLift(CrankDeg, IVO, IVC, IntakeValveLift);
|
||||
public float ExhaustValveArea =>
|
||||
MathF.PI * ExhaustValveDiameter * ValveLift(CrankDeg, EVO, EVC, ExhaustValveLift);
|
||||
|
||||
public double ExhaustValveArea =>
|
||||
Math.PI * ExhaustValveDiameter * ValveLift(CrankDeg, EVO, EVC, ExhaustValveLift);
|
||||
|
||||
private double Wiebe(double angleSinceSpark)
|
||||
private float Wiebe(float angleSinceSpark)
|
||||
{
|
||||
if (angleSinceSpark < WiebeStart) return 0.0;
|
||||
double phi = (angleSinceSpark - WiebeStart) / WiebeDuration;
|
||||
if (phi <= 0) return 0.0;
|
||||
return 1.0 - Math.Exp(-WiebeA * Math.Pow(phi, WiebeM + 1));
|
||||
if (angleSinceSpark < WiebeStart) return 0f;
|
||||
float phi = (angleSinceSpark - WiebeStart) / WiebeDuration;
|
||||
if (phi <= 0f) return 0f;
|
||||
return 1f - MathF.Exp(-WiebeA * MathF.Pow(phi, WiebeM + 1f));
|
||||
}
|
||||
|
||||
public void PreStep(double dt)
|
||||
public void PreStep(float dt)
|
||||
{
|
||||
double prevVolume = cylinderVolume;
|
||||
|
||||
// ----- Use phase‑offset crank angle for this cylinder -----
|
||||
double crankAngleRad = Crankshaft.CrankAngle + PhaseOffset;
|
||||
float prevVolume = cylinderVolume;
|
||||
float crankAngleRad = Crankshaft.CrankAngle + PhaseOffset;
|
||||
cylinderVolume = ComputeVolume(crankAngleRad);
|
||||
|
||||
double dV = cylinderVolume - prevVolume;
|
||||
|
||||
// Piston torque
|
||||
double pRel = Pressure - 101325.0;
|
||||
double sinTh = Math.Sin(crankAngleRad);
|
||||
double cosTh = Math.Cos(crankAngleRad);
|
||||
double term = Math.Sqrt(1.0 - Obliquity * Obliquity * sinTh * sinTh);
|
||||
double dxdtheta = CrankRadius * sinTh * (1.0 + Obliquity * cosTh / term);
|
||||
double pistonArea = Math.PI * 0.25 * Bore * Bore;
|
||||
double torque = pRel * pistonArea * dxdtheta;
|
||||
Crankshaft.AddTorque(torque);
|
||||
float dV = cylinderVolume - prevVolume;
|
||||
float pRel = Pressure - 101325f;
|
||||
float sinTh = MathF.Sin(crankAngleRad), cosTh = MathF.Cos(crankAngleRad);
|
||||
float term = MathF.Sqrt(1f - Obliquity * Obliquity * sinTh * sinTh);
|
||||
float dxdtheta = CrankRadius * sinTh * (1f + Obliquity * cosTh / term);
|
||||
float pistonArea = MathF.PI * 0.25f * Bore * Bore;
|
||||
Crankshaft.AddTorque(pRel * pistonArea * dxdtheta);
|
||||
|
||||
cylinderEnergy -= Pressure * dV;
|
||||
|
||||
// Also use offset angle for event detection
|
||||
double crankshaftPrevAngle = Crankshaft.PreviousAngle;
|
||||
double prevDeg = (crankshaftPrevAngle + PhaseOffset) * 180.0 / Math.PI % 720.0;
|
||||
double currDeg = crankAngleRad * 180.0 / Math.PI % 720.0;
|
||||
float prevDeg = (Crankshaft.PreviousAngle + PhaseOffset) * 180f / MathF.PI % 720f;
|
||||
float currDeg = crankAngleRad * 180f / MathF.PI % 720f;
|
||||
|
||||
// ----- Intake closing: capture trapped air mass and compute fuel -----
|
||||
// Intake closing
|
||||
if (prevDeg >= IVO && prevDeg < IVC && currDeg >= IVC)
|
||||
{
|
||||
trappedAirMass = _airMass;
|
||||
@@ -213,122 +163,103 @@ namespace FluidSim.Components
|
||||
fuelInjected = true;
|
||||
}
|
||||
|
||||
// ----- Spark ignition -----
|
||||
double sparkAngle = 0.0 - SparkAdvance;
|
||||
if (sparkAngle < 0) sparkAngle += 720.0;
|
||||
|
||||
// Spark
|
||||
float sparkAngle = 0f - SparkAdvance;
|
||||
if (sparkAngle < 0f) sparkAngle += 720f;
|
||||
bool crossedSpark = (prevDeg < sparkAngle && currDeg >= sparkAngle) ||
|
||||
(prevDeg > sparkAngle + 360.0 && currDeg < sparkAngle);
|
||||
(prevDeg > sparkAngle + 360f && currDeg < sparkAngle);
|
||||
if (crossedSpark && !combustionActive && fuelInjected)
|
||||
{
|
||||
bool misfire = _random.NextDouble() < MisfireProbability;
|
||||
if (misfire)
|
||||
if (_random.NextDouble() < MisfireProbability)
|
||||
{
|
||||
combustionActive = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
combustionActive = true;
|
||||
burnFraction = 0.0;
|
||||
double range = EnergyVariationFraction;
|
||||
_energyFactor = 1.0 + range * (2.0 * _random.NextDouble() - 1.0);
|
||||
combustionActive = true; burnFraction = 0f;
|
||||
float range = EnergyVariationFraction;
|
||||
_energyFactor = 1f + range * (2f * (float)_random.NextDouble() - 1f);
|
||||
}
|
||||
}
|
||||
|
||||
// ----- Combustion progress -----
|
||||
// Combustion
|
||||
if (combustionActive)
|
||||
{
|
||||
double angleSinceSpark = currDeg - sparkAngle;
|
||||
if (angleSinceSpark < 0) angleSinceSpark += 720.0;
|
||||
double newFraction = Wiebe(angleSinceSpark);
|
||||
|
||||
if (newFraction >= 1.0 || angleSinceSpark > (WiebeDuration + WiebeStart + SparkAdvance))
|
||||
float angleSinceSpark = currDeg - sparkAngle;
|
||||
if (angleSinceSpark < 0f) angleSinceSpark += 720f;
|
||||
float newFraction = Wiebe(angleSinceSpark);
|
||||
if (newFraction >= 1f || angleSinceSpark > (WiebeDuration + WiebeStart + SparkAdvance))
|
||||
{
|
||||
newFraction = 1.0;
|
||||
combustionActive = false;
|
||||
double totalMass = _airMass + _exhaustMass;
|
||||
_airMass = 0.0;
|
||||
_exhaustMass = totalMass;
|
||||
newFraction = 1f; combustionActive = false;
|
||||
float totalMass = _airMass + _exhaustMass;
|
||||
_airMass = 0f; _exhaustMass = totalMass;
|
||||
}
|
||||
|
||||
double dFraction = newFraction - burnFraction;
|
||||
if (dFraction > 0)
|
||||
float dFraction = newFraction - burnFraction;
|
||||
if (dFraction > 0f)
|
||||
{
|
||||
double dQ = fuelMass * FuelLowerHeatingValue * _energyFactor * dFraction;
|
||||
float dQ = fuelMass * FuelLowerHeatingValue * _energyFactor * dFraction;
|
||||
cylinderEnergy += dQ;
|
||||
_exhaustMass += fuelMass * dFraction;
|
||||
burnFraction = newFraction;
|
||||
}
|
||||
}
|
||||
|
||||
// ----- Heat loss -----
|
||||
double dQ_loss = HeatTransferCoefficient * CylinderWallArea *
|
||||
(Temperature - AmbientTemperature) * dt;
|
||||
// Heat loss
|
||||
float dQ_loss = HeatTransferCoefficient * CylinderWallArea *
|
||||
(Temperature - AmbientTemperature) * dt;
|
||||
cylinderEnergy -= dQ_loss;
|
||||
|
||||
// Update port states
|
||||
double p = Pressure, rho = Density, T = Temperature;
|
||||
double h = Gamma / (Gamma - 1.0) * p / Math.Max(rho, 1e-12);
|
||||
double af = AirFraction;
|
||||
|
||||
IntakePort.Pressure = p;
|
||||
IntakePort.Density = rho;
|
||||
IntakePort.Temperature = T;
|
||||
IntakePort.SpecificEnthalpy = h;
|
||||
IntakePort.AirFraction = af;
|
||||
|
||||
ExhaustPort.Pressure = p;
|
||||
ExhaustPort.Density = rho;
|
||||
ExhaustPort.Temperature = T;
|
||||
ExhaustPort.SpecificEnthalpy = h;
|
||||
ExhaustPort.AirFraction = af;
|
||||
float p = Pressure, rho = Density, T = Temperature;
|
||||
float h = Gamma / (Gamma - 1f) * p / MathF.Max(rho, 1e-12f);
|
||||
float af = AirFraction;
|
||||
IntakePort.Pressure = p; IntakePort.Density = rho;
|
||||
IntakePort.Temperature = T; IntakePort.SpecificEnthalpy = h; IntakePort.AirFraction = af;
|
||||
ExhaustPort.Pressure = p; ExhaustPort.Density = rho;
|
||||
ExhaustPort.Temperature = T; ExhaustPort.SpecificEnthalpy = h; ExhaustPort.AirFraction = af;
|
||||
}
|
||||
|
||||
public void UpdateState(double dt)
|
||||
public void UpdateState(float dt)
|
||||
{
|
||||
double dmAir = 0.0, dmExhaust = 0.0, dE = 0.0;
|
||||
|
||||
float dmAir = 0f, dmExhaust = 0f, dE = 0f;
|
||||
foreach (var port in _ports)
|
||||
{
|
||||
double mdot = port.MassFlowRate;
|
||||
double af = mdot >= 0 ? port.AirFraction : AirFraction;
|
||||
float mdot = port.MassFlowRate;
|
||||
float af = mdot >= 0f ? port.AirFraction : AirFraction;
|
||||
dmAir += mdot * af * dt;
|
||||
dmExhaust += mdot * (1.0 - af) * dt;
|
||||
dmExhaust += mdot * (1f - af) * dt;
|
||||
dE += mdot * port.SpecificEnthalpy * dt;
|
||||
}
|
||||
|
||||
_airMass += dmAir;
|
||||
_exhaustMass += dmExhaust;
|
||||
_airMass += dmAir; _exhaustMass += dmExhaust;
|
||||
cylinderEnergy += dE;
|
||||
|
||||
double V = Math.Max(cylinderVolume, 1e-12);
|
||||
float V = MathF.Max(cylinderVolume, 1e-12f);
|
||||
float currentP = (Gamma - 1f) * cylinderEnergy / V;
|
||||
if (currentP > MaxPressurePa) cylinderEnergy = MaxPressurePa * V / (Gamma - 1f);
|
||||
|
||||
double currentP = (Gamma - 1.0) * cylinderEnergy / V;
|
||||
if (currentP > MaxPressurePa)
|
||||
cylinderEnergy = MaxPressurePa * V / (Gamma - 1.0);
|
||||
|
||||
double currentRho = (_airMass + _exhaustMass) / V;
|
||||
double currentT = currentP / Math.Max(currentRho * GasConstant, 1e-12);
|
||||
float currentRho = (_airMass + _exhaustMass) / V;
|
||||
float currentT = currentP / MathF.Max(currentRho * GasConstant, 1e-12f);
|
||||
if (currentT > MaxTemperatureK)
|
||||
{
|
||||
double pAtTlimit = currentRho * GasConstant * MaxTemperatureK;
|
||||
cylinderEnergy = pAtTlimit * V / (Gamma - 1.0);
|
||||
float pAtTlimit = currentRho * GasConstant * MaxTemperatureK;
|
||||
cylinderEnergy = pAtTlimit * V / (Gamma - 1f);
|
||||
}
|
||||
|
||||
double totalMass = _airMass + _exhaustMass;
|
||||
if (totalMass < 1e-9)
|
||||
float totalMass = _airMass + _exhaustMass;
|
||||
if (totalMass < 1e-9f)
|
||||
{
|
||||
_airMass = 1e-9;
|
||||
_exhaustMass = 0.0;
|
||||
cylinderEnergy = 101325.0 * V / (Gamma - 1.0);
|
||||
_airMass = 1e-9f; _exhaustMass = 0f;
|
||||
cylinderEnergy = 101325f * V / (Gamma - 1f);
|
||||
}
|
||||
else if (cylinderEnergy < 0.0)
|
||||
else if (cylinderEnergy < 0f)
|
||||
{
|
||||
cylinderEnergy = 101325.0 * V / (Gamma - 1.0);
|
||||
cylinderEnergy = 101325f * V / (Gamma - 1f);
|
||||
}
|
||||
|
||||
if (_airMass < 0.0) _airMass = 0.0;
|
||||
if (_exhaustMass < 0.0) _exhaustMass = 0.0;
|
||||
if (_airMass < 0f) _airMass = 0f;
|
||||
if (_exhaustMass < 0f) _exhaustMass = 0f;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,46 +0,0 @@
|
||||
using System;
|
||||
|
||||
namespace FluidSim.Components
|
||||
{
|
||||
public static class NozzleFlow
|
||||
{
|
||||
/// <summary>
|
||||
/// Computes the nozzle‑exit primitive state and mass flow rate from a
|
||||
/// volume to a pipe, using isentropic relations. Follows ensim4's flow() logic.
|
||||
/// </summary>
|
||||
public static void Compute(double Pt_high, double Tt_high,
|
||||
double P_low, double gamma, double R, double area,
|
||||
out double rhoExit, out double uExit,
|
||||
out double pExit, out double mdot)
|
||||
{
|
||||
double gm1 = gamma - 1.0;
|
||||
double Pt_over_Ps = Pt_high / P_low;
|
||||
|
||||
// Mach number (subsonic, clamped to 1)
|
||||
double M = Math.Sqrt(Math.Max(0.0,
|
||||
(2.0 / gm1) * (Math.Pow(Pt_over_Ps, gm1 / gamma) - 1.0)));
|
||||
if (M > 1.0) M = 1.0;
|
||||
|
||||
double T_star = Tt_high / (1.0 + 0.5 * gm1 * M * M);
|
||||
double a_star = Math.Sqrt(gamma * R * T_star);
|
||||
double u_star = M * a_star;
|
||||
pExit = Pt_high * Math.Pow(1.0 + 0.5 * gm1 * M * M, -gamma / gm1);
|
||||
rhoExit = pExit / (R * T_star);
|
||||
uExit = u_star; // positive away from high‑pressure side
|
||||
mdot = rhoExit * uExit * area;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Ambient cell for non‑reflecting open end (ensim4 calc_ambient_cell).
|
||||
/// </summary>
|
||||
public static void ComputeAmbientCell(double rhoInt, double uInt, double pInt,
|
||||
double pAmbient, double gamma,
|
||||
out double rhoAmb, out double uAmb,
|
||||
out double pAmb)
|
||||
{
|
||||
pAmb = pAmbient;
|
||||
uAmb = uInt;
|
||||
rhoAmb = rhoInt * Math.Pow(pAmb / pInt, 1.0 / gamma);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,451 +0,0 @@
|
||||
using System;
|
||||
using System.Diagnostics;
|
||||
using FluidSim.Interfaces;
|
||||
|
||||
namespace FluidSim.Components
|
||||
{
|
||||
/// <summary>
|
||||
/// 1‑D compressible Euler pipe with Lax‑Friedrichs finite‑volume scheme.
|
||||
/// Ghost states are set externally via SetGhostLeft/Right; they are always required.
|
||||
/// Now includes a passive scalar for air mass fraction.
|
||||
/// </summary>
|
||||
public class Pipe1D : IComponent
|
||||
{
|
||||
public const bool EnableDetailedProfiling = false; // set to false in release builds
|
||||
|
||||
public Port PortA { get; }
|
||||
public Port PortB { get; }
|
||||
public double Area { get; }
|
||||
public double DampingMultiplier { get; set; } = 10.0;
|
||||
public double EnergyRelaxationRate { get; set; } = 5.0; // 1/s
|
||||
public string Name = "Pipe";
|
||||
|
||||
private double _ambientPressure = 101325.0;
|
||||
public double AmbientPressure
|
||||
{
|
||||
get => _ambientPressure;
|
||||
set
|
||||
{
|
||||
_ambientPressure = value;
|
||||
_ambientEnergyReference = value / (_gamma - 1.0);
|
||||
}
|
||||
}
|
||||
|
||||
private readonly int _n;
|
||||
private readonly double _dx;
|
||||
private readonly double _diameter;
|
||||
private readonly double _gamma = 1.4;
|
||||
|
||||
private double[] _rho, _rhou, _E;
|
||||
private double[] _Y; // air mass fraction
|
||||
private double[] _fluxM, _fluxP, _fluxE;
|
||||
|
||||
private double _rhoGhostL, _uGhostL, _pGhostL, _YGhostL;
|
||||
private double _rhoGhostR, _uGhostR, _pGhostR, _YGhostR;
|
||||
private bool _ghostLValid, _ghostRValid;
|
||||
|
||||
private double _laminarCoeff;
|
||||
private double _ambientEnergyReference;
|
||||
|
||||
// ---------- Profiling accumulators ----------
|
||||
private long _profPrecomputeTicks;
|
||||
private long _profLeftFluxTicks;
|
||||
private long _profInteriorLoopTicks;
|
||||
private long _profRightFluxTicks;
|
||||
private long _profPortUpdateTicks;
|
||||
private long _profCallCount;
|
||||
|
||||
public Pipe1D(double length, double area, int cellCount)
|
||||
{
|
||||
if (cellCount < 4) throw new ArgumentException("cellCount must be at least 4");
|
||||
|
||||
_n = cellCount;
|
||||
_dx = length / _n;
|
||||
Area = area;
|
||||
_diameter = 2.0 * Math.Sqrt(area / Math.PI);
|
||||
|
||||
_rho = new double[_n];
|
||||
_rhou = new double[_n];
|
||||
_E = new double[_n];
|
||||
_Y = new double[_n];
|
||||
_fluxM = new double[_n + 1];
|
||||
_fluxP = new double[_n + 1];
|
||||
_fluxE = new double[_n + 1];
|
||||
|
||||
double mu_air = 1.8e-5;
|
||||
double radius = _diameter * 0.5;
|
||||
_laminarCoeff = 8.0 * mu_air / (radius * radius);
|
||||
|
||||
_ambientEnergyReference = 101325.0 / (_gamma - 1.0);
|
||||
|
||||
PortA = new Port { Owner = this };
|
||||
PortB = new Port { Owner = this };
|
||||
|
||||
SetUniformState(1.225, 0.0, 101325.0);
|
||||
}
|
||||
|
||||
IReadOnlyList<Port> IComponent.Ports => new[] { PortA, PortB };
|
||||
|
||||
public void UpdateState(double dt) { }
|
||||
|
||||
// ---------- Ghost interface ----------
|
||||
public void SetGhostLeft(double rho, double u, double p, double airFraction)
|
||||
{
|
||||
_rhoGhostL = rho; _uGhostL = u; _pGhostL = p; _YGhostL = airFraction; _ghostLValid = true;
|
||||
}
|
||||
public void SetGhostRight(double rho, double u, double p, double airFraction)
|
||||
{
|
||||
_rhoGhostR = rho; _uGhostR = u; _pGhostR = p; _YGhostR = airFraction; _ghostRValid = true;
|
||||
}
|
||||
public void ClearGhostFlags() { _ghostLValid = false; _ghostRValid = false; }
|
||||
|
||||
public double GetInteriorAirFractionLeft() => _Y[0];
|
||||
public double GetInteriorAirFractionRight() => _Y[_n - 1];
|
||||
|
||||
public (double rho, double u, double p) GetInteriorStateLeft()
|
||||
{
|
||||
double rho = Math.Max(_rho[0], 1e-12);
|
||||
double u = _rhou[0] / rho;
|
||||
double p = PressureScalar(0);
|
||||
return (rho, u, p);
|
||||
}
|
||||
public (double rho, double u, double p) GetInteriorStateRight()
|
||||
{
|
||||
double rho = Math.Max(_rho[_n - 1], 1e-12);
|
||||
double u = _rhou[_n - 1] / rho;
|
||||
double p = PressureScalar(_n - 1);
|
||||
return (rho, u, p);
|
||||
}
|
||||
public int CellCount => _n;
|
||||
public double GetCellDensity(int i) => _rho[i];
|
||||
public double GetCellVelocity(int i) => _rhou[i] / Math.Max(_rho[i], 1e-12);
|
||||
public double GetCellPressure(int i) => PressureScalar(i);
|
||||
|
||||
public int GetRequiredSubSteps(double dtGlobal, double cflTarget = 0.8)
|
||||
{
|
||||
double maxW = 0.0;
|
||||
for (int i = 0; i < _n; i++)
|
||||
{
|
||||
double rho = Math.Max(_rho[i], 1e-12);
|
||||
double u = Math.Abs(_rhou[i] / rho);
|
||||
double p = PressureScalar(i);
|
||||
double c = Math.Sqrt(_gamma * p / rho);
|
||||
double local = u + c;
|
||||
if (local > maxW) maxW = local;
|
||||
}
|
||||
maxW = Math.Max(maxW, 1e-8);
|
||||
return Math.Max(1, (int)Math.Ceiling(dtGlobal * maxW / (cflTarget * _dx)));
|
||||
}
|
||||
|
||||
// ---------- Main step (per sub‑step) ----------
|
||||
public void SimulateSingleStep(double dtSub)
|
||||
{
|
||||
if (!_ghostLValid || !_ghostRValid)
|
||||
throw new InvalidOperationException("Ghost cells not set before SimulateSingleStep.");
|
||||
|
||||
double dt = dtSub;
|
||||
int n = _n;
|
||||
double dt_dx = dt / _dx;
|
||||
double coeff = _laminarCoeff * DampingMultiplier;
|
||||
double relaxRate = EnergyRelaxationRate;
|
||||
double gamma = _gamma;
|
||||
double gm1 = gamma - 1.0;
|
||||
|
||||
// ---------- Profiling start ----------
|
||||
long t0 = 0, t1 = 0;
|
||||
if (EnableDetailedProfiling)
|
||||
{
|
||||
t0 = Stopwatch.GetTimestamp();
|
||||
_profCallCount++;
|
||||
}
|
||||
|
||||
// ---------- Phase 1: Pre‑compute pressure and speed of sound ----------
|
||||
double[] p = new double[n];
|
||||
double[] c = new double[n];
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
double rho = Math.Max(_rho[i], 1e-12);
|
||||
double u = _rhou[i] / rho;
|
||||
p[i] = gm1 * (_E[i] - 0.5 * _rhou[i] * _rhou[i] / rho);
|
||||
c[i] = Math.Sqrt(gamma * p[i] / rho);
|
||||
}
|
||||
|
||||
if (EnableDetailedProfiling)
|
||||
{
|
||||
t1 = Stopwatch.GetTimestamp();
|
||||
_profPrecomputeTicks += (t1 - t0);
|
||||
t0 = t1;
|
||||
}
|
||||
|
||||
// ---------- Local flux functions ----------
|
||||
void LaxFlux(double rL, double uL, double pL, double cL,
|
||||
double rR, double uR, double pR, double cR,
|
||||
out double fm, out double fp, out double fe)
|
||||
{
|
||||
double EL = pL / (gm1 * rL) + 0.5 * uL * uL;
|
||||
double ER = pR / (gm1 * rR) + 0.5 * uR * uR;
|
||||
double Fm_L = rL * uL;
|
||||
double Fp_L = rL * uL * uL + pL;
|
||||
double Fe_L = (rL * EL + pL) * uL;
|
||||
double Fm_R = rR * uR;
|
||||
double Fp_R = rR * uR * uR + pR;
|
||||
double Fe_R = (rR * ER + pR) * uR;
|
||||
double alpha = Math.Max(Math.Abs(uL) + cL, Math.Abs(uR) + cR);
|
||||
fm = 0.5 * (Fm_L + Fm_R) - 0.5 * alpha * (rR - rL);
|
||||
fp = 0.5 * (Fp_L + Fp_R) - 0.5 * alpha * (rR * uR - rL * uL);
|
||||
fe = 0.5 * (Fe_L + Fe_R) - 0.5 * alpha * (rR * ER - rL * EL);
|
||||
}
|
||||
|
||||
void ScalarFlux(double rL, double uL, double cL, double YL,
|
||||
double rR, double uR, double cR, double YR,
|
||||
double alpha, out double fy)
|
||||
{
|
||||
double Fm_L = rL * uL;
|
||||
double Fm_R = rR * uR;
|
||||
fy = 0.5 * (Fm_L * YL + Fm_R * YR) - 0.5 * alpha * (rR * YR - rL * YL);
|
||||
}
|
||||
|
||||
// ---------- Phase 2: Left face flux (ghostL – cell 0) ----------
|
||||
double rL_ghost = Math.Max(_rhoGhostL, 1e-12);
|
||||
double pL_ghost = _pGhostL;
|
||||
double uL_ghost = _uGhostL;
|
||||
double cL_ghost = Math.Sqrt(gamma * pL_ghost / rL_ghost);
|
||||
|
||||
LaxFlux(rL_ghost, uL_ghost, pL_ghost, cL_ghost,
|
||||
_rho[0], _rhou[0] / Math.Max(_rho[0], 1e-12), p[0], c[0],
|
||||
out double fluxM_left, out double fluxP_left, out double fluxE_left);
|
||||
|
||||
double alphaLeft = Math.Max(Math.Abs(uL_ghost) + cL_ghost,
|
||||
Math.Abs(_rhou[0] / Math.Max(_rho[0], 1e-12)) + c[0]);
|
||||
ScalarFlux(rL_ghost, uL_ghost, cL_ghost, _YGhostL,
|
||||
_rho[0], _rhou[0] / Math.Max(_rho[0], 1e-12), c[0], _Y[0],
|
||||
alphaLeft, out double fluxY_left);
|
||||
|
||||
if (EnableDetailedProfiling)
|
||||
{
|
||||
t1 = Stopwatch.GetTimestamp();
|
||||
_profLeftFluxTicks += (t1 - t0);
|
||||
t0 = t1;
|
||||
}
|
||||
|
||||
// ---------- Phase 3: Interior loop (fluxes + cell updates) ----------
|
||||
double fluxM_prev = fluxM_left;
|
||||
double fluxP_prev = fluxP_left;
|
||||
double fluxE_prev = fluxE_left;
|
||||
double fluxY_prev = fluxY_left;
|
||||
|
||||
for (int i = 0; i < n - 1; i++)
|
||||
{
|
||||
int iL = i;
|
||||
int iR = i + 1;
|
||||
|
||||
double rL = Math.Max(_rho[iL], 1e-12);
|
||||
double uL = _rhou[iL] / rL;
|
||||
double pL = p[iL];
|
||||
double cL = c[iL];
|
||||
double YL = _Y[iL];
|
||||
|
||||
double rR = Math.Max(_rho[iR], 1e-12);
|
||||
double uR = _rhou[iR] / rR;
|
||||
double pR = p[iR];
|
||||
double cR = c[iR];
|
||||
double YR = _Y[iR];
|
||||
|
||||
LaxFlux(rL, uL, pL, cL, rR, uR, pR, cR,
|
||||
out double fluxM_right, out double fluxP_right, out double fluxE_right);
|
||||
|
||||
double alpha = Math.Max(Math.Abs(uL) + cL, Math.Abs(uR) + cR);
|
||||
ScalarFlux(rL, uL, cL, YL, rR, uR, cR, YR, alpha, out double fluxY_right);
|
||||
|
||||
// Update cell i
|
||||
double r = _rho[i];
|
||||
double ru = _rhou[i];
|
||||
double E = _E[i];
|
||||
double Y = _Y[i];
|
||||
|
||||
double newR = r - dt_dx * (fluxM_right - fluxM_prev);
|
||||
double newRu = ru - dt_dx * (fluxP_right - fluxP_prev);
|
||||
double newE = E - dt_dx * (fluxE_right - fluxE_prev);
|
||||
double oldRhoY = r * Y;
|
||||
double newRhoY = oldRhoY - dt_dx * (fluxY_right - fluxY_prev);
|
||||
|
||||
double dampingFactor = Math.Exp(-coeff / Math.Max(r, 1e-12) * dt);
|
||||
newRu *= dampingFactor;
|
||||
double relaxFactor = Math.Exp(-relaxRate * dt);
|
||||
newE = _ambientEnergyReference + (newE - _ambientEnergyReference) * relaxFactor;
|
||||
|
||||
newR = Math.Max(newR, 1e-12);
|
||||
double kin = 0.5 * newRu * newRu / Math.Max(newR, 1e-12);
|
||||
double eMin = 100.0 / gm1 + kin;
|
||||
newE = Math.Max(newE, eMin);
|
||||
|
||||
_rho[i] = newR;
|
||||
_rhou[i] = newRu;
|
||||
_E[i] = newE;
|
||||
_Y[i] = Math.Clamp(newRhoY / newR, 0.0, 1.0);
|
||||
|
||||
fluxM_prev = fluxM_right;
|
||||
fluxP_prev = fluxP_right;
|
||||
fluxE_prev = fluxE_right;
|
||||
fluxY_prev = fluxY_right;
|
||||
}
|
||||
|
||||
if (EnableDetailedProfiling)
|
||||
{
|
||||
t1 = Stopwatch.GetTimestamp();
|
||||
_profInteriorLoopTicks += (t1 - t0);
|
||||
t0 = t1;
|
||||
}
|
||||
|
||||
// ---------- Phase 4: Right face flux (cell n‑1 – ghostR) ----------
|
||||
double rR_ghost = Math.Max(_rhoGhostR, 1e-12);
|
||||
double pR_ghost = _pGhostR;
|
||||
double uR_ghost = _uGhostR;
|
||||
double cR_ghost = Math.Sqrt(gamma * pR_ghost / rR_ghost);
|
||||
|
||||
double rInt = _rho[n - 1];
|
||||
double uInt = _rhou[n - 1] / Math.Max(rInt, 1e-12);
|
||||
|
||||
LaxFlux(rInt, uInt, p[n - 1], c[n - 1],
|
||||
rR_ghost, uR_ghost, pR_ghost, cR_ghost,
|
||||
out double fluxM_right_final, out double fluxP_right_final, out double fluxE_right_final);
|
||||
|
||||
double alphaRight = Math.Max(Math.Abs(uInt) + c[n - 1], Math.Abs(uR_ghost) + cR_ghost);
|
||||
ScalarFlux(rInt, uInt, c[n - 1], _Y[n - 1],
|
||||
rR_ghost, uR_ghost, cR_ghost, _YGhostR,
|
||||
alphaRight, out double fluxY_right_final);
|
||||
|
||||
// Update last cell
|
||||
{
|
||||
int i = n - 1;
|
||||
double r = _rho[i];
|
||||
double ru = _rhou[i];
|
||||
double E = _E[i];
|
||||
double Y = _Y[i];
|
||||
|
||||
double newR = r - dt_dx * (fluxM_right_final - fluxM_prev);
|
||||
double newRu = ru - dt_dx * (fluxP_right_final - fluxP_prev);
|
||||
double newE = E - dt_dx * (fluxE_right_final - fluxE_prev);
|
||||
double oldRhoY = r * Y;
|
||||
double newRhoY = oldRhoY - dt_dx * (fluxY_right_final - fluxY_prev);
|
||||
|
||||
double dampingFactor = Math.Exp(-coeff / Math.Max(r, 1e-12) * dt);
|
||||
newRu *= dampingFactor;
|
||||
double relaxFactor = Math.Exp(-relaxRate * dt);
|
||||
newE = _ambientEnergyReference + (newE - _ambientEnergyReference) * relaxFactor;
|
||||
|
||||
newR = Math.Max(newR, 1e-12);
|
||||
double kin = 0.5 * newRu * newRu / Math.Max(newR, 1e-12);
|
||||
double eMin = 100.0 / gm1 + kin;
|
||||
newE = Math.Max(newE, eMin);
|
||||
|
||||
_rho[i] = newR;
|
||||
_rhou[i] = newRu;
|
||||
_E[i] = newE;
|
||||
_Y[i] = Math.Clamp(newRhoY / newR, 0.0, 1.0);
|
||||
}
|
||||
|
||||
if (EnableDetailedProfiling)
|
||||
{
|
||||
t1 = Stopwatch.GetTimestamp();
|
||||
_profRightFluxTicks += (t1 - t0);
|
||||
t0 = t1;
|
||||
}
|
||||
|
||||
// ---------- Phase 5: Update port states ----------
|
||||
(double rhoA, double uA, double pA) = GetInteriorStateLeft();
|
||||
PortA.Pressure = pA; PortA.Density = rhoA;
|
||||
PortA.Temperature = pA / (rhoA * 287.0);
|
||||
PortA.SpecificEnthalpy = gm1 / (gamma - 1.0) * pA / rhoA;
|
||||
PortA.AirFraction = _Y[0];
|
||||
|
||||
(double rhoB, double uB, double pB) = GetInteriorStateRight();
|
||||
PortB.Pressure = pB; PortB.Density = rhoB;
|
||||
PortB.Temperature = pB / (rhoB * 287.0);
|
||||
PortB.SpecificEnthalpy = gm1 / (gamma - 1.0) * pB / rhoB;
|
||||
PortB.AirFraction = _Y[_n - 1];
|
||||
|
||||
if (EnableDetailedProfiling)
|
||||
{
|
||||
t1 = Stopwatch.GetTimestamp();
|
||||
_profPortUpdateTicks += (t1 - t0);
|
||||
}
|
||||
}
|
||||
|
||||
private double PressureScalar(int i)
|
||||
{
|
||||
double rho = Math.Max(_rho[i], 1e-12);
|
||||
return (_gamma - 1.0) * (_E[i] - 0.5 * _rhou[i] * _rhou[i] / rho);
|
||||
}
|
||||
|
||||
public void SetUniformState(double rho, double u, double p)
|
||||
{
|
||||
double e = p / ((_gamma - 1.0) * rho);
|
||||
double E = rho * e + 0.5 * rho * u * u;
|
||||
for (int i = 0; i < _n; i++)
|
||||
{
|
||||
_rho[i] = rho;
|
||||
_rhou[i] = rho * u;
|
||||
_E[i] = E;
|
||||
_Y[i] = 1.0; // initially pure air
|
||||
}
|
||||
}
|
||||
|
||||
public void SetCellState(int i, double rho, double u, double p)
|
||||
{
|
||||
if (i < 0 || i >= _n) return;
|
||||
double e = p / ((_gamma - 1.0) * rho);
|
||||
double E = rho * e + 0.5 * rho * u * u;
|
||||
_rho[i] = rho;
|
||||
_rhou[i] = rho * u;
|
||||
_E[i] = E;
|
||||
_Y[i] = 1.0;
|
||||
}
|
||||
|
||||
public void SetCellPressure(int i, double p)
|
||||
{
|
||||
if (i < 0 || i >= _n) return;
|
||||
double rho = _rho[i];
|
||||
double u = _rhou[i] / rho;
|
||||
double e = p / ((_gamma - 1.0) * rho);
|
||||
_E[i] = rho * e + 0.5 * rho * u * u;
|
||||
}
|
||||
|
||||
// ---------- Public profiling interface ----------
|
||||
public void ResetDetailCounters()
|
||||
{
|
||||
_profPrecomputeTicks = 0;
|
||||
_profLeftFluxTicks = 0;
|
||||
_profInteriorLoopTicks = 0;
|
||||
_profRightFluxTicks = 0;
|
||||
_profPortUpdateTicks = 0;
|
||||
_profCallCount = 0;
|
||||
}
|
||||
|
||||
public string GetDetailProfileReport()
|
||||
{
|
||||
if (!EnableDetailedProfiling)
|
||||
return "Detailed profiling disabled.";
|
||||
|
||||
double freq = Stopwatch.Frequency;
|
||||
long totalTicks = _profPrecomputeTicks + _profLeftFluxTicks +
|
||||
_profInteriorLoopTicks + _profRightFluxTicks +
|
||||
_profPortUpdateTicks;
|
||||
|
||||
if (totalTicks == 0) return "No profiling data.";
|
||||
|
||||
double totalSec = totalTicks / freq;
|
||||
double avgCallSec = totalSec / _profCallCount;
|
||||
double avgCallUs = avgCallSec * 1e6;
|
||||
|
||||
string report = $" Pipe detailed (over {_profCallCount} calls, total {totalSec * 1000:F2} ms):\n";
|
||||
report += $" Avg per call: {avgCallUs:F2} µs\n";
|
||||
report += $" Precompute p,c: {_profPrecomputeTicks * 100.0 / totalTicks:F1} % ({_profPrecomputeTicks / freq * 1e6 / _profCallCount:F2} µs/call)\n";
|
||||
report += $" Left face flux: {_profLeftFluxTicks * 100.0 / totalTicks:F1} % ({_profLeftFluxTicks / freq * 1e6 / _profCallCount:F2} µs/call)\n";
|
||||
report += $" Interior loop: {_profInteriorLoopTicks * 100.0 / totalTicks:F1} % ({_profInteriorLoopTicks / freq * 1e6 / _profCallCount:F2} µs/call)\n";
|
||||
report += $" Right face flux: {_profRightFluxTicks * 100.0 / totalTicks:F1} % ({_profRightFluxTicks / freq * 1e6 / _profCallCount:F2} µs/call)\n";
|
||||
report += $" Port update: {_profPortUpdateTicks * 100.0 / totalTicks:F1} % ({_profPortUpdateTicks / freq * 1e6 / _profCallCount:F2} µs/call)\n";
|
||||
return report;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -8,36 +8,40 @@ namespace FluidSim.Components
|
||||
{
|
||||
public List<Port> Ports { get; } = new List<Port>();
|
||||
|
||||
private double _airMass;
|
||||
private double _exhaustMass;
|
||||
public double InternalEnergy { get; set; }
|
||||
public double Volume { get; set; }
|
||||
public double Dvdt { get; set; }
|
||||
public double Gamma { get; set; } = 1.4;
|
||||
public double GasConstant { get; set; } = 287.0;
|
||||
private float _airMass;
|
||||
private float _exhaustMass;
|
||||
public float InternalEnergy;
|
||||
public float Volume;
|
||||
public float Dvdt;
|
||||
public float Gamma { get; set; } = 1.4f;
|
||||
public float GasConstant { get; set; } = 287f;
|
||||
public float AmbientPressure { get; set; } = 101325f;
|
||||
|
||||
public double AmbientPressure { get; set; } = 101325.0;
|
||||
// ---------- Thermal relaxation to environment ----------
|
||||
/// <summary>Rate of heat transfer to the surroundings (1/s). 0 = adiabatic.</summary>
|
||||
public float EnergyRelaxationRate { get; set; } = 10f;
|
||||
/// <summary>Temperature to relax toward (K). Default is room temperature.</summary>
|
||||
public float AmbientTemperature { get; set; } = 300f;
|
||||
|
||||
// Derived quantities
|
||||
public double Mass => _airMass + _exhaustMass;
|
||||
public double AirFraction => _airMass / Math.Max(Mass, 1e-12);
|
||||
public double Density => Mass / Math.Max(Volume, 1e-12);
|
||||
public double Pressure => (Gamma - 1.0) * InternalEnergy / Math.Max(Volume, 1e-12);
|
||||
public double Temperature => Pressure / Math.Max(Density * GasConstant, 1e-12);
|
||||
public double SpecificEnthalpy => Gamma / (Gamma - 1.0) * Pressure / Math.Max(Density, 1e-12);
|
||||
public float Mass => _airMass + _exhaustMass;
|
||||
public float AirFraction => _airMass / MathF.Max(Mass, 1e-12f);
|
||||
public float Density => Mass / MathF.Max(Volume, 1e-12f);
|
||||
public float Pressure => (Gamma - 1f) * InternalEnergy / MathF.Max(Volume, 1e-12f);
|
||||
public float Temperature => Pressure / MathF.Max(Density * GasConstant, 1e-12f);
|
||||
public float SpecificEnthalpy => Gamma / (Gamma - 1f) * Pressure / MathF.Max(Density, 1e-12f);
|
||||
|
||||
public Volume0D(double initialVolume, double initialPressure,
|
||||
double initialTemperature, double gasConstant = 287.0, double gamma = 1.4)
|
||||
public Volume0D(float initialVolume, float initialPressure,
|
||||
float initialTemperature, float gasConstant = 287f, float gamma = 1.4f)
|
||||
{
|
||||
GasConstant = gasConstant;
|
||||
Gamma = gamma;
|
||||
Volume = initialVolume;
|
||||
Dvdt = 0.0;
|
||||
Dvdt = 0f;
|
||||
|
||||
double rho0 = initialPressure / (GasConstant * initialTemperature);
|
||||
_airMass = rho0 * Volume; // starts with all air
|
||||
_exhaustMass = 0.0;
|
||||
InternalEnergy = (initialPressure * Volume) / (Gamma - 1.0);
|
||||
float rho0 = initialPressure / (GasConstant * initialTemperature);
|
||||
_airMass = rho0 * Volume;
|
||||
_exhaustMass = 0f;
|
||||
InternalEnergy = (initialPressure * Volume) / (Gamma - 1f);
|
||||
}
|
||||
|
||||
public Port CreatePort()
|
||||
@@ -52,66 +56,75 @@ namespace FluidSim.Components
|
||||
return port;
|
||||
}
|
||||
|
||||
public void SetPressure(double pressure, double? temperature = null)
|
||||
public void SetPressure(float pressure, float? temperature = null)
|
||||
{
|
||||
double V = Math.Max(Volume, 1e-12);
|
||||
double T = temperature ?? Temperature;
|
||||
double rho = pressure / (GasConstant * T);
|
||||
double totalMass = rho * V;
|
||||
// Keep current air fraction when setting pressure?
|
||||
double af = AirFraction;
|
||||
float V = MathF.Max(Volume, 1e-12f);
|
||||
float T = temperature ?? Temperature;
|
||||
float rho = pressure / (GasConstant * T);
|
||||
float totalMass = rho * V;
|
||||
float af = AirFraction;
|
||||
_airMass = totalMass * af;
|
||||
_exhaustMass = totalMass * (1.0 - af);
|
||||
InternalEnergy = pressure * V / (Gamma - 1.0);
|
||||
_exhaustMass = totalMass * (1f - af);
|
||||
InternalEnergy = pressure * V / (Gamma - 1f);
|
||||
}
|
||||
|
||||
public void UpdateState(double dt)
|
||||
public void UpdateState(float dt)
|
||||
{
|
||||
double totalMdotAir = 0.0;
|
||||
double totalMdotExhaust = 0.0;
|
||||
double totalEdot = 0.0;
|
||||
|
||||
float totalMdotAir = 0f, totalMdotExhaust = 0f, totalEdot = 0f;
|
||||
foreach (var port in Ports)
|
||||
{
|
||||
double mdot = port.MassFlowRate; // positive INTO volume
|
||||
double af = mdot >= 0 ? port.AirFraction : AirFraction; // inflow: use port's fraction; outflow: well-mixed
|
||||
float mdot = port.MassFlowRate;
|
||||
float af = mdot >= 0f ? port.AirFraction : AirFraction;
|
||||
totalMdotAir += mdot * af;
|
||||
totalMdotExhaust += mdot * (1.0 - af);
|
||||
totalMdotExhaust += mdot * (1f - af);
|
||||
totalEdot += mdot * port.SpecificEnthalpy;
|
||||
}
|
||||
|
||||
double dAir = totalMdotAir * dt;
|
||||
double dExhaust = totalMdotExhaust * dt;
|
||||
double dE = totalEdot * dt - Pressure * Dvdt * dt;
|
||||
float dAir = totalMdotAir * dt;
|
||||
float dExhaust = totalMdotExhaust * dt;
|
||||
float dE = totalEdot * dt - Pressure * Dvdt * dt;
|
||||
|
||||
_airMass += dAir;
|
||||
_exhaustMass += dExhaust;
|
||||
InternalEnergy += dE;
|
||||
|
||||
double V = Math.Max(Volume, 1e-12);
|
||||
double totalMass = _airMass + _exhaustMass;
|
||||
if (totalMass < 1e-9)
|
||||
// ---- Thermal relaxation ----
|
||||
if (EnergyRelaxationRate > 0f)
|
||||
{
|
||||
_airMass = 1e-9;
|
||||
_exhaustMass = 0.0;
|
||||
InternalEnergy = AmbientPressure * V / (Gamma - 1.0);
|
||||
}
|
||||
else if (InternalEnergy < 0.0)
|
||||
{
|
||||
InternalEnergy = AmbientPressure * V / (Gamma - 1.0);
|
||||
float currentMass = Mass;
|
||||
if (currentMass > 1e-12f)
|
||||
{
|
||||
// Target internal energy: current mass at ambient temperature
|
||||
float targetE = currentMass * GasConstant * AmbientTemperature / (Gamma - 1f);
|
||||
float relaxFactor = MathF.Exp(-EnergyRelaxationRate * dt);
|
||||
InternalEnergy = targetE + (InternalEnergy - targetE) * relaxFactor;
|
||||
}
|
||||
}
|
||||
|
||||
if (_airMass < 0.0) _airMass = 0.0;
|
||||
if (_exhaustMass < 0.0) _exhaustMass = 0.0;
|
||||
float V = MathF.Max(Volume, 1e-12f);
|
||||
float totalMass = _airMass + _exhaustMass;
|
||||
if (totalMass < 1e-9f)
|
||||
{
|
||||
_airMass = 1e-9f;
|
||||
_exhaustMass = 0f;
|
||||
InternalEnergy = AmbientPressure * V / (Gamma - 1f);
|
||||
}
|
||||
else if (InternalEnergy < 0f)
|
||||
{
|
||||
InternalEnergy = AmbientPressure * V / (Gamma - 1f);
|
||||
}
|
||||
|
||||
double p = Pressure, rho = Density, T = Temperature, h = SpecificEnthalpy, afrac = AirFraction;
|
||||
if (_airMass < 0f) _airMass = 0f;
|
||||
if (_exhaustMass < 0f) _exhaustMass = 0f;
|
||||
|
||||
float p = Pressure, rho = Density, T = Temperature, h = SpecificEnthalpy, afr = AirFraction;
|
||||
foreach (var port in Ports)
|
||||
{
|
||||
port.Pressure = p;
|
||||
port.Density = rho;
|
||||
port.Temperature = T;
|
||||
port.SpecificEnthalpy = h;
|
||||
port.AirFraction = afrac;
|
||||
port.AirFraction = afr;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user