Helmholtz test, sod shock tube

Scenarios/HelmholtzResonatorScenario.cs

@@ -0,0 +1,133 @@
+using System;
+using FluidSim.Components;
+using FluidSim.Interfaces;
+using FluidSim.Utils;
+using SFML.Graphics;
+using SFML.System;
+
+namespace FluidSim.Core
+{
+    public class HelmholtzResonatorScenario : Scenario
+    {
+        private Solver solver;
+        private Volume0D cavity;
+        private Pipe1D neck;
+        private Connection coupling;
+        private int stepCount;
+        private double time;
+        private double dt;
+        private double ambientPressure = 1.0 * Units.atm;
+
+        public override void Initialize(int sampleRate)
+        {
+            dt = 1.0 / sampleRate;
+
+            // 1‑litre cavity, 10% over‑pressure
+            double cavityVolume = 1e-3;
+            double initialCavityPressure = 1.1 * ambientPressure;
+            cavity = new Volume0D(cavityVolume, initialCavityPressure, 300.0, sampleRate)
+            {
+                Gamma = 1.4,
+                GasConstant = 287.0
+            };
+
+            // Neck: length 10 cm, radius 1 cm
+            double neckLength = 0.1;
+            double neckRadius = 0.01;
+            double neckArea = Math.PI * neckRadius * neckRadius;
+            neck = new Pipe1D(neckLength, neckArea, sampleRate, forcedCellCount: 40);
+            neck.SetUniformState(1.225, 0.0, ambientPressure);
+
+            coupling = new Connection(neck.PortA, cavity.Port)
+            {
+                Area = neckArea,
+                DischargeCoefficient = 0.62,
+                Gamma = 1.4
+            };
+
+            solver = new Solver();
+            solver.SetTimeStep(dt);
+            solver.AddVolume(cavity);
+            solver.AddPipe(neck);
+            solver.AddConnection(coupling);
+
+            // Port A (left) = volume coupling, Port B (right) = open end
+            solver.SetPipeBoundary(neck, isA: true, BoundaryType.VolumeCoupling);
+            solver.SetPipeBoundary(neck, isA: false, BoundaryType.OpenEnd, ambientPressure);
+        }
+
+        public override float Process()
+        {
+            float sample = solver.Step();
+            time += dt;
+            stepCount++;
+
+            double pOpen = neck.GetCellPressure(neck.GetCellCount() - 1);
+            float audio = (float)((pOpen - ambientPressure) / ambientPressure);
+
+            if (stepCount % 20 == 0)
+            {
+                double pCav = cavity.Pressure;
+                double mdotA = neck.PortA.MassFlowRate;   // positive = into pipe (leaving cavity)
+                Console.WriteLine(
+                    $"t={time * 1e3:F2} ms step={stepCount} " +
+                    $"P_cav={pCav:F1} Pa, P_open={pOpen:F1} Pa, " +
+                    $"mdot_A={mdotA * 1e3:F4} g/s, audio={audio:F4}");
+            }
+
+            return audio;
+        }
+
+        public override void Draw(RenderWindow target)
+        {
+            float winW = target.GetView().Size.X;
+            float winH = target.GetView().Size.Y;
+            float centerY = winH / 2f;
+
+            // Cavity rectangle
+            float cavityWidth = 120f;
+            float cavityHeight = 180f;
+            var cavityRect = new RectangleShape(new Vector2f(cavityWidth, cavityHeight));
+            cavityRect.Position = new Vector2f(40f, centerY - cavityHeight / 2f);
+            cavityRect.FillColor = PressureColor(cavity.Pressure);
+            target.Draw(cavityRect);
+
+            // Neck drawn as tapered pipe
+            int n = neck.GetCellCount();
+            float neckStartX = 40f + cavityWidth + 10f;
+            float neckEndX = winW - 60f;
+            float neckLenPx = neckEndX - neckStartX;
+            float dx = neckLenPx / (n - 1);
+            float baseRadius = 20f;
+
+            Vertex[] vertices = new Vertex[n * 2];
+            for (int i = 0; i < n; i++)
+            {
+                float x = neckStartX + i * dx;
+                double p = neck.GetCellPressure(i);
+                float r = baseRadius * (float)(0.5 + 0.5 * Math.Tanh((p - ambientPressure) / (ambientPressure * 0.2)));
+                if (r < 4f) r = 4f;
+                Color col = PressureColor(p);
+                vertices[i * 2] = new Vertex(new Vector2f(x, centerY - r), col);
+                vertices[i * 2 + 1] = new Vertex(new Vector2f(x, centerY + r), col);
+            }
+            target.Draw(vertices, PrimitiveType.TriangleStrip);
+
+            // Open end indicator
+            var arrow = new CircleShape(8f);
+            arrow.Position = new Vector2f(neckEndX - 4f, centerY - 4f);
+            arrow.FillColor = Color.White;
+            target.Draw(arrow);
+        }
+
+        private Color PressureColor(double pressure)
+        {
+            double range = ambientPressure * 0.1;
+            double t = Math.Clamp((pressure - ambientPressure) / range, -1.0, 1.0);
+            byte r = (byte)(t > 0 ? 255 * t : 0);
+            byte b = (byte)(t < 0 ? -255 * t : 0);
+            byte g = (byte)(255 * (1 - Math.Abs(t)));
+            return new Color(r, g, b);
+        }
+    }
+}

Scenarios/PipeResonatorScenario.cs

@@ -21,7 +21,7 @@ namespace FluidSim.Core
         {
             dt = 1.0 / sampleRate;
 
-            double length = 0.5;
+            double length = 2;
             double radius = 50 * Units.mm;
             double area = Units.AreaFromDiameter(radius);
 
@@ -31,8 +31,9 @@ namespace FluidSim.Core
             solver = new Solver();
             solver.SetTimeStep(dt);
             solver.AddPipe(pipe);
-            solver.SetPipeBoundary(pipe, isLeft: true, BoundaryType.OpenEnd, ambientPressure);
-            solver.SetPipeBoundary(pipe, isLeft: false, BoundaryType.ClosedEnd);
+            // Open end at port A (left), closed end at port B (right)
+            solver.SetPipeBoundary(pipe, isA: true, BoundaryType.OpenEnd, ambientPressure);
+            solver.SetPipeBoundary(pipe, isA: false, BoundaryType.ClosedEnd);
 
             // Initial pressure pulse
             int pulseCells = 5;

Scenarios/SodShockTubeScenario.cs

@@ -0,0 +1,158 @@
+using System;
+using FluidSim.Components;
+using FluidSim.Utils;
+using SFML.Graphics;
+using SFML.System;
+
+namespace FluidSim.Core
+{
+    public class SodShockTubeScenario : Scenario
+    {
+        private Solver solver;
+        private Pipe1D pipe;
+        private int stepCount;
+        private double time;
+        private double dt;
+        private double ambientPressure = 1.0 * Units.atm;
+        private const double GasConstant = 287.0;
+
+        public override void Initialize(int sampleRate)
+        {
+            dt = 1.0 / sampleRate;
+            double length = 1.0;
+            double area = 1.0;
+            int nCells = 200;
+
+            pipe = new Pipe1D(length, area, sampleRate, forcedCellCount: nCells);
+            pipe.SetUniformState(0.125, 0.0, 0.1 * ambientPressure);  // right state
+
+            // Left half high pressure
+            for (int i = 0; i < nCells / 2; i++)
+                pipe.SetCellState(i, 1.0, 0.0, ambientPressure);
+
+            solver = new Solver();
+            solver.SetTimeStep(dt);
+            solver.AddPipe(pipe);
+            solver.SetPipeBoundary(pipe, isA: true, BoundaryType.ClosedEnd);
+            solver.SetPipeBoundary(pipe, isA: false, BoundaryType.ClosedEnd);
+        }
+
+        public override float Process()
+        {
+            float sample = solver.Step();
+            time += dt;
+            stepCount++;
+
+            double pMid = pipe.GetPressureAtFraction(0.5);
+            float audio = (float)((pMid - ambientPressure) / ambientPressure);
+
+            bool log = true;
+
+            if (log)
+            {
+                int n = pipe.GetCellCount();
+                Console.WriteLine($"step {stepCount}:");
+                Console.WriteLine("i    rho (kg/m³)   p (Pa)       T (K)     u (m/s)");
+                for (int i = 0; i < n; i++)
+                {
+                    if (i % 10 == 0)
+                    {
+                        double rho = pipe.GetCellDensity(i);
+                        double p = pipe.GetCellPressure(i);
+                        double u = pipe.GetCellVelocity(i);
+                        double T = p / (rho * GasConstant);   // GasConstant = 287.0
+                        Console.WriteLine($"{i,-4} {rho,10:F4}   {p,10:F1}   {T,8:F2}   {u,10:F4}");
+                    }
+                }
+                Console.WriteLine();
+            }
+
+            return audio;
+        }
+
+        public override void Draw(RenderWindow target)
+        {
+            float winW = target.GetView().Size.X;
+            float winH = target.GetView().Size.Y;
+            float centerY = winH / 2f;
+            float margin = 40f;
+            float pipeStartX = margin;
+            float pipeEndX = winW - margin;
+            float pipeLenPx = pipeEndX - pipeStartX;
+            int n = pipe.GetCellCount();
+            float dx = pipeLenPx / (n - 1);
+            float baseRadius = 60f;
+
+            Vertex[] vertices = new Vertex[n * 2];
+            for (int i = 0; i < n; i++)
+            {
+                float x = pipeStartX + i * dx;
+
+                double p = pipe.GetCellPressure(i);
+                double rho = pipe.GetCellDensity(i);
+                double T = p / (rho * GasConstant);           // temperature in Kelvin
+
+                // Radius from pressure (exaggerated deviation)
+                float r = baseRadius * (float)(p / ambientPressure * 2);
+                if (r < 4f) r = 4f;
+
+                // Colour from temperature
+                Color col = TemperatureColor(T);
+
+                vertices[i * 2] = new Vertex(new Vector2f(x, centerY - r), col);
+                vertices[i * 2 + 1] = new Vertex(new Vector2f(x, centerY + r), col);
+            }
+            target.Draw(vertices, PrimitiveType.TriangleStrip);
+
+            // Diaphragm marker (faint white line at initial interface)
+            float diaphragmX = pipeStartX + (n / 2) * dx;
+            var line = new RectangleShape(new Vector2f(2f, winH * 0.5f));
+            line.Position = new Vector2f(diaphragmX - 1f, centerY - winH * 0.25f);
+            line.FillColor = new Color(255, 255, 255, 80);
+            target.Draw(line);
+        }
+
+        /// <summary>
+        /// Custom temperature‑to‑hue mapping that matches the given Sod‑tube hue values:
+        ///   250 K → 176, 300 K → 122, 350 K → 120?, 450 K → 71.
+        /// Interpolates piecewise linearly, clamping outside [250,450].
+        /// </summary>
+        private Color TemperatureColor(double T)
+        {
+            // 1. Map temperature to hue (0–360)
+            double[] Tknots = { 250, 282, 353, 450 };
+            double[] Hknots = { 176, 179, 122, 71 };
+            double hue;
+            if (T <= Tknots[0]) hue = Hknots[0];
+            else if (T >= Tknots[^1]) hue = Hknots[^1];
+            else
+            {
+                int i = 0;
+                while (i < Tknots.Length - 1 && T > Tknots[i + 1]) i++;
+                double frac = (T - Tknots[i]) / (Tknots[i + 1] - Tknots[i]);
+                hue = Hknots[i] + frac * (Hknots[i + 1] - Hknots[i]);
+            }
+
+            // 2. Convert hue to RGB (S = 1, V = 1)
+            double h = hue / 60.0;
+            int sector = (int)Math.Floor(h);
+            double f = h - sector;
+            byte p = 0;
+            byte q = (byte)(255 * (1 - f));
+            byte tByte = (byte)(255 * f);
+            byte v = 255;
+
+            byte r, g, b;
+            switch (sector % 6)
+            {
+                case 0: r = v; g = tByte; b = p; break;
+                case 1: r = q; g = v; b = p; break;
+                case 2: r = p; g = v; b = tByte; break;
+                case 3: r = p; g = q; b = v; break;
+                case 4: r = tByte; g = p; b = v; break;
+                default: r = v; g = p; b = q; break;
+            }
+            return new Color(r, g, b);
+        }
+    }
+}