Merge pull request #1015 from cesarBLG/electrical-braking-enhancement

Enhancements for EP brakes

Author: cesarBLG

Source/Documentation/Manual/physics.rst

@@ -2590,6 +2590,10 @@ behave exactly the same way as player controlled ones.
 
 .. _physics-braking:
 
+.. index::
+   single: BrakeSystemType
+   single: BrakeEquipmentType
+
 Open Rails Braking
 ==================
 
@@ -2627,13 +2631,15 @@ graduated release. It will also force graduated release of brakes in triple
 valves. This option should be unchecked, except for compatibility problems
 with old MSTS stock.
 
-The following brake types are implemented in OR:
+The following brake types are implemented in OR. They can be selected using
+the ``Wagon(BrakeSystemType`` parameter:
 
-- Vacuum single
-- Air single-pipe
-- Air twin-pipe
-- EP (Electro-pneumatic)
-- Single-transfer-pipe (air and vacuum)
+- Vacuum single pipe: ``BrakeSystemType ("Vacuum_single_pipe")``
+- Air single-pipe: ``BrakeSystemType ("Air_single_pipe")``
+- Air twin-pipe: ``BrakeSystemType ("Air_twin_pipe")``
+- EP (Electro-pneumatic, twin-pipe): ``BrakeSystemType ("EP")``
+- EP single-pipe: ``BrakeSystemType ("EP_single_pipe")``
+- Single-transfer-pipe (air and vacuum): ``BrakeSystemType ("Air_piped")`` or ``BrakeSystemType ("Vacuum_piped")``
 
 The operation of air single-pipe brakes is described in general below.
 
@@ -2658,17 +2664,19 @@ brake features.
 For EP brakes, two variants are available:
 
 - If ``Wagon(ORTSEPBrakeControlsBrakePipe`` is set to 0 (default situation),
-an electrical wire (application wire) provides simultaneous fast brake application
-along the train. Release time will be fast if standard air brake haven't been applied,
-otherwise air brakes will determine release time. Typically this system is present
-with Train Brake Controllers having an EP-only application section, followed by an
-air application portion which serves as a fallback system.
+  an electrical wire (application wire) provides simultaneous fast brake application
+  along the train. Release time will be fast if standard air brake haven't been applied,
+  otherwise air brakes will determine release time. Typically this system is present
+  with Train Brake Controllers having an EP-only application section, followed by an
+  air application portion which serves as a fallback system, or in combination with a
+  solenoid valve that isolates the triple valve when EP brakes are operational.
+
 - If ``Wagon(ORTSEPBrakeControlsBrakePipe`` is set to 1, brake pipe is charged and discharged
-simultaneously at each car in the train, providing fast and uniform brake application and release.
-The locomotive instructs the cars to "charge" or "discharge" the brake pipe to reach
-a reference pressure. Standard triple valves or distributors will follow brake pipe variations
-actuating the cylinders. This system is sometimes called "UIC EP brake". It is typically the system
-used in high speed trains.
+  simultaneously at each car in the train, providing fast and uniform brake application and release.
+  The locomotive instructs the cars to "charge" or "discharge" the brake pipe to reach
+  a reference pressure. Standard triple valves or distributors will follow brake pipe variations
+  actuating the cylinders. This system is sometimes called "UIC EP brake". It is typically the system
+  used in high speed trains.
 
 .. _physics-brake-controller:
 
@@ -3380,10 +3388,12 @@ MaxAuxilaryChargingRate and EmergencyResChargingRate.
    single: ORTSBrakeEmergencyTimeFactor
    single: ORTSBrakePipeTimeFactor
    single: ORTSEPBrakeControlsBrakePipe
+   single: ORTSEPBrakeInhibitsTripleValve
    single: ORTSCompressorIsMuControlled
    single: Supply_Reservoir
    single: ORTSSupplyResCapacity
    single: ORTSSupplyResChargingRate
+   single: Emergency_Solenoid_Valve
 
 - ``Wagon(BrakePipeVolume`` -- Volume of car's brake pipe in cubic feet
   (default .5).
@@ -3456,6 +3466,8 @@ MaxAuxilaryChargingRate and EmergencyResChargingRate.
   by the brake system.
 - ``Wagon(ORTSEPBrakeControlsBrakePipe`` -- Set to 1 for UIC EP brake: brake pipe
   pressure is electrically controlled at every fitted car.
+- ``Wagon(ORTSEPBrakeInhibitsTripleValve`` -- Set to 1 if the car is fitted with a
+  selector valve that ignores brake pipe pressure when EP brakes are operational.
 - ``Wagon(ORTSBrakeRelayValveRatio`` -- Determines the proportionality constant
   between pressure as demanded by the triple valve and brake cylinder pressure.
   This is achieved via a relay valve which sets BC pressure proportionally.
@@ -3534,7 +3546,7 @@ MaxAuxilaryChargingRate and EmergencyResChargingRate.
 - ``Wagon(ORTSInitialApplicationThreshold`` -- The pressure difference between
   the brake pipe and auxiliary reservoir at which the triple valve will
   change from release to apply (default 1 psi).
-- ``BrakeEquipmentType(Supply_Reservoir`` -- Adds a supply reservoir to the
+- ``Wagon(BrakeEquipmentType(Supply_Reservoir`` -- Adds a supply reservoir to the
   loco or wagon, which will constantly charge to the brake pipe pressure
   or MR pipe (if equipped) pressure. If a supply reservoir is equipped,
   supply res air will be used to pressurize the brake cylinders thru the relay
@@ -3571,6 +3583,10 @@ MaxAuxilaryChargingRate and EmergencyResChargingRate.
   Pipe for twin pipe braking systems (default = Main Reservoir Pressure).
 - ``Engine(ORTSCompressorIsMuControlled`` -- Set to 1 if compressors from
   all locomotives are synchronized.
+- ``Wagon(BrakeEquipmentType(Emergency_Solenoid_Valve`` -- Adds an
+  electrically controlled valve that quickly applies maximum
+  brake cylinder pressure during an emergency braking. Only available if the
+  brake cylinder pressure is controlled using a relay valve.
 
 .. _physics-retainers:
 

Source/Orts.Simulation/Simulation/Physics/Train.cs

@@ -4040,7 +4040,7 @@ public virtual void InitializeBrakes()
             if (Simulator.Settings.VerboseConfigurationMessages && LeadLocomotiveIndex >= 0) // Check incompatibilities between brake control valves
             {
                 MSTSLocomotive lead = (MSTSLocomotive)Cars[LeadLocomotiveIndex];
-                if (Cars.Any(x => (x as MSTSWagon).BrakeValve != lead.BrakeValve))
+                if (lead.BrakeSystem is AirSinglePipe leadBrakes && Cars.Any(x => x.BrakeSystem is AirSinglePipe carBrakes && leadBrakes.BrakeValve != carBrakes.BrakeValve))
                 {
                     Trace.TraceInformation("Cars along the train have incompatible brake control valves");
                 }
@@ -4069,17 +4069,17 @@ public void UnconditionalInitializeBrakes()
                                 car.MSTSBrakeSystem = new VacuumSinglePipe(car);
                             else if (lead.BrakeSystem is AirTwinPipe)
                                 car.MSTSBrakeSystem = new AirTwinPipe(car);
-                            else if (lead.BrakeSystem is AirSinglePipe)
+                            else if (lead.BrakeSystem is AirSinglePipe leadAir)
                             {
                                 car.MSTSBrakeSystem = new AirSinglePipe(car);
                                 // if emergency reservoir has been set on lead locomotive then also set on trailing cars
-                                if (lead.EmergencyReservoirPresent)
+                                if (leadAir.EmergencyReservoirPresent)
                                 {
-                                    car.EmergencyReservoirPresent = lead.EmergencyReservoirPresent;
+                                    (car.BrakeSystem as AirSinglePipe).EmergencyReservoirPresent = leadAir.EmergencyReservoirPresent;
                                 }
                             }
-                            else if (lead.BrakeSystem is EPBrakeSystem)
-                                car.MSTSBrakeSystem = new EPBrakeSystem(car);
+                            else if (lead.BrakeSystem is EPBrakeSystem ep)
+                                car.MSTSBrakeSystem = new EPBrakeSystem(car, ep.TwoPipes);
                             else if (lead.BrakeSystem is SingleTransferPipe)
                                 car.MSTSBrakeSystem = new SingleTransferPipe(car);
                             else

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

@@ -1738,7 +1738,7 @@ public override void Initialize()
             }
 
             // MaximumMainReservoirPipePressurePSI is only used in twin pipe system, and should have a value
-            if ((BrakeSystem is AirTwinPipe))
+            if (BrakeSystem is AirSinglePipe air && air.TwoPipes)
             {
 
                 // for airtwinpipe system, make sure that a value is set for it

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

@@ -236,51 +236,13 @@ public enum WindowState
         public float BearingHotBoxSmokeDurationS;
         public float BearingHotBoxSmokeVelocityMpS = 15.0f;
         public Color BearingHotBoxSmokeSteadyColor = Color.Gray;
-
-        /// <summary>
-        /// True if vehicle is equipped with an additional emergency brake reservoir
-        /// </summary>
-        public bool EmergencyReservoirPresent;
-        public enum BrakeValveType
-        {
-            None,
-            TripleValve, // Plain triple valve
-            Distributor, // Triple valve with graduated release
-            DistributingValve, // Triple valve + driver brake valve control. Only for locomotives
-        }
-        /// <summary>
-        /// Type of brake valve in the car
-        /// </summary>
-        public BrakeValveType BrakeValve;
-        /// <summary>
-        /// True if equipped with handbrake. (Not common for older steam locomotives.)
-        /// </summary>
-        public bool HandBrakePresent;
-        /// <summary>
-        /// Number of available retainer positions. (Used on freight cars, mostly.) Might be 0, 3 or 4.
-        /// </summary>
-        public int RetainerPositions;
-
-         /// <summary>
-        /// Indicates whether a brake is present or not when Manual Braking is selected.
-        /// </summary>
-        public bool ManualBrakePresent;
+        List<string> BrakeEquipment = new List<string>();
 
         /// <summary>
         /// Indicates whether a non auto (straight) brake is present or not when braking is selected.
         /// </summary>
         public bool NonAutoBrakePresent;
 
-        /// <summary>
-        /// Indicates whether an auxiliary reservoir is present on the wagon or not.
-        /// </summary>
-        public bool AuxiliaryReservoirPresent;
-
-        /// <summary>
-        /// Indicates whether an additional supply reservoir is present on the wagon or not.
-        /// </summary>
-        public bool SupplyReservoirPresent;
-
         /// <summary>
         /// Active locomotive for a control trailer
         /// </summary>
@@ -1372,30 +1334,11 @@ public virtual void Parse(string lowercasetoken, STFReader stf)
                 case "wagon(brakesystemtype":
                     CarBrakeSystemType = stf.ReadStringBlock(null).ToLower();
                     BrakeSystem = MSTSBrakeSystem.Create(CarBrakeSystemType, this);
+                    MSTSBrakeSystem?.SetBrakeEquipment(BrakeEquipment);
                     break;
                 case "wagon(brakeequipmenttype":
-                    foreach (var equipment in stf.ReadStringBlock("").ToLower().Replace(" ", "").Split(','))
-                    {
-                        switch (equipment)
-                        {
-                            case "triple_valve": BrakeValve = BrakeValveType.TripleValve; break;
-                            case "distributor":
-                            case "graduated_release_triple_valve": BrakeValve = BrakeValveType.Distributor; break;
-                            case "distributing_valve": BrakeValve = BrakeValveType.DistributingValve; break;
-                            case "emergency_brake_reservoir": EmergencyReservoirPresent = true; break;
-                            case "handbrake": HandBrakePresent = true; break;
-                            case "auxilary_reservoir": // MSTS legacy parameter - use is discouraged
-                            case "auxiliary_reservoir":
-                                AuxiliaryReservoirPresent = true;
-                                break;
-                            case "manual_brake": ManualBrakePresent = true; break;
-                            case "retainer_3_position": RetainerPositions = 3; break;
-                            case "retainer_4_position": RetainerPositions = 4; break;
-                            case "supply_reservoir":
-                                SupplyReservoirPresent = true;
-                                break;
-                        }
-                    }
+                    BrakeEquipment = stf.ReadStringBlock("").ToLower().Replace(" ", "").Split(',').ToList();
+                    MSTSBrakeSystem?.SetBrakeEquipment(BrakeEquipment);
                     break;
                 case "wagon(coupling":
                     Couplers.Add(new MSTSCoupling()); // Adds a new coupler every time "Coupler" parameters found in WAG and INC file
@@ -1739,13 +1682,6 @@ public virtual void Copy(MSTSWagon copy)
             IsGreaseFrictionBearing = copy.IsGreaseFrictionBearing;
             CarBrakeSystemType = copy.CarBrakeSystemType;
             BrakeSystem = MSTSBrakeSystem.Create(CarBrakeSystemType, this);
-            EmergencyReservoirPresent = copy.EmergencyReservoirPresent;
-            BrakeValve = copy.BrakeValve;
-            HandBrakePresent = copy.HandBrakePresent;
-            ManualBrakePresent = copy.ManualBrakePresent;
-            AuxiliaryReservoirPresent = copy.AuxiliaryReservoirPresent;
-            SupplyReservoirPresent = copy.SupplyReservoirPresent;
-            RetainerPositions = copy.RetainerPositions;
             InteriorShapeFileName = copy.InteriorShapeFileName;
             InteriorSoundFileName = copy.InteriorSoundFileName;
             Cab3DShapeFileName = copy.Cab3DShapeFileName;
@@ -1817,7 +1753,7 @@ public virtual void Copy(MSTSWagon copy)
                         IntakePointList.Add(new IntakePoint(copyIntakePoint));
                 }
             }
-
+            BrakeEquipment = new List<string>(BrakeEquipment);
             MSTSBrakeSystem.InitializeFromCopy(copy.BrakeSystem);
             if (copy.WeightLoadController != null) WeightLoadController = new MSTSNotchController(copy.WeightLoadController);