Add counter pressure braking

Author: peternewell

Source/Orts.Simulation/Simulation/RollingStocks/MSTSLocomotive.cs

@@ -115,6 +115,7 @@ public enum LocomotiveRailDriveTypes
         public LocomotiveRailDriveTypes LocomotiveRailDriveType;
 
         public bool RackGogWheelEngaged = false;
+        public float CogWheelDiameterM;
 
         // simulation parameters
         public bool ManualHorn = false;
@@ -3019,6 +3020,7 @@ public virtual void AdvancedAdhesion(float elapsedClockSeconds)
                 axle.BrakeRetardForceN = BrakeRetardForceN / LocomotiveAxles.Count;
                 axle.TrainSpeedMpS = SpeedMpS;                //Set the train speed of the axle mod
                 axle.WheelRadiusM = DriverWheelRadiusM;
+                axle.CogWheelRadiusM = CogWheelRadiusM;
                 axle.WheelDistanceGaugeM = TrackGaugeM;
                 axle.CurrentCurveRadiusM = CurrentCurveRadiusM;
                 axle.BogieRigidWheelBaseM = RigidWheelBaseM;

Source/Orts.Simulation/Simulation/RollingStocks/MSTSSteamLocomotive.cs

@@ -86,6 +86,7 @@
 using SharpDX.Direct3D9;
 using Orts.Simulation.RollingStocks;
 using static Orts.Simulation.RollingStocks.MSTSSteamLocomotive;
+using SharpDX.MediaFoundation;
 
 namespace Orts.Simulation.RollingStocks
 {
@@ -171,6 +172,8 @@ public class MSTSSteamLocomotive : MSTSLocomotive
         bool BoosterAirisLow = false;
         int BoosterEngineNumber;
 
+        float SteamLocomotiveRetardingDynamicBrakeForceN = 0;
+
         /// <summary>
         /// Grate limit of locomotive exceedeed?
         /// </summary>
@@ -2498,6 +2501,7 @@ public override void Update(float elapsedClockSeconds)
             LocoTenderFrictionForceN = CombFrictionN;
 
             #region transfer energy
+
             UpdateFX(elapsedClockSeconds);
             UpdateTender(elapsedClockSeconds);
             UpdateFirebox(elapsedClockSeconds, absSpeedMpS);
@@ -2519,6 +2523,7 @@ public override void Update(float elapsedClockSeconds)
 
                 if (SteamEngines[i].AuxiliarySteamEngineType != SteamEngine.AuxiliarySteamEngineTypes.Booster)
                 {
+                    UpdateCounterPressure(elapsedClockSeconds, cutoff, i);
                     UpdateCylinders(elapsedClockSeconds, throttle, cutoff, absSpeedMpS, i);
                 }
                 else if (SteamEngines[i].AuxiliarySteamEngineType == SteamEngine.AuxiliarySteamEngineTypes.Booster)  // Booster Engine
@@ -4874,7 +4879,55 @@ private void UpdateSuperHeat()
 
         }
 
-        private void UpdateCylinders(float elapsedClockSeconds, float throttle, float cutoff, float absSpeedMpS, int numberofengine)
+        /// <summary>
+        /// Calculate the counter pressure to be used by a locomotive as a braking effect
+        /// To do this we first calculate the MEP air pressure of compressed air with each stroke, then we calculate the resulting "resisting" tractive force
+        /// </summary>
+        private void UpdateCounterPressure(float elapsedClockSeconds, float cutoff, int numberofengine)
+        {
+            SteamLocomotiveRetardingDynamicBrakeForceN = 0;
+
+            float currentDynamicBrakeFraction = DynamicBrakePercent / 100;
+
+            if (currentDynamicBrakeFraction > 0 && absSpeedMpS >0)
+            {
+                float CylinderVolumePoint_compression = (currentDynamicBrakeFraction * Me.ToIn(SteamEngines[numberofengine].CylindersStrokeM)) + CylinderClearancePC;
+                float CylinderVolumePoint_release = (Me.ToIn(SteamEngines[numberofengine].CylindersStrokeM) + 2 * CylinderClearancePC) - CylinderVolumePoint_compression;
+
+//                Trace.TraceInformation("Vol-release {0} Vol-compression {1} Stroke {2}", CylinderVolumePoint_release, CylinderVolumePoint_compression, Me.ToIn(SteamEngines[numberofengine].CylindersStrokeM));
+
+                // Ratio of compression = stroke during compression = stroke @ start of compression / stroke and end of compression
+                float CylinderRatio_compression = CylinderVolumePoint_compression / CylinderClearancePC;
+                float CylinderRatio_release = CylinderVolumePoint_compression / (Me.ToIn(SteamEngines[numberofengine].CylindersStrokeM) + 2 * CylinderClearancePC);
+
+                float CompMeanPressure_compressionAtmPSI = OneAtmospherePSI * CylinderRatio_compression * ((float)Math.Log(CylinderRatio_compression, 10) / (CylinderRatio_compression - 1.0f));
+                float CompMeanPressure_releaseAtmPSI = CompMeanPressure_compressionAtmPSI * CylinderRatio_release * ((float)Math.Log(CylinderRatio_release) / (CylinderRatio_release - 1.0f));
+
+//                Trace.TraceInformation("MEPcomp {0} Log {1} CompRatio {2}", CompMeanPressure_compressionAtmPSI, (float)Math.Log(CylinderRatio_compression), CylinderRatio_compression);
+
+                float CylinderWork_compression_InLbs = CompMeanPressure_compressionAtmPSI * CylinderVolumePoint_compression;
+                float CylinderWork_release_InLbs = CompMeanPressure_releaseAtmPSI * CylinderVolumePoint_release;
+
+//                Trace.TraceInformation("Workc {0} Workr {1} Pc {2} Pr {3}", CylinderWork_compression_InLbs, CylinderWork_release_InLbs, CompMeanPressure_compressionAtmPSI, CompMeanPressure_releaseAtmPSI);
+
+                float TotalWorkCounterPressure = CylinderWork_compression_InLbs + CylinderWork_release_InLbs;
+
+                float CounterPressureMEP = TotalWorkCounterPressure / Me.ToIn(SteamEngines[numberofengine].CylindersStrokeM);
+
+                // Calculate tractive retarding force
+                SteamLocomotiveRetardingDynamicBrakeForceN = N.FromLbf(CounterPressureMEP * Me.ToIn(SteamEngines[numberofengine].CylindersDiameterM) * Me.ToIn(SteamEngines[numberofengine].CylindersDiameterM) * Me.ToIn(SteamEngines[numberofengine].CylindersStrokeM) / Me.ToIn(SteamEngines[numberofengine].AttachedAxle.CogWheelRadiusM));
+
+//                Trace.TraceInformation("CogRetardForce {0} throttle {1} MEP {2} Ratio-Comp {3} Ratio-Rel {4}", N.ToLbf(SteamLocomotiveRetardingDynamicBrakeForceN), throttle, CounterPressureMEP, CylinderRatio_compression, CylinderRatio_release);
+            }
+            else
+            {
+                SteamLocomotiveRetardingDynamicBrakeForceN = 0;
+            }
+
+
+        }
+
+            private void UpdateCylinders(float elapsedClockSeconds, float throttle, float cutoff, float absSpeedMpS, int numberofengine)
         {
             // Calculate speed of locomotive in wheel rpm - used to determine changes in performance based upon speed.
             SteamEngines[numberofengine].DriveWheelRevRpS = absSpeedMpS / (2.0f * MathHelper.Pi * SteamEngines[numberofengine].AttachedAxle.WheelRadiusM);
@@ -6592,6 +6645,18 @@ protected override void UpdateTractiveForce(float elapsedClockSeconds, float loc
             {
                 TractiveForceN = 0;
             }
+
+        //    if (DynamicBrakePercent > 0 && DynamicBrake)
+
+            if (DynamicBrakePercent > 0)
+            {
+                DynamicBrakeForceN = SteamLocomotiveRetardingDynamicBrakeForceN;
+            }
+            else
+            {
+                DynamicBrakeForceN = 0;
+            }
+
         }
 
 

Source/Orts.Simulation/Simulation/RollingStocks/MSTSWagon.cs

@@ -1296,6 +1296,7 @@ public virtual void Parse(string lowercasetoken, STFReader stf)
                 case "wagon(ortsheatingboilerfuelusage": TrainHeatBoilerFuelUsageGalukpH = new Interpolator(stf); break;
                 case "wagon(wheelradius": WheelRadiusM = stf.ReadFloatBlock(STFReader.UNITS.Distance, null); break;
                 case "engine(wheelradius": DriverWheelRadiusM = stf.ReadFloatBlock(STFReader.UNITS.Distance, null); break;
+                case "engine(ortscogwheelradius": CogWheelRadiusM = stf.ReadFloatBlock(STFReader.UNITS.Distance, null); break;
                 case "wagon(sound": MainSoundFileName = stf.ReadStringBlock(null); break;
                 case "wagon(ortsbrakeshoefriction": BrakeShoeFrictionFactor = new Interpolator(stf); break;
                 case "wagon(maxhandbrakeforce": InitialMaxHandbrakeForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, null); break;
@@ -1548,11 +1549,6 @@ public virtual void Parse(string lowercasetoken, STFReader stf)
                     Couplers[CouplerCountLocation].Rigid = false;
                     Couplers[CouplerCountLocation].Rigid = stf.ReadBoolBlock(true);
                     break;
-
-                case "wagon(ortscogwheel":
-                    CogWheelFitted = stf.ReadBoolBlock(false);
-                    break;
-
                 case "wagon(adheasion":
                     stf.MustMatch("(");
                     Adhesion1 = stf.ReadFloat(STFReader.UNITS.None, null);
@@ -1694,6 +1690,7 @@ public virtual void Copy(MSTSWagon copy)
             InitialMassKG = copy.InitialMassKG;
             WheelRadiusM = copy.WheelRadiusM;
             DriverWheelRadiusM = copy.DriverWheelRadiusM;
+            CogWheelRadiusM = copy.CogWheelRadiusM;
             MainSoundFileName = copy.MainSoundFileName;
             BrakeShoeFrictionFactor = copy.BrakeShoeFrictionFactor;
             WheelBrakeSlideProtectionFitted = copy.WheelBrakeSlideProtectionFitted;
@@ -1757,7 +1754,6 @@ public virtual void Copy(MSTSWagon copy)
             Curtius_KnifflerB = copy.Curtius_KnifflerB;
             Curtius_KnifflerC = copy.Curtius_KnifflerC;
             AdhesionK = copy.AdhesionK;
-            CogWheelFitted = copy.CogWheelFitted;
             AxleInertiaKgm2 = copy.AxleInertiaKgm2;
             SlipWarningThresholdPercent = copy.SlipWarningThresholdPercent;
             Lights = copy.Lights;

Source/Orts.Simulation/Simulation/RollingStocks/SubSystems/PowerTransmissions/Axle.cs

@@ -258,6 +258,8 @@ public void Initialize()
                     if (axle.AxleWeightN <= 0) axle.AxleWeightN = 9.81f * axle.WheelWeightKg;  //remains fixed for diesel/electric locomotives, but varies for steam locomotives
                     if (axle.NumWheelsetAxles <= 0) axle.NumWheelsetAxles = locomotive.LocoNumDrvAxles;
                     if (axle.WheelRadiusM <= 0) axle.WheelRadiusM = locomotive.DriverWheelRadiusM;
+                    if (axle.CogWheelRadiusM <= 0) axle.CogWheelRadiusM = locomotive.CogWheelRadiusM;
+                    if (!axle.CogWheelFitted) axle.CogWheelFitted = locomotive.CogWheelFitted;
                     if (axle.WheelFlangeAngleRad <= 0) axle.WheelFlangeAngleRad = locomotive.MaximumWheelFlangeAngleRad;
                     if (axle.DampingNs <= 0) axle.DampingNs = locomotive.MassKG / 1000.0f / AxleList.Count;
                     if (axle.FrictionN <= 0) axle.FrictionN = locomotive.MassKG / 1000.0f / AxleList.Count;
@@ -607,6 +609,11 @@ public float TransmissionEfficiency
         /// </summary>
         public float WheelRadiusM;
 
+        /// <summary>
+        /// Radius of wheels connected to rack track
+        /// </summary>
+        public float CogWheelRadiusM;
+
         /// <summary>
         /// Wheel number
         /// </summary>
@@ -903,10 +910,13 @@ public void Parse(STFReader stf)
                         WheelWeightKg = stf.ReadFloatBlock(STFReader.UNITS.Mass, null);
                         AxleWeightN = 9.81f * WheelWeightKg;
                         break;
-                    case "cogwheel":
+                    case "cogwheelfitted":
                         CogWheelFitted = stf.ReadBoolBlock(false);
                         Trace.TraceInformation("CogWheel - {0}", CogWheelFitted);
                         break;
+                    case "cogwheelradius":
+                        CogWheelRadiusM = stf.ReadFloatBlock(STFReader.UNITS.Distance, null);
+                        break;
                     case "animatedparts":
                         foreach (var part in stf.ReadStringBlock("").ToUpper().Replace(" ", "").Split(','))
                         {
@@ -922,6 +932,7 @@ public void Parse(STFReader stf)
         public void Copy(Axle other)
         {
             WheelRadiusM = other.WheelRadiusM;
+            CogWheelRadiusM = other.CogWheelRadiusM;
             WheelFlangeAngleRad = other.WheelFlangeAngleRad;
             NumWheelsetAxles = other.NumWheelsetAxles;
             InertiaKgm2 = other.InertiaKgm2;

Source/Orts.Simulation/Simulation/RollingStocks/TrainCar.cs

@@ -658,7 +658,8 @@ public Direction Direction
         public int LocoNumDrvAxles; // Number of drive axles on locomotive
         protected float MSTSLocoNumDrvWheels; // Number of drive axles on locomotive - used to read MSTS value as default
         public float DriverWheelRadiusM = Me.FromIn(30.0f); // Drive wheel radius of locomotive wheels - Wheel radius of loco drive wheels can be anywhere from about 10" to 40".
-                public enum SteamEngineTypes
+        public float CogWheelRadiusM = Me.FromIn(22.0f);
+        public enum SteamEngineTypes
         {
             Unknown,
             Simple,