Add project files.

2026-05-02 16:58:40 +02:00
parent edc3fd9b48
commit 9fc45224af
17 changed files with 915 additions and 0 deletions
--- a/Core/OrificeBoundary.cs
+++ b/Core/OrificeBoundary.cs
@@ -0,0 +1,95 @@
+using System;
+using FluidSim.Components;
+
+namespace FluidSim.Core
+{
+    public static class OrificeBoundary
+    {
+        public static double MassFlow(double pA, double rhoA, double pB, double rhoB,
+                                       Connection conn)
+        {
+            if (double.IsNaN(pA) || double.IsNaN(rhoA) || double.IsNaN(pB) || double.IsNaN(rhoB) ||
+                double.IsInfinity(pA) || double.IsInfinity(rhoA) || double.IsInfinity(pB) || double.IsInfinity(rhoB) ||
+                pA <= 0 || rhoA <= 0 || pB <= 0 || rhoB <= 0)
+                return 0.0;
+
+            double dp = pA - pB;
+            double sign = Math.Sign(dp);
+            double absDp = Math.Abs(dp);
+            double rhoUp = dp >= 0 ? rhoA : rhoB;
+            double pUp = dp >= 0 ? pA : pB;
+            double pDown = dp >= 0 ? pB : pA;
+            double delta = 1e-6 * pUp;
+
+            if (absDp < delta)
+            {
+                double k = conn.DischargeCoefficient * conn.Area * Math.Sqrt(2 * rhoUp / delta);
+                return k * dp;
+            }
+            else
+            {
+                double pr = pDown / pUp;
+                double choked = Math.Pow(2.0 / (conn.Gamma + 1.0), conn.Gamma / (conn.Gamma - 1.0));
+                if (pr < choked)
+                {
+                    double term = Math.Sqrt(conn.Gamma *
+                        Math.Pow(2.0 / (conn.Gamma + 1.0), (conn.Gamma + 1.0) / (conn.Gamma - 1.0)));
+                    double flow = conn.DischargeCoefficient * conn.Area *
+                                  Math.Sqrt(rhoUp * pUp) * term;
+                    return sign * flow;
+                }
+                else
+                {
+                    double ex = 1.0 - Math.Pow(pr, (conn.Gamma - 1.0) / conn.Gamma);
+                    double flow = conn.DischargeCoefficient * conn.Area *
+                        Math.Sqrt(2.0 * rhoUp * pUp * (conn.Gamma / (conn.Gamma - 1.0)) *
+                                  pr * pr * ex);
+                    return sign * flow;
+                }
+            }
+        }
+
+        public static void PipeVolumeFlux(double pPipe, double rhoPipe, double uPipe,
+                                          double pVol, double rhoVol, double uVol,
+                                          Connection conn, double pipeArea,
+                                          bool isLeftBoundary,
+                                          out double massFlux, out double momFlux, out double energyFlux)
+        {
+            // mass flow from pipe to volume (positive = pipe → volume)
+            double mdot = MassFlow(pPipe, rhoPipe, pVol, rhoVol, conn);
+
+            // Limit mass flow to the amount that can leave/enter the pipe cell
+            double maxMdot = rhoPipe * pipeArea * 343.0;
+            if (Math.Abs(mdot) > maxMdot) mdot = Math.Sign(mdot) * maxMdot;
+
+            bool flowLeavesPipe = mdot > 0;
+            double uFace, pFace, rhoFace;
+            double massFluxPerArea;
+
+            if (isLeftBoundary)
+            {
+                massFluxPerArea = -mdot / pipeArea;
+                if (flowLeavesPipe)
+                { uFace = uPipe; pFace = pPipe; rhoFace = rhoPipe; }
+                else
+                { uFace = uVol; pFace = pVol; rhoFace = rhoVol; }
+            }
+            else // right boundary
+            {
+                massFluxPerArea = mdot / pipeArea;
+                if (flowLeavesPipe)
+                { uFace = uPipe; pFace = pPipe; rhoFace = rhoPipe; }
+                else
+                { uFace = uVol; pFace = pVol; rhoFace = rhoVol; }
+            }
+
+            // Total enthalpy of the injected fluid (corrected: mass flux × total enthalpy)
+            double specificEnthalpy = (1.4 / (1.4 - 1.0)) * pFace / Math.Max(rhoFace, 1e-12);
+            double totalEnthalpy = specificEnthalpy + 0.5 * uFace * uFace;
+
+            massFlux = massFluxPerArea;
+            momFlux = massFluxPerArea * uFace + pFace;
+            energyFlux = massFluxPerArea * totalEnthalpy;
+        }
+    }
+}
--- a/Core/Simulation.cs
+++ b/Core/Simulation.cs
@@ -0,0 +1,86 @@
+using System;
+using FluidSim.Components;
+using FluidSim.Utils;
+
+namespace FluidSim.Core
+{
+    public static class Simulation
+    {
+        private static Pipe1D pipe;
+        private static Connection leftConn, rightConn;   // dummy connections for orifice params
+        private static double time;
+        private static double dt;
+        private static int stepCount;
+
+        public static void Initialize(int sampleRate)
+        {
+            dt = 1.0 / sampleRate;
+
+            double length = 150 * Units.mm;
+            double diameter = 25 * Units.mm;
+            double area = Units.AreaFromDiameter(25, Units.mm);
+            int nCells = 10;
+
+            pipe = new Pipe1D(length, area, nCells, sampleRate);
+            pipe.SetUniformState(1.2, 0.0, 1.0 * Units.atm);   // start at 1 atm
+            pipe.FrictionFactor = 0.02;
+
+            // Dummy connections – only used for orifice parameters
+            leftConn = new Connection(null, null) { Area = area, DischargeCoefficient = 1.0, Gamma = 1.4 };
+            rightConn = new Connection(null, null) { Area = area, DischargeCoefficient = 1.0, Gamma = 1.4 };
+        }
+
+        public static float Process()
+        {
+            // Fixed boundary reservoirs
+            double pLeft = 1.1 * Units.atm;
+            double rhoLeft = 1.2;
+            double uLeft = 0.0;
+
+            double pRight = 1.0 * Units.atm;
+            double rhoRight = 1.2;
+            double uRight = 0.0;
+
+            // Compute boundary fluxes via orifice model
+            OrificeBoundary.PipeVolumeFlux(
+                pipe.GetLeftPressure(), pipe.GetLeftDensity(), 0.0,
+                pLeft, rhoLeft, uLeft,
+                leftConn, pipe.Area, true,
+                out double leftMassFlux, out double leftMomFlux, out double leftEnergyFlux);
+
+            OrificeBoundary.PipeVolumeFlux(
+                pipe.GetRightPressure(), pipe.GetRightDensity(), 0.0,
+                pRight, rhoRight, uRight,
+                rightConn, pipe.Area, false,
+                out double rightMassFlux, out double rightMomFlux, out double rightEnergyFlux);
+
+            pipe.SetLeftBoundaryFlux(leftMassFlux, leftMomFlux, leftEnergyFlux);
+            pipe.SetRightBoundaryFlux(rightMassFlux, rightMomFlux, rightEnergyFlux);
+            pipe.Simulate();
+
+            time += dt;
+            stepCount++;
+            Log();
+            return 0f;
+        }
+
+        public static void Log()
+        {
+            if (stepCount <= 20 || stepCount % 50 == 0)
+            {
+                Console.WriteLine($"Step {stepCount:D4}  t = {time * 1e3:F3} ms");
+                for (int i = 0; i < pipe.GetCellCount(); i++)
+                {
+                    double rho = pipe.GetCellDensity(i);
+                    double p = pipe.GetCellPressure(i);
+                    double u = pipe.GetCellVelocity(i);
+                    Console.WriteLine($"  Cell {i}: ρ={rho:F4} kg/m³  p={p / 1e5:F6} bar  u={u:F3} m/s");
+                }
+                double leftFlow = pipe.PortA.MassFlowRate;
+                double rightFlow = pipe.PortB.MassFlowRate;
+                Console.WriteLine($"  Left flow = {leftFlow * 1e3:F4} g/s   Right flow = {rightFlow * 1e3:F4} g/s");
+                Console.WriteLine();
+            }
+        }
+    }
+}
--- a/Core/Solver.cs
+++ b/Core/Solver.cs
@@ -0,0 +1,94 @@
+using System.Collections.Generic;
+using FluidSim.Components;
+using FluidSim.Interfaces;
+
+namespace FluidSim.Core
+{
+    public class Solver
+    {
+        private readonly List<Volume0D> _volumes = new();
+        private readonly List<Pipe1D> _pipes = new();
+        private readonly List<Connection> _connections = new();
+
+        public void AddVolume(Volume0D v) => _volumes.Add(v);
+        public void AddPipe(Pipe1D p) => _pipes.Add(p);
+        public void AddConnection(Connection c) => _connections.Add(c);
+
+        public void Step()
+        {
+            // 1. Volumes publish state
+            foreach (var v in _volumes)
+                v.PushStateToPort();
+
+            // 2. Apply orifice boundaries to pipes
+            foreach (var conn in _connections)
+            {
+                if (IsPipePort(conn.PortA) && IsVolumePort(conn.PortB))
+                    ApplyOrifice(conn, conn.PortA, conn.PortB);
+                else if (IsVolumePort(conn.PortA) && IsPipePort(conn.PortB))
+                    ApplyOrifice(conn, conn.PortB, conn.PortA);
+                else if (IsVolumePort(conn.PortA) && IsVolumePort(conn.PortB))
+                    VolumeToVolume(conn);
+            }
+
+            // 3. Pipes simulate
+            foreach (var p in _pipes)
+                p.Simulate();
+
+            // 4. Transfer pipe flows to connected volumes
+            foreach (var conn in _connections)
+            {
+                if (IsPipePort(conn.PortA) && IsVolumePort(conn.PortB))
+                    Transfer(conn.PortA, conn.PortB);
+                else if (IsVolumePort(conn.PortA) && IsPipePort(conn.PortB))
+                    Transfer(conn.PortB, conn.PortA);
+            }
+
+            // 5. Volumes integrate
+            foreach (var v in _volumes)
+                v.Integrate();
+        }
+
+        bool IsVolumePort(Port p) => _volumes.Exists(v => v.Port == p);
+        bool IsPipePort(Port p) => _pipes.Exists(pp => pp.PortA == p || pp.PortB == p);
+        Pipe1D GetPipe(Port p) => _pipes.Find(pp => pp.PortA == p || pp.PortB == p);
+
+        void ApplyOrifice(Connection conn, Port pipePort, Port volPort)
+        {
+            Pipe1D pipe = GetPipe(pipePort);
+            if (pipe == null) return;
+            bool isLeft = pipe.PortA == pipePort;
+
+            double pP = isLeft ? pipe.GetLeftPressure() : pipe.GetRightPressure();
+            double rhoP = isLeft ? pipe.GetLeftDensity() : pipe.GetRightDensity();
+            double uP = 0.0;
+            double pV = volPort.Pressure, rhoV = volPort.Density, uV = 0.0;
+
+            OrificeBoundary.PipeVolumeFlux(pP, rhoP, uP, pV, rhoV, uV, conn, pipe.Area,
+                isLeft, out double mf, out double pf, out double ef);
+            if (isLeft)
+                pipe.SetLeftBoundaryFlux(mf, pf, ef);
+            else
+                pipe.SetRightBoundaryFlux(mf, pf, ef);
+        }
+
+        void VolumeToVolume(Connection conn)
+        {
+            double mdot = OrificeBoundary.MassFlow(conn.PortA.Pressure, conn.PortA.Density,
+                                                    conn.PortB.Pressure, conn.PortB.Density, conn);
+            conn.PortA.MassFlowRate = -mdot;
+            conn.PortB.MassFlowRate = mdot;
+            if (mdot > 0)
+                conn.PortB.SpecificEnthalpy = conn.PortA.SpecificEnthalpy;
+            else if (mdot < 0)
+                conn.PortA.SpecificEnthalpy = conn.PortB.SpecificEnthalpy;
+        }
+
+        void Transfer(Port pipePort, Port volPort)
+        {
+            double mdot = pipePort.MassFlowRate;
+            volPort.MassFlowRate = -mdot;
+            volPort.SpecificEnthalpy = pipePort.SpecificEnthalpy;
+        }
+    }
+}
--- a/Core/SoundEngine.cs
+++ b/Core/SoundEngine.cs
@@ -0,0 +1,131 @@
+using SFML.Audio;
+using SFML.System;
+
+namespace FluidSim;
+
+#region Lock‑free ring buffer (unchanged)
+internal class RingBuffer
+{
+    private readonly float[] buffer;
+    private volatile int readPos;
+    private volatile int writePos;
+
+    public RingBuffer(int capacity)
+    {
+        if ((capacity & (capacity - 1)) != 0)
+            throw new ArgumentException("Capacity must be a power of two.");
+        buffer = new float[capacity];
+    }
+
+    public int Count => (writePos - readPos) & (buffer.Length - 1);
+    public int Space => (readPos - writePos - 1) & (buffer.Length - 1);
+
+    public int Write(float[] data, int count)
+    {
+        int space = Space;
+        int toWrite = Math.Min(count, space);
+        int mask = buffer.Length - 1;
+        for (int i = 0; i < toWrite; i++)
+            buffer[(writePos + i) & mask] = data[i];
+        writePos = (writePos + toWrite) & mask;
+        return toWrite;
+    }
+
+    public int Read(float[] destination, int count)
+    {
+        int available = Count;
+        int toRead = Math.Min(count, available);
+        int mask = buffer.Length - 1;
+        for (int i = 0; i < toRead; i++)
+            destination[i] = buffer[(readPos + i) & mask];
+        readPos = (readPos + toRead) & mask;
+        return toRead;
+    }
+}
+#endregion
+
+#region Stereo stream that consumes the ring buffer
+internal class RingBufferStream : SoundStream
+{
+    private readonly RingBuffer ringBuffer;
+
+    public RingBufferStream(RingBuffer buffer)
+    {
+        ringBuffer = buffer;
+        // 2 channels, 44.1 kHz, standard stereo mapping
+        Initialize(2, 44100, new[] { SoundChannel.FrontLeft, SoundChannel.FrontRight });
+    }
+
+    protected override bool OnGetData(out short[] samples)
+    {
+        const int monoBlockSize = 512;          // number of mono samples we'll read
+        float[] temp = new float[monoBlockSize];
+        int read = ringBuffer.Read(temp, monoBlockSize);
+        samples = new short[monoBlockSize * 2];
+
+        if (read > 0)
+        {
+            for (int i = 0; i < read; i++)
+            {
+                float clamped = Math.Clamp(temp[i], -1f, 1f);
+                short final = (short)(clamped * short.MaxValue);
+                samples[i * 2] = final;   // left
+                samples[i * 2 + 1] = final;   // right
+            }
+        }
+        for (int i = read * 2; i < samples.Length; i++)
+            samples[i] = 0;
+
+        return true;
+    }
+
+    protected override void OnSeek(Time timeOffset) =>
+        throw new NotSupportedException();
+}
+#endregion
+
+#region Public sound engine API (unchanged)
+public class SoundEngine : IDisposable
+{
+    private readonly RingBuffer ringBuffer;
+    private readonly RingBufferStream stream;
+    private bool isPlaying;
+
+    public SoundEngine(int bufferCapacity = 16384)
+    {
+        ringBuffer = new RingBuffer(bufferCapacity);
+        stream = new RingBufferStream(ringBuffer);
+    }
+
+    public void Start()
+    {
+        if (isPlaying) return;
+        stream.Play();
+        isPlaying = true;
+    }
+
+    public void Stop()
+    {
+        if (!isPlaying) return;
+        stream.Stop();
+        isPlaying = false;
+        float[] drain = new float[ringBuffer.Count];
+        ringBuffer.Read(drain, drain.Length);
+    }
+
+    public int WriteSamples(float[] data, int count) =>
+        ringBuffer.Write(data, count);
+
+    public float Volume
+    {
+        get => stream.Volume;
+        set => stream.Volume = value;
+    }
+
+    public void Dispose()
+    {
+        Stop();
+        stream.Dispose();
+    }
+}
+#endregion