update

Core/SoundProcessor.cs

@@ -4,14 +4,20 @@ namespace FluidSim.Core
 {
     public class SoundProcessor
     {
-        // Monopole state
-        private double lastMassFlow = 0.0;
         private double dt;
+        private double pipeArea;
+        private double ambientPressure = 101325.0;
 
-        // Resonant band‑pass filter (second‑order)
-        private double b0, b1, b2, a1, a2;
-        private double x1 = 0, x2 = 0, y1 = 0, y2 = 0;
-        private double pipeLength;
+        // Monopole source state
+        private double lastMassFlow = 0.0;
+
+        // Gains
+        private float masterGain = 0.0005f;
+        private float pressureGain = 0.12f;
+        private float turbulenceGain = 0.05f;
+        private float turbulence = 0.05f;
+
+        private PinkNoiseGenerator pinkNoise;
 
         // Reverb (outdoor)
         private float[] delayLine;
@@ -20,36 +26,11 @@ namespace FluidSim.Core
         private float lowpassCoeff = 0.70f;
         private float lastFeedbackSample = 0f;
 
-        // Turbulence (pink noise scaled by U³)
-        private PinkNoiseGenerator pinkNoise;
-        private float turbulenceGain = 0.05f;
-        private double pipeArea;
-        private double ambientPressure = 101325.0;
-
-        // Gains
-        private float masterGain = 0.0005f;
-        private float pressureGain = 0.12f;
-
-        public SoundProcessor(int sampleRate, double pipeLengthMeters, double pipeDiameterMeters = 0.04, float reverbTimeMs = 200.0f)
+        public SoundProcessor(int sampleRate, double pipeDiameterMeters, float reverbTimeMs = 200.0f)
         {
             dt = 1.0 / sampleRate;
-            pipeLength = pipeLengthMeters;
             pipeArea = Math.PI * Math.Pow(pipeDiameterMeters / 2.0, 2.0);
 
-            // Design resonant filter at pipe fundamental frequency
-            double c = 340.0;
-            double f0 = c / (4.0 * pipeLength);
-            double Q = 15.0;
-            double omega = 2.0 * Math.PI * f0;
-            double alpha = Math.Sin(omega * dt) / (2.0 * Q);
-            double norm = 1.0 / (1.0 + alpha);
-            b0 = alpha * norm;
-            b1 = 0.0;
-            b2 = -alpha * norm;
-            a1 = -2.0 * Math.Cos(omega * dt) * norm;
-            a2 = (1.0 - alpha) * norm;
-
-            // Reverb delay line
             int delaySamples = (int)(sampleRate * reverbTimeMs / 1000.0);
             delayLine = new float[delaySamples];
             writeIndex = 0;
@@ -62,65 +43,60 @@ namespace FluidSim.Core
             get => masterGain;
             set => masterGain = value;
         }
-
         public float PressureGain
         {
             get => pressureGain;
             set => pressureGain = value;
         }
-
         public float TurbulenceGain
         {
             get => turbulenceGain;
             set => turbulenceGain = value;
         }
+        public float Turbulence
+        {
+            get => turbulence;
+            set => turbulence = value;
+        }
 
         public void SetAmbientPressure(double p) => ambientPressure = p;
-        public void SetPipeDiameter(double diameterMeters) => pipeArea = Math.PI * Math.Pow(diameterMeters / 2.0, 2.0);
+        public void SetPipeDiameter(double diameterMeters) =>
+            pipeArea = Math.PI * Math.Pow(diameterMeters / 2.0, 2.0);
 
         public float Process(float massFlow, float pipeEndPressure)
         {
-            // 1. Monopole source: d(mdot)/dt
+            // 1. Monopole: d(mdot)/dt
             double derivative = (massFlow - lastMassFlow) / dt;
-            derivative = Math.Clamp(derivative, -500, 500);
             lastMassFlow = massFlow;
             float monopole = (float)(derivative * masterGain);
 
-            // 2. Pressure difference (low‑frequency component)
+            // 2. Pressure component
             float pressureDiff = (float)((pipeEndPressure - ambientPressure) / ambientPressure) * pressureGain;
+
             float mixed = monopole + pressureDiff;
-            // DO NOT clamp here – let the filter and final clamp handle dynamics
 
-            // 3. Resonant band‑pass filter
-            double y = b0 * mixed + b1 * x1 + b2 * x2 - a1 * y1 - a2 * y2;
-            x2 = x1; x1 = mixed;
-            y2 = y1; y1 = y;
-            float resonant = (float)Math.Clamp(y, -1f, 1f);
-
-            // 4. Turbulence noise: amplitude ∝ U³ (empirical for low speeds)
+            // 3. Turbulence: amplitude ∝ U^8
             double velocity = massFlow / (pipeArea * 1.225);
-            double Uref = 100.0;
-            double turbulenceAmp = Math.Pow(Math.Abs(velocity) / Uref, 3.0);
+            double turbulenceAmp = Math.Pow(Math.Abs(velocity) * turbulence, 3.0);
             float pink = pinkNoise.Next() * turbulenceGain * (float)turbulenceAmp;
 
-            resonant += pink;
-            resonant = Math.Clamp(resonant, -1f, 1f);
+            float combined = mixed + pink;
 
-            // 5. Outdoor reverb
+            // 4. Outdoor reverb
             float delayed = delayLine[writeIndex];
             float filteredDelay = delayed * lowpassCoeff + lastFeedbackSample * (1f - lowpassCoeff);
             lastFeedbackSample = filteredDelay;
             float wet = delayed + filteredDelay * feedback;
-            delayLine[writeIndex] = resonant + filteredDelay * feedback;
+            delayLine[writeIndex] = combined + filteredDelay * feedback;
             writeIndex = (writeIndex + 1) % delayLine.Length;
 
-            // 6. Dry/wet mix
-            float output = resonant * 0.7f + wet * 0.3f;
-            output = MathF.Tanh(output);
-            return output;
+            // 5. Dry/wet mix
+            float output = combined * 0.7f + wet * 0.3f;
+            return MathF.Tanh(output);
         }
     }
 
+    // PinkNoiseGenerator unchanged, same as before
     internal class PinkNoiseGenerator
     {
         private readonly Random random = new Random();