Non-driven axles

Author: cesarBLG

Source/Orts.Simulation/Simulation/RollingStocks/MSTSDieselLocomotive.cs

@@ -178,7 +178,7 @@ public override void Parse(string lowercasetoken, STFReader stf)
                     var transmissionType = stf.ReadString();
                     try
                     {
-                        DieselTransmissionType = (DieselTransmissionTypes)Enum.Parse(typeof(DieselTransmissionTypes), transmissionType.First().ToString().ToUpper() + transmissionType.Substring(1));
+                        DieselTransmissionType = (DieselTransmissionTypes)Enum.Parse(typeof(DieselTransmissionTypes), transmissionType, true);
                     }
                     catch
                     {

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

@@ -2742,7 +2742,7 @@ protected virtual void UpdateTractiveForce(float elapsedClockSeconds)
             {
                 if (axle.DriveType == AxleDriveType.ForceDriven)
                 {
-                    axle.DriveForceN = TractiveForceN / LocomotiveAxles.Count;
+                    axle.DriveForceN = TractiveForceN * axle.TractiveForceFraction;
                     if (SlipControlSystem == SlipControlType.Full)
                     {
                         // Simple slip control
@@ -3112,7 +3112,7 @@ protected virtual void UpdateAxles(float elapsedClockSeconds)
 
             foreach (var axle in LocomotiveAxles)
             {
-                axle.BrakeRetardForceN = BrakeRetardForceN / LocomotiveAxles.Count;
+                axle.BrakeRetardForceN = BrakeRetardForceN * axle.BrakeForceFraction;
                 axle.TrainSpeedMpS = SpeedMpS;                //Set the train speed of the axle mod
                 axle.WheelRadiusM = DriverWheelRadiusM;
                 axle.WheelDistanceGaugeM = TrackGaugeM;

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

@@ -1301,6 +1301,35 @@ public override void Restore(BinaryReader inf)
 
         public override void Initialize()
         {
+            bool notDrivenAxle = false;
+            for (int i = 0; i < LocomotiveAxles.Count; i++)
+            {
+                var axle = LocomotiveAxles[i];
+                bool driven = false;
+                if (SteamEngines.Count > 0)
+                {
+                    foreach (var engine in SteamEngines)
+                    {
+                        if (engine.AttachedAxle == axle)
+                        {
+                            driven = true;
+                        }
+                    }
+                }
+                else if (i == 0) driven = true;
+                if (!driven)
+                {
+                    axle.DriveType = AxleDriveType.NotDriven;
+                    notDrivenAxle = true;
+                }
+            }
+            if (!notDrivenAxle)
+            {
+                var axle = new Axle(this);
+                axle.DriveType = AxleDriveType.NotDriven;
+                LocomotiveAxles.Add(axle);
+            }
+
             base.Initialize();
 
             // Create a steam engine block if none exits, typically for a MSTS or BASIC configuration
@@ -6718,7 +6747,7 @@ protected override void UpdateAxles(float elapsedClockSeconds)
             }
             foreach (var axle in LocomotiveAxles)
             {
-                axle.BrakeRetardForceN = BrakeRetardForceN / LocomotiveAxles.Count;
+                axle.BrakeRetardForceN = BrakeRetardForceN * axle.BrakeForceFraction;
                 axle.TrainSpeedMpS = SpeedMpS;                //Set the train speed of the axle mod
                 axle.WheelDistanceGaugeM = TrackGaugeM;
                 axle.CurrentCurveRadiusM = CurrentCurveRadiusM;

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

@@ -31,6 +31,7 @@
 using SharpDX.Direct3D9;
 using Orts.Formats.OR;
 using static Orts.Simulation.RollingStocks.SubSystems.PowerTransmissions.Axle;
+using MonoGame.Framework.Utilities.Deflate;
 
 namespace Orts.Simulation.RollingStocks.SubSystems.PowerTransmissions
 {
@@ -345,19 +346,32 @@ public void Copy(Axles other)
         public void Initialize()
         {
             ResetTime = Car.Simulator.GameTime;
+            int numForce = 0;
+            int numMotor = 0;
             foreach (var axle in AxleList)
             {
-                if (Car is MSTSLocomotive locomotive)
+                if (!(Car is MSTSLocomotive)) axle.DriveType = AxleDriveType.NotDriven;
+                else if (axle.DriveType == AxleDriveType.ForceDriven) numForce++;
+                else if (axle.DriveType == AxleDriveType.MotorDriven) numMotor++;
+            }
+            foreach (var axle in AxleList)
+            {
+                if (numMotor > 0 && axle.DriveType == AxleDriveType.ForceDriven) axle.DriveType = AxleDriveType.NotDriven;
+                else if (axle.DriveType == AxleDriveType.ForceDriven) axle.TractiveForceFraction = 1.0f / numForce;
+                else if (axle.DriveType == AxleDriveType.MotorDriven) axle.TractiveForceFraction = 1.0f / numMotor;
+                int numDriven = numMotor > 0 ? numMotor : numForce;
+                int numNotDriven = AxleList.Count - numDriven;
+                var locomotive = Car as MSTSLocomotive;
+                if (locomotive != null)
                 {
-                    if (axle.InertiaKgm2 <= 0) axle.InertiaKgm2 = locomotive.AxleInertiaKgm2 / AxleList.Count;
-                    if (axle.WheelWeightKg <= 0) axle.WheelWeightKg = locomotive.DrvWheelWeightKg / AxleList.Count;
-                    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.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;
-                    
+                    if (axle.DriveType != AxleDriveType.NotDriven)
+                    {
+                        axle.BrakeForceFraction = 1.0f / (locomotive.DriveWheelOnlyBrakes ? numDriven : AxleList.Count);
+                        if (axle.WheelWeightKg <= 0) axle.WheelWeightKg = locomotive.DrvWheelWeightKg / numDriven;
+                        if (axle.NumWheelsetAxles <= 0) axle.NumWheelsetAxles = locomotive.LocoNumDrvAxles / numDriven;
+                        if (axle.WheelRadiusM <= 0) axle.WheelRadiusM = locomotive.DriverWheelRadiusM;
+                    }
+
                     // set the wheel slip threshold times for different types of locomotives
                     // Because of the irregular force around the wheel for a steam engine during a revolution, "response" time for warnings needs to be lower
                     if (locomotive.EngineType == TrainCar.EngineTypes.Steam)
@@ -371,6 +385,23 @@ public void Initialize()
                         axle.WheelSlipWarningThresholdTimeS = 1;
                     }
                 }
+                if (axle.DriveType == AxleDriveType.NotDriven)
+                {
+                    var wagon = Car as MSTSWagon;
+                    axle.BrakeForceFraction = locomotive != null && locomotive.DriveWheelOnlyBrakes ? 0 :1.0f / AxleList.Count;
+                    if (axle.WheelWeightKg <= 0)
+                    {
+                        if (locomotive != null) axle.WheelWeightKg = Math.Max((Car.MassKG - locomotive.DrvWheelWeightKg) / numNotDriven, 500);
+                        else axle.WheelWeightKg = Car.MassKG / numNotDriven;
+                    }
+                    if (axle.NumWheelsetAxles <= 0) axle.NumWheelsetAxles = Math.Max(Car.GetWagonNumAxles() / numNotDriven, 1);
+                    if (axle.WheelRadiusM <= 0) axle.WheelRadiusM = wagon.WheelRadiusM;
+                }
+                if (axle.InertiaKgm2 <= 0) axle.InertiaKgm2 = (Car as MSTSWagon).AxleInertiaKgm2 / AxleList.Count;
+                if (axle.WheelFlangeAngleRad <= 0) axle.WheelFlangeAngleRad = Car.MaximumWheelFlangeAngleRad;
+                if (axle.AxleWeightN <= 0) axle.AxleWeightN = 9.81f * axle.WheelWeightKg;  //remains fixed for diesel/electric locomotives, but varies for steam locomotives
+                if (axle.DampingNs <= 0) axle.DampingNs = axle.WheelWeightKg / 1000.0f;
+                if (axle.FrictionN <= 0) axle.FrictionN = axle.WheelWeightKg / 1000.0f;
                 axle.Initialize();
             }
         }
@@ -529,6 +560,15 @@ public class Axle : ISubSystem<Axle>
     {
         public int NumOfSubstepsPS { get; set; }
 
+        /// <summary>
+        /// Contribution of this axle to the total tractive force
+        /// </summary>
+        public float TractiveForceFraction;
+        /// <summary>
+        /// Contribution of this axle to the total brake force
+        /// </summary>
+        public float BrakeForceFraction;
+
         /// <summary>
         /// Positive only brake force to the individual axle, in Newtons
         /// </summary>
@@ -1261,6 +1301,7 @@ void Integrate(float elapsedClockSeconds)
         public virtual void Update(float elapsedSeconds)
         {
             bool advancedAdhesion = Car is MSTSLocomotive locomotive && locomotive.AdvancedAdhesionModel;
+            advancedAdhesion &= DriveType != AxleDriveType.NotDriven; // Skip integrator for undriven axles to save CPU
             forceToAccelerationFactor = WheelRadiusM * WheelRadiusM / totalInertiaKgm2;
             if (!advancedAdhesion)
             {
@@ -1390,8 +1431,25 @@ public void UpdateSimpleAdhesion(float elapsedClockSeconds)
             if (Math.Abs(axleOutForceN) > maxAdhesionForceN)
             {
                 axleOutForceN = MathHelper.Clamp(axleOutForceN, -maxAdhesionForceN, maxAdhesionForceN);
-                if (Car is MSTSLocomotive locomotive && !locomotive.AntiSlip && locomotive.SlipControlSystem == MSTSLocomotive.SlipControlType.None) axleOutForceN *= locomotive.Adhesion1;
-                //else if (!(Car is MSTSLocomotive) && Car.Simulator.UseAdvancedAdhesion && !Car.Simulator.Settings.SimpleControlPhysics && Car.IsPlayerTrain) axleOutForceN = MathHelper.Clamp(axleOutForceN, -);
+                if (!Car.Simulator.UseAdvancedAdhesion || Car.Simulator.Settings.SimpleControlPhysics || !Car.Train.IsPlayerDriven)
+                {
+                    if (Car is MSTSLocomotive locomotive && !locomotive.AntiSlip) axleOutForceN *= locomotive.Adhesion1;
+                }
+                else
+                {
+                    float adhesionForceN;
+                    if ((TrainSpeedMpS > 0 && axleOutForceN < 0) || (TrainSpeedMpS < 0 && axleOutForceN > 0))
+                    {
+                        // Compute adhesion as if wheel is fully locked
+                        adhesionForceN = AxleWeightN * SlipCharacteristicsPacha(-TrainSpeedMpS, TrainSpeedMpS, AdhesionK, AdhesionLimit);
+                    }
+                    else
+                    {
+                        // Get asymptotic (dynamic) adhesion coefficient
+                        adhesionForceN = AxleWeightN * SlipCharacteristicsPacha(1000.0f, Math.Abs(TrainSpeedMpS), AdhesionK, AdhesionLimit);
+                    }
+                    axleOutForceN = MathHelper.Clamp(axleOutForceN, -adhesionForceN, adhesionForceN);
+                }
 
                 HuDIsWheelSlip = HuDIsWheelSlipWarning = IsWheelSlip = IsWheelSlipWarning = true;
 
@@ -1418,7 +1476,7 @@ public void UpdateSimpleAdhesion(float elapsedClockSeconds)
             }
             AxlePositionRad += AxleSpeedMpS / WheelRadiusM * elapsedClockSeconds;
 
-            if (Math.Abs(TrainSpeedMpS) < 0.001f && Math.Abs(axleInForceN) < frictionForceN)
+            if (Math.Abs(TrainSpeedMpS) < 0.001f && Math.Abs(axleInForceN) < totalFrictionForceN)
             {
                 axleOutForceN = 0;
             }

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

@@ -50,7 +50,7 @@ public override double GetDevelopedTorqueNm(double motorSpeedRadpS)
         }
         public override void Update(float timeSpan)
         {
-            TargetForceN = Locomotive.TractiveForceN / Locomotive.TractionMotors.Count;
+            TargetForceN = Locomotive.TractiveForceN * AxleConnected.TractiveForceFraction;
             EngineMaxSpeedMpS = Locomotive.MaxSpeedMpS;
             SlipControl = Locomotive.SlipControlSystem == MSTSLocomotive.SlipControlType.Full;
             float linToAngFactor = AxleConnected.TransmissionRatio / AxleConnected.WheelRadiusM;

Source/RunActivity/Viewer3D/RollingStock/MSTSWagonViewer.cs

@@ -467,13 +467,19 @@ void MatchMatrixToPart(MSTSWagon car, int matrix, int bogieMatrix)
             // Gate all RunningGearPartIndexes on this!
             var matrixAnimated = TrainCarShape.SharedShape.Animations != null && TrainCarShape.SharedShape.Animations.Count > 0 && TrainCarShape.SharedShape.Animations[0].anim_nodes.Count > matrix && TrainCarShape.SharedShape.Animations[0].anim_nodes[matrix].controllers.Count > 0;
             int? LinkedAxleIndex = null;
+            int? notDrivenAxleIndex = null;
+            int? drivenAxleIndex = null;
             for (int i=0; i<car.LocomotiveAxles.Count; i++)
             {
                 if (car.LocomotiveAxles[i].AnimatedParts.Contains(matrixName))
                 {
                     LinkedAxleIndex = i;
                     break;
                 }
+                // Do not attach parts to this axle by default if it contains a list of animated parts
+                if (car.LocomotiveAxles[i].AnimatedParts.Count > 0) continue;
+                if (notDrivenAxleIndex == null && car.LocomotiveAxles[i].DriveType == Simulation.RollingStocks.SubSystems.PowerTransmissions.AxleDriveType.NotDriven) notDrivenAxleIndex = i;
+                if (drivenAxleIndex == null && car.LocomotiveAxles[i].DriveType != Simulation.RollingStocks.SubSystems.PowerTransmissions.AxleDriveType.NotDriven) drivenAxleIndex = i;
             }
             if (matrixName.StartsWith("WHEELS") && (matrixName.Length == 7 || matrixName.Length == 8 || matrixName.Length == 9))
             {
@@ -492,9 +498,9 @@ void MatchMatrixToPart(MSTSWagon car, int matrix, int bogieMatrix)
                     if (matrixName.Length == 8 || matrixName.Length == 9)
                         Int32.TryParse(matrixName.Substring(6, 1), out id);
                     if (matrixName.Length == 8 || matrixName.Length == 9 || !matrixAnimated)
-                        WheelPartIndexes[LinkedAxleIndex ?? -1].Add(matrix);
+                        WheelPartIndexes[LinkedAxleIndex ?? notDrivenAxleIndex ?? drivenAxleIndex ?? -1].Add(matrix);
                     else
-                        RunningGears[LinkedAxleIndex ?? (car.LocomotiveAxles.Count > 0 ? 0 : -1)].AddMatrix(matrix);
+                        RunningGears[LinkedAxleIndex ?? drivenAxleIndex ?? -1].AddMatrix(matrix);
                     var pmatrix = TrainCarShape.SharedShape.GetParentMatrix(matrix);
                     car.AddWheelSet(m.Translation, id, pmatrix, matrixName.ToString(), bogie1Axles, bogie2Axles);
                 }
@@ -657,7 +663,7 @@ void MatchMatrixToPart(MSTSWagon car, int matrix, int bogieMatrix)
             else
             {
                 if (matrixAnimated && matrix != 0)
-                    RunningGears[LinkedAxleIndex ?? (car.LocomotiveAxles.Count > 0 ? 0 : -1)].AddMatrix(matrix);
+                    RunningGears[LinkedAxleIndex ?? drivenAxleIndex ?? -1].AddMatrix(matrix);
 
                 for (var i = 0; i < TrainCarShape.Hierarchy.Length; i++)
                     if (TrainCarShape.Hierarchy[i] == matrix)
@@ -802,18 +808,16 @@ public override void PrepareFrame(RenderFrame frame, ElapsedTime elapsedTime)
 
         private void UpdateAnimation(RenderFrame frame, ElapsedTime elapsedTime)
         {
-                        
-            float distanceTravelledM = 0.0f; // Distance travelled by non-driven wheels
+            float distanceTravelledM; // Distance travelled by non-driven wheels
             float AnimationWheelRadiusM = MSTSWagon.WheelRadiusM; // Radius of non driven wheels
             float AnimationDriveWheelRadiusM = MSTSWagon.DriverWheelRadiusM; // Radius of driven wheels
 
-            if (MSTSWagon is MSTSLocomotive loco && loco.AdvancedAdhesionModel)
+            if (MSTSWagon is MSTSLocomotive loco)
             {
                 //TODO: next code line has been modified to flip trainset physics in order to get viewing direction coincident with loco direction when using rear cab.
                 // To achieve the same result with other means, without flipping trainset physics, the line should be changed as follows:
-                //                                distanceTravelledM = MSTSWagon.WheelSpeedMpS * elapsedTime.ClockSeconds;
-                distanceTravelledM = ((MSTSWagon.Train != null && MSTSWagon.Train.IsPlayerDriven && loco.UsingRearCab) ? -1 : 1) * MSTSWagon.WheelSpeedMpS * elapsedTime.ClockSeconds;
-                if (Car.BrakeSkid && !loco.DriveWheelOnlyBrakes) distanceTravelledM = 0;
+                //                                distanceTravelledM = MSTSWagon.SpeedMpS * elapsedTime.ClockSeconds;
+                distanceTravelledM = ((MSTSWagon.Train != null && MSTSWagon.Train.IsPlayerDriven && loco.UsingRearCab) ? -1 : 1) * MSTSWagon.SpeedMpS * elapsedTime.ClockSeconds;
                 foreach (var kvp in RunningGears)
                 {
                     if (!kvp.Value.Empty())
@@ -829,28 +833,27 @@ private void UpdateAnimation(RenderFrame frame, ElapsedTime elapsedTime)
                 }
                 foreach (var kvp in WheelPartIndexes)
                 {
-                    var axle = kvp.Key < loco.LocomotiveAxles.Count && kvp.Key >= 0 ? loco.LocomotiveAxles[kvp.Key] : (Car.EngineType == TrainCar.EngineTypes.Steam ? null : loco.LocomotiveAxles[0]);
-                    Matrix wheelRotationMatrix;
+                    var axle = kvp.Key < loco.LocomotiveAxles.Count && kvp.Key >= 0 ? loco.LocomotiveAxles[kvp.Key] : null;
                     if (axle != null)
                     {
                         //TODO: next code line has been modified to flip trainset physics in order to get viewing direction coincident with loco direction when using rear cab.
-                        wheelRotationMatrix = Matrix.CreateRotationX(((MSTSWagon.Train != null && MSTSWagon.Train.IsPlayerDriven && loco.UsingRearCab) ? -1 : 1) * -(float)axle.AxlePositionRad);
+                        WheelRotationR = ((MSTSWagon.Train != null && MSTSWagon.Train.IsPlayerDriven && loco.UsingRearCab) ? -1 : 1) * -(float)axle.AxlePositionRad;
                     }
                     else
                     {
                         var rotationalDistanceR = distanceTravelledM / AnimationWheelRadiusM;  // in radians
                         WheelRotationR = MathHelper.WrapAngle(WheelRotationR - rotationalDistanceR);
-                        wheelRotationMatrix = Matrix.CreateRotationX(WheelRotationR);
                     }
+                    Matrix wheelRotationMatrix = Matrix.CreateRotationX(WheelRotationR);
                     foreach (var iMatrix in kvp.Value)
                     {
                         TrainCarShape.XNAMatrices[iMatrix] = wheelRotationMatrix * TrainCarShape.SharedShape.Matrices[iMatrix];
                     }
                 }
             }
-            else // set values for simple adhesion
+            else // set values for wagons (not handled by Axle class)
             {
-                distanceTravelledM = ((MSTSWagon.IsDriveable && MSTSWagon.Train != null && MSTSWagon.Train.IsPlayerDriven && ((MSTSLocomotive)MSTSWagon).UsingRearCab) ? -1 : 1) * MSTSWagon.SpeedMpS * elapsedTime.ClockSeconds;
+                distanceTravelledM = MSTSWagon.SpeedMpS * elapsedTime.ClockSeconds;
                 if (Car.BrakeSkid) distanceTravelledM = 0;
                 foreach (var kvp in RunningGears)
                 {