Merge pull request #627 from cesarBLG/enhance-adhesion

Improve advanced adhesion model

Author: cjakeman

Source/Documentation/Manual/physics.rst

@@ -313,31 +313,33 @@ the *Axle brake force*. The *Axle out force* is the output force of
 the adhesion model (used to pull the train). To compute the model
 correctly the FPS rate needs to be divided by a *Solver dividing* value
 in a range from 1 to 50. By default, the Runge-Kutta4 solver is used to
-obtain the best results. When the *Solver dividing* value is higher than
-40, in order to reduce CPU load the Euler-modified solver is used instead.
+obtain the best results.
 
 In some cases when the CPU load is high, the time step for the computation
 may become very high and the simulation may start to oscillate (the
-*Wheel slip* rate of change (in the brackets) becomes very high). There
-is a stability correction feature that modifies the dynamics of the
-adhesion characteristics. Higher instability can cause a huge wheel slip.
+*Wheel slip* rate of change (in the brackets) becomes very high).
 You can use the ``DebugResetWheelSlip`` (``<Ctrl+X>`` keys by default)
 command to reset the adhesion model. If you experience such behavior most
 of time, use the basic adhesion model instead by pressing
 ``DebugToggleAdvancedAdhesion`` ( ``<Ctrl+Alt+X>`` keys by default).
 
-Another option is to use a Moving average filter available in the
-:ref:`Simulation Options <options-simulation>`. The higher the value,
-the more stable the simulation will be. However, the higher value causes
-slower dynamic response. The recommended range is between 10 and 50.
-
 .. index::
    single: ORTSWheelSlipCausesThrottleDown
 
 To match some of the real world features, the *Wheel slip* event can
 cause automatic zero throttle setting. Use the ``Engine (ORTS
 (ORTSWheelSlipCausesThrottleDown))`` Boolean value of the ENG file.
 
+.. index::
+   single: ORTSSlipControlSystem
+   
+Modern locomotives have slip control systems which automatically adjust
+power, providing an optimal tractive effort avoiding wheel slip. 
+The ``ORTSSlipControlSystem ( Full )``  parameter can be inserted
+into the engine section of the .eng file to indicate the presence of
+such system.
+
+
 Engine -- Classes of Motive Power
 =================================
 
@@ -940,6 +942,20 @@ auxiliary systems can be adjusted by the optional parameter
 A :ref:`scripting interface <features-scripting-powersupply>` to customize the
 behavior of the power supply is also available.
 
+Traction motor type
+'''''''''''''''''''
+
+.. index::
+   single: ORTSTractionMotorType
+
+There are different types of electric motors: series DC motors,
+asynchronous/synchronous AC motors, etc.
+Currently a simple AC induction motor has been implemented, and can be selected
+with the ``ORTSTractionMotorType ( AC ) `` parameter, to be inserted in the Engine
+section of the ENG file. The use of this motor will have an impact on wheel slip,
+because the wheel speed never exceeds the frequency of the rotating magnetic field.
+
+
 Steam Locomotives
 -----------------
 

Source/ORTS.Common/Integrator.cs

@@ -194,7 +194,7 @@ public void Reset()
         /// <param name="timeSpan">Integration step or timespan in seconds</param>
         /// <param name="value">Value to integrate</param>
         /// <returns>Value of integration in the next step (t + timeSpan)</returns>
-        public float Integrate(float timeSpan, float value)
+        public float Integrate(float timeSpan, Func<float, float> value)
         {
             float step = 0.0f;
             float end = timeSpan;
@@ -207,43 +207,28 @@ public float Integrate(float timeSpan, float value)
             {
                 return integralValue;
             }
-
-            //if (timeSpan > MinStep)
             if (Math.Abs(prevDerivation) > Error)
             {
-                //count = 2 * Convert.ToInt32(Math.Round((timeSpan) / MinStep, 0));
                 count = ++numOfSubstepsPS;
                 if (count > MaxSubsteps)
                     count = MaxSubsteps;
                 waitBeforeSpeedingUp = 100;
-                //if (numOfSubstepsPS > (MaxSubsteps / 2))
-                //    Method = IntegratorMethods.EulerBackMod;
-                //else
-                //    Method = IntegratorMethods.RungeKutta4;
             }
             else
             {
                 if (--waitBeforeSpeedingUp <= 0)    //wait for a while before speeding up the integration
                 {
-                    count = --numOfSubstepsPS;
-                    if (count < 1)
-                        count = 1;
+                    count = Math.Max(--numOfSubstepsPS, 1);
 
                     waitBeforeSpeedingUp = 10;      //not so fast ;)
                 }
                 else
                     count = numOfSubstepsPS;
-                //IsStepDividing = false;
             }
 
             timeSpan = timeSpan / (float)count;
-            IsStepDividing = true;
             numOfSubstepsPS = count;
-
-            if (count > 1)
-                IsStepDividing = true;
-            else
-                IsStepDividing = false;
+            IsStepDividing = count > 1;
 
 
             #region SOLVERS
@@ -253,28 +238,26 @@ public float Integrate(float timeSpan, float value)
                 switch (Method)
                 {
                     case IntegratorMethods.EulerBackward:
-                        integralValue += (derivation = timeSpan * value);
+                        integralValue += (derivation = timeSpan * value(integralValue));
                         break;
                     case IntegratorMethods.EulerBackMod:
-                        integralValue += (derivation = timeSpan / 2.0f * (previousValues[0] + value));
-                        previousValues[0] = value;
+                        integralValue += (derivation = timeSpan / 2.0f * (previousValues[0] + value(integralValue)));
+                        previousValues[0] = value(integralValue);
                         break;
                     case IntegratorMethods.EulerForward:
                         throw new NotImplementedException("Not implemented yet!");
 
                     case IntegratorMethods.RungeKutta2:
-                        //throw new NotImplementedException("Not implemented yet!");
-                        k1 = integralValue + timeSpan / 2 * value;
+                        k1 = integralValue + timeSpan / 2 * value(integralValue);
                         k2 = 2 * (k1 - integralValue) / timeSpan;
                         integralValue += (derivation = timeSpan * k2);
                         break;
                     case IntegratorMethods.RungeKutta4:
-                        //throw new NotImplementedException("Not implemented yet!");
-                        k1 = timeSpan * value;
-                        k2 = k1 + timeSpan / 2.0f * value;
-                        k3 = k1 + timeSpan / 2.0f * k2;
-                        k4 = timeSpan * k3;
-                        integralValue += (derivation = (k1 + 2.0f * k2 + 2.0f * k3 + k4) / 6.0f);
+                        k1 = value(integralValue);
+                        k2 = value(integralValue + k1 * timeSpan / 2.0f);
+                        k3 = value(integralValue + k2 * timeSpan / 2.0f);
+                        k4 = value(integralValue + k3 * timeSpan);
+                        integralValue += (derivation = (k1 + 2.0f * k2 + 2.0f * k3 + k4) * timeSpan / 6.0f);
                         break;
                     case IntegratorMethods.NewtonRhapson:
                         throw new NotImplementedException("Not implemented yet!");
@@ -289,7 +272,7 @@ public float Integrate(float timeSpan, float value)
                             previousStep[i] = previousStep[i - 1];
                             previousValues[i] = previousValues[i - 1];
                         }
-                        previousValues[0] = value;
+                        previousValues[0] = value(integralValue);
                         previousStep[0] = timeSpan;
                         break;
                     default:
@@ -313,24 +296,6 @@ public float Integrate(float timeSpan, float value)
             else
                 return integralValue;
         }
-        /// <summary>
-        /// Integrates given value in time. TimeSpan (integration step) is computed internally.
-        /// </summary>
-        /// <param name="clockSeconds">Time value in seconds</param>
-        /// <param name="value">Value to integrate</param>
-        /// <returns>Value of integration in elapsedClockSeconds time</returns>
-        public float TimeIntegrate(float clockSeconds, float value)
-        {
-            float timeSpan = clockSeconds - oldTime;
-            oldTime = clockSeconds;
-            integralValue += timeSpan * value;
-            if (isLimited)
-            {
-                return (integralValue <= min) ? min : ((integralValue >= max) ? max : integralValue);
-            }
-            else
-                return integralValue;
-        }
 
         public void Save(BinaryWriter outf)
         {

Source/Orts.Simulation/Orts.Simulation.csproj

@@ -195,6 +195,7 @@
     <Compile Include="Simulation\Turntables.cs" />
     <Compile Include="Simulation\Weather.cs" />
     <Compile Include="Common\Scripting\EuropeanTrainControlSystem.cs" />
+    <Compile Include="Simulation\RollingStocks\SubSystems\PowerTransmissions\InductionMotor.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\ORTS.Common\ORTS.Common.csproj">

Source/Orts.Simulation/Simulation/AIs/AITrain.cs

@@ -6298,8 +6298,6 @@ public bool SwitchToPlayerControl()
                 {
                     var loco = car as MSTSLocomotive;
                     loco.LocomotiveAxle.Reset(Simulator.GameTime, SpeedMpS);
-                    loco.LocomotiveAxle.AxleSpeedMpS = SpeedMpS;
-                    loco.LocomotiveAxle.FilterMovingAverage.Initialize(loco.AverageForceN);
                     loco.AntiSlip = false; // <CSComment> TODO Temporary patch until AntiSlip is re-implemented
                 }
                 if (car == Simulator.PlayerLocomotive) { leadLocomotiveIndex = j; }

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

@@ -397,6 +397,8 @@ public override void LoadFromWagFile(string wagFilePath)
                     var dropoffspeed = calculatedmaximumpowerw / (MaxForceN);
                     var configuredadhesiondropoffspeed = (Curtius_KnifflerA / (dropoffspeed + Curtius_KnifflerB) + Curtius_KnifflerC);
 
+                    Trace.TraceInformation("Slip control system: {0}, Traction motor type: {1}", SlipControlSystem.ToString(), TractionMotorType.ToString()); // Slip control
+
                     Trace.TraceInformation("Apparent (Design) Adhesion: Zero - {0:N2} @ {1}, Max Continuous Speed - {2:N2} @ {3}, Drive Wheel Weight - {4}", designadhesionzerospeed, FormatStrings.FormatSpeedDisplay(zerospeed, IsMetric), designadhesionmaxcontspeed, FormatStrings.FormatSpeedDisplay(SpeedOfMaxContinuousForceMpS, IsMetric), FormatStrings.FormatMass(DrvWheelWeightKg, IsMetric));
                     Trace.TraceInformation("OR Calculated Adhesion Setting: Zero Speed - {0:N2} @ {1}, Dropoff Speed - {2:N2} @ {3}, Max Continuous Speed - {4:N2} @ {5}", configuredadhesionzerospeed, FormatStrings.FormatSpeedDisplay(zerospeed, IsMetric), configuredadhesiondropoffspeed, FormatStrings.FormatSpeedDisplay(dropoffspeed, IsMetric), configuredadhesionmaxcontinuousspeed, FormatStrings.FormatSpeedDisplay(SpeedOfMaxContinuousForceMpS, IsMetric));
                 }
@@ -669,13 +671,25 @@ protected override void UpdateTractiveForce(float elapsedClockSeconds, float t,
                 // its impact. More modern locomotive have a more sophisticated system that eliminates slip in the majority (if not all circumstances).
                 // Simple adhesion control does not have any slip control feature built into it.
                 // TODO - a full review of slip/no slip control.
-                if (WheelSlip && AdvancedAdhesionModel)
+                if (TractionMotorType == TractionMotorTypes.AC)
                 {
-                    AbsTractionSpeedMpS = AbsWheelSpeedMpS;
+                    AbsTractionSpeedMpS = AbsSpeedMpS;
+                    if (AbsWheelSpeedMpS > 1.1 * MaxSpeedMpS)
+                    {
+                        AverageForceN = TractiveForceN = 0;
+                        return;
+                    }
                 }
                 else
                 {
-                    AbsTractionSpeedMpS = AbsSpeedMpS;
+                    if (WheelSlip && AdvancedAdhesionModel)
+                    {
+                        AbsTractionSpeedMpS = AbsWheelSpeedMpS;
+                    }
+                    else
+                    {
+                        AbsTractionSpeedMpS = AbsSpeedMpS;
+                    }
                 }
 
                 if (TractiveForceCurves == null)