refactoring (broken right now)

Core/OrificeLink.cs

@@ -0,0 +1,140 @@
+using System;
+using FluidSim.Components;
+using FluidSim.Interfaces;
+
+namespace FluidSim.Core
+{
+    /// <summary>
+    /// Connects a port (volume or atmosphere) to one end of a pipe via an orifice.
+    /// The area can be dynamic (Func<double>).
+    /// </summary>
+    public class OrificeLink
+    {
+        public Port VolumePort { get; }
+        public Pipe1D Pipe { get; }
+        public bool IsPipeLeftEnd { get; }
+        public Func<double> AreaProvider { get; set; }
+        public double DischargeCoefficient { get; set; } = 0.62;
+        public double Gamma { get; set; } = 1.4;
+        public double GasConstant { get; set; } = 287.0;
+
+        // Last resolved state (for audio/monitoring)
+        public double LastMassFlowRate { get; private set; }
+        public double LastFaceDensity { get; private set; }
+        public double LastFaceVelocity { get; private set; }
+        public double LastFacePressure { get; private set; }
+
+        public OrificeLink(Port volumePort, Pipe1D pipe, bool isPipeLeftEnd, Func<double> areaProvider)
+        {
+            VolumePort = volumePort ?? throw new ArgumentNullException(nameof(volumePort));
+            Pipe = pipe ?? throw new ArgumentNullException(nameof(pipe));
+            IsPipeLeftEnd = isPipeLeftEnd;
+            AreaProvider = areaProvider ?? throw new ArgumentNullException(nameof(areaProvider));
+        }
+
+        /// <summary>
+        /// Resolve the coupling for one sub‑step. Computes nozzle flow (isentropic)
+        /// and sets the pipe ghost cell and the port flow rates.
+        /// </summary>
+        public void Resolve(double dtSub)
+        {
+            double area = AreaProvider();
+            if (area < 1e-12)
+            {
+                SetClosedWall();
+                return;
+            }
+
+            // Retrieve volume state
+            double volP = VolumePort.Pressure;
+            double volRho = VolumePort.Density;
+            double volT = VolumePort.Temperature;
+            double volH = VolumePort.SpecificEnthalpy;
+
+            // Retrieve pipe interior state at the connected end
+            (double pipeRho, double pipeU, double pipeP) = IsPipeLeftEnd
+                ? Pipe.GetInteriorStateLeft()
+                : Pipe.GetInteriorStateRight();
+
+            // Determine upstream/downstream: if volume pressure > pipe pressure, flow is out of volume (negative into volume).
+            bool flowOutOfVolume = volP > pipeP;
+            double pUp, rhoUp, TUp, pDown;
+            if (flowOutOfVolume)
+            {
+                pUp = volP; rhoUp = volRho; TUp = volT; pDown = pipeP;
+            }
+            else
+            {
+                // Pipe is upstream
+                pUp = pipeP; rhoUp = pipeRho; TUp = pipeP / (pipeRho * GasConstant); // temperature from pipe
+                pDown = volP;
+            }
+
+            // Compute isentropic nozzle flow
+            IsentropicOrifice.Compute(pUp, rhoUp, TUp, Gamma, GasConstant, pDown, area, DischargeCoefficient,
+                                      out double mdotUpstreamToDown, out double rhoFace, out double uFace, out double pFace);
+
+            // mdotUpstreamToDown is positive from upstream to downstream.
+            // Convert to mass flow into volume (positive mdot = into volume).
+            double mdotVolume;
+            if (flowOutOfVolume)
+                mdotVolume = -mdotUpstreamToDown;   // out of volume is negative
+            else
+                mdotVolume = mdotUpstreamToDown;    // into volume is positive
+
+            // Clamp mass flow to available mass in volume (if it is a Volume0D)
+            if (VolumePort.Owner is Volume0D vol)
+            {
+                double maxMdot = vol.Mass / dtSub;
+                if (mdotVolume > maxMdot) mdotVolume = maxMdot;
+                if (mdotVolume < -maxMdot) mdotVolume = -maxMdot;
+            }
+
+            // Apply ghost state to pipe
+            if (IsPipeLeftEnd)
+                Pipe.SetGhostLeft(rhoFace, uFace, pFace);
+            else
+                Pipe.SetGhostRight(rhoFace, uFace, pFace);
+
+            // Store results
+            LastMassFlowRate = mdotVolume;
+            LastFaceDensity = rhoFace;
+            LastFaceVelocity = uFace;
+            LastFacePressure = pFace;
+
+            // Set port flow rates for volume integration
+            VolumePort.MassFlowRate = mdotVolume;
+            if (mdotVolume >= 0)
+            {
+                // Inflow: enthalpy comes from upstream (pipe)
+                double pPipe = pipeP;
+                double rhoPipe = pipeRho;
+                VolumePort.SpecificEnthalpy = Gamma / (Gamma - 1.0) * pPipe / rhoPipe;
+            }
+            else
+            {
+                // Outflow: volume's own specific enthalpy
+                VolumePort.SpecificEnthalpy = volH;
+            }
+        }
+
+        private void SetClosedWall()
+        {
+            var (rInt, uInt, pInt) = IsPipeLeftEnd
+                ? Pipe.GetInteriorStateLeft()
+                : Pipe.GetInteriorStateRight();
+
+            if (IsPipeLeftEnd)
+                Pipe.SetGhostLeft(rInt, -uInt, pInt);
+            else
+                Pipe.SetGhostRight(rInt, -uInt, pInt);
+
+            LastMassFlowRate = 0.0;
+            LastFaceDensity = rInt;
+            LastFaceVelocity = 0.0;
+            LastFacePressure = pInt;
+            VolumePort.MassFlowRate = 0.0;
+            // Keep specific enthalpy as is (not used)
+        }
+    }
+}