private static void ApplyBrakingForce(BrakeSystem car, ExtraBrakeState state)
{
var cylinderBrakingFactor = Mathf.InverseLerp(Main.settings.returnSpringStrength, Constants.FullApplicationPressure, state.cylinderPressure);
var mechanicalBrakingFactor = GetMechanicalBrakeFactor(car);
car.brakingFactor = Mathf.Max(mechanicalBrakingFactor, cylinderBrakingFactor);
}
public override string GetFullStatus(BrakeSystem lastCarBrakeSystem, Dictionary <BrakeSystemComponent, PressureUnit> units)
{
// display differently depending upon whether vacuum or air braked system
if (Car.CarBrakeSystemType == "vacuum_piped")
{
var s = $" {Simulator.Catalog.GetString("V")} {FormatStrings.FormatPressure(Car.Train.EqualReservoirPressurePSIorInHg, PressureUnit.InHg, PressureUnit.InHg, true)}";
if (lastCarBrakeSystem != null && lastCarBrakeSystem != this)
{
s += $" {Simulator.Catalog.GetString("EOT")} {lastCarBrakeSystem.GetStatus(units)}";
}
if (HandbrakePercent > 0)
{
s += $" {Simulator.Catalog.GetString("Handbrake")} {HandbrakePercent:F0}%";
}
return(s);
}
else // air braked by default
{
var s = $"{Simulator.Catalog.GetString("BP")} {FormatStrings.FormatPressure(BrakeLine1PressurePSI, PressureUnit.PSI, units[BrakeSystemComponent.BrakePipe], false)}";
if (lastCarBrakeSystem != null && lastCarBrakeSystem != this)
{
s += $" {Simulator.Catalog.GetString("EOT")} {lastCarBrakeSystem.GetStatus(units)}";
}
if (HandbrakePercent > 0)
{
s += $" {Simulator.Catalog.GetString("Handbrake")} {HandbrakePercent:F0}%";
}
return(s);
}
}
public override CarPart.CarPart Create()
{
var rearSuspension = new Suspension(
type: GetRandomSuspensionType(),
cost: randomGenerator.GetRandomValueInRange(40000, 100000),
manufacturer: GetRandomManufacturer());
var frontSuspension = new Suspension(
type: GetRandomSuspensionType(),
cost: randomGenerator.GetRandomValueInRange(40000, 100000),
manufacturer: GetRandomManufacturer());
var drivetrain = new Drivetrain(
cost: randomGenerator.GetRandomValueInRange(30000, 100000),
type: GetRandomDrivetrainType(),
manufacturer: GetRandomManufacturer());
var steeringPowerType = GetRandomSteeringPowerType();
var brakeSystem = new BrakeSystem(
type: GetRandomBrakesType(),
cost: randomGenerator.GetRandomValueInRange(10000, 50000),
manufacturer: GetRandomManufacturer());
return(new Chassis(
manufacturer: GetRandomManufacturer(),
brakeSystem: brakeSystem,
drivetrain: drivetrain,
rearSuspension: rearSuspension,
frontSuspension: frontSuspension,
steeringPowerType: steeringPowerType,
wheels: new Wheel(
cost: randomGenerator.GetRandomValueInRange(10000, 30000),
manufacturer: GetRandomManufacturer())));
}
public override string GetFullStatus(BrakeSystem lastCarBrakeSystem, Dictionary <BrakeSystemComponent, Pressure.Unit> units)
{
// display differently depending upon whether vacuum or air braked system
if (Car.CarBrakeSystemType == "vacuum_piped")
{
string s = string.Format(" V {0}", FormatStrings.FormatPressure(Car.Train.EqualReservoirPressurePSIorInHg, Pressure.Unit.InHg, Pressure.Unit.InHg, true));
if (lastCarBrakeSystem != null && lastCarBrakeSystem != this)
{
s += " EOT " + lastCarBrakeSystem.GetStatus(units);
}
if (HandbrakePercent > 0)
{
s += string.Format(" Handbrake {0:F0}%", HandbrakePercent);
}
return(s);
}
else // air braked by default
{
var s = string.Format("BP {0}", FormatStrings.FormatPressure(BrakeLine1PressurePSI, Pressure.Unit.PSI, units[BrakeSystemComponent.BrakePipe], false));
if (lastCarBrakeSystem != null && lastCarBrakeSystem != this)
{
s += " EOT " + lastCarBrakeSystem.GetStatus(units);
}
if (HandbrakePercent > 0)
{
s += string.Format(" Handbrake {0:F0}%", HandbrakePercent);
}
return(s);
}
}
public Motorcycle(bool kickstart, BrakeSystem brakes, string title, string description, double price, int mileage, string make, string model) : base(title, description, price, mileage, make, model)
{
KickStart = kickstart;
Brakes = brakes;
Title += " (MotorCycle)";
}
public override void InitializeFromCopy(BrakeSystem copy)
{
ManualBraking thiscopy = (ManualBraking)copy;
ManualMaxApplicationRateValuepS = thiscopy.ManualMaxApplicationRateValuepS;
ManualReleaseRateValuepS = thiscopy.ManualReleaseRateValuepS;
}
private static float GetMechanicalBrakeFactor(BrakeSystem car)
{
if (car.hasIndependentBrake && !car.hasCompressor) // Caboose only
{
return(car.independentBrakePosition);
}
return(0f);
}
private static void UpdateBrakePipeGauge(BrakeSystem car, ExtraBrakeState state)
{
// AirBrake.DebugLog(car, $"before: BP={ExtraBrakeState.Instance(car).brakePipePressureUnsmoothed}, gauge={car.brakePipePressure}, vel={car.brakePipePressureRef}");
car.brakePipePressure = Mathf.SmoothDamp(
car.brakePipePressure,
state.brakePipePressureUnsmoothed,
ref car.brakePipePressureRef, 0.2f);
// AirBrake.DebugLog(car, $"after: BP={ExtraBrakeState.Instance(car).brakePipePressureUnsmoothed}, gauge={car.brakePipePressure}, vel={car.brakePipePressureRef}");
}
public override string GetFullStatus(BrakeSystem lastCarBrakeSystem, Dictionary <BrakeSystemComponent, PressureUnit> units)
{
var s = $" {Simulator.Catalog.GetString("BC")} {FormatStrings.FormatPressure(CylPressurePSI, PressureUnit.PSI, units[BrakeSystemComponent.BrakeCylinder], true)}";
if (HandbrakePercent > 0)
{
s += $" {Simulator.Catalog.GetString("Handbrake")} {HandbrakePercent:F0}%";
}
return(s);
}
public override string GetFullStatus(BrakeSystem lastCarBrakeSystem, Dictionary <BrakeSystemComponent, PressureUnit> units)
{
string s = string.Format(" BC {0}", FormatStrings.FormatPressure(CylPressurePSI, PressureUnit.PSI, units[BrakeSystemComponent.BrakeCylinder], true));
if (HandbrakePercent > 0)
{
s += string.Format(" Handbrake {0:F0}%", HandbrakePercent);
}
return(s);
}
public override string GetFullStatus(BrakeSystem lastCarBrakeSystem, Dictionary <BrakeSystemComponent, PressureUnit> units)
{
var s = string.Format("BP {0}", FormatStrings.FormatPressure(BrakeLine1PressurePSI, PressureUnit.PSI, units[BrakeSystemComponent.BrakePipe], false));
if (lastCarBrakeSystem != null && lastCarBrakeSystem != this)
{
s += " EOT " + lastCarBrakeSystem.GetStatus(units);
}
if (HandbrakePercent > 0)
{
s += string.Format(" Handbrake {0:F0}%", HandbrakePercent);
}
return(s);
}
public override string GetFullStatus(BrakeSystem lastCarBrakeSystem, Dictionary <BrakeSystemComponent, PressureUnit> units)
{
string s = string.Format(" V {0}", FormatStrings.FormatPressure(Car.Train.EqualReservoirPressurePSIorInHg, PressureUnit.InHg, PressureUnit.InHg, true));
if (lastCarBrakeSystem != null && lastCarBrakeSystem != this)
{
s += " EOT " + lastCarBrakeSystem.GetStatus(units);
}
if (HandbrakePercent > 0)
{
s += string.Format(" Handbrake {0:F0}%", HandbrakePercent);
}
return(s);
}
public async Task <IHttpActionResult> Post(int id, BrakeSystemInputModel model)
{
BrakeSystem brakeSystem = new BrakeSystem()
{
Id = model.Id, Name = model.Name
};
CommentsStagingModel comment = new CommentsStagingModel()
{
Comment = model.Comment
};
var attachments = SetUpAttachmentsModels(model.Attachments);
var changeRequestId = await _brakeSystemApplicationService.DeleteAsync(brakeSystem, id, CurrentUser.Email, comment, attachments);
return(Ok(changeRequestId));
}
private Expression <Func <VehicleToBrakeConfigDocument, bool> > AddBrakeSystemFilter(
Expression <Func <VehicleToBrakeConfigDocument, bool> > filterEx)
{
if (BrakeSystem == null || !BrakeSystem.Any())
{
return(filterEx);
}
Expression <Func <VehicleToBrakeConfigDocument, bool> > brakeSystemFilterEx = null;
foreach (var brakeSystem in BrakeSystem)
{
brakeSystemFilterEx = brakeSystemFilterEx.OrElse(x => x.BrakeSystemName == brakeSystem);
}
return(filterEx.AndAlso(brakeSystemFilterEx));
}
private static void RechargeMainReservoir(BrakeSystem car, ExtraBrakeState state, float dt)
{
if (car.compressorRunning)
{
var increase = car.compressorProductionRate * Main.settings.compressorSpeed * dt;
car.mainReservoirPressureUnsmoothed =
Mathf.Clamp(car.mainReservoirPressureUnsmoothed + increase, 0f, Constants.MaxMainReservoirPressure);
}
AirFlow.OneWayFlow(
dt,
ref car.mainReservoirPressureUnsmoothed,
ref state.brakePipePressureUnsmoothed,
Constants.MainReservoirVolume,
Constants.BrakePipeVolume,
float.PositiveInfinity);
car.mainReservoirPressure = Mathf.SmoothDamp(car.mainReservoirPressure, car.mainReservoirPressureUnsmoothed, ref car.mainResPressureRef, 0.8f);
}
private static void Update(BrakeSystem car, float dt)
{
var state = ExtraBrakeState.Instance(car);
foreach (var c**k in new HoseAndCock[] { car.Front, car.Rear })
{
float rate = c**k.IsOpenToAtmosphere
? AirFlow.Vent(
dt,
ref state.brakePipePressureUnsmoothed,
Constants.BrakePipeVolume,
VentRate)
: 0f;
// AirBrake.DebugLog(car, $"cockOpen={c**k.IsOpenToAtmosphere}, ventRate={rate}");
c**k.exhaustFlow = Mathf.SmoothDamp(c**k.exhaustFlow, rate, ref c**k.exhaustFlowRef, 0.1f);
}
}
public override void InitializeFromCopy(BrakeSystem copy)
{
VacuumSinglePipe thiscopy = (VacuumSinglePipe)copy;
MaxBrakeForceN = thiscopy.MaxBrakeForceN;
MaxHandbrakeForceN = thiscopy.MaxHandbrakeForceN;
MaxForcePressurePSI = thiscopy.MaxForcePressurePSI;
MaxReleaseRatePSIpS = thiscopy.MaxReleaseRatePSIpS;
MaxApplicationRatePSIpS = thiscopy.MaxApplicationRatePSIpS;
// ApplyChargingRatePSIpS = thiscopy.ApplyChargingRatePSIpS;
// PipeTimeFactorS = thiscopy.PipeTimeFactorS;
// ReleaseTimeFactorS = thiscopy.ReleaseTimeFactorS;
NumCylinders = thiscopy.NumCylinders;
CylVol = thiscopy.CylVol;
PipeVol = thiscopy.PipeVol;
VacResVol = thiscopy.VacResVol;
HasDirectAdmissionValue = thiscopy.HasDirectAdmissionValue;
}
public override string GetFullStatus(BrakeSystem lastCarBrakeSystem, Dictionary <BrakeSystemComponent, PressureUnit> units)
{
string s = string.Format(" EQ {0}", FormatStrings.FormatPressure(Car.Train.BrakeLine1PressurePSIorInHg, PressureUnit.PSI, units[BrakeSystemComponent.EqualizingReservoir], true));
s += string.Format(
" BC {0} BP {1}",
FormatStrings.FormatPressure(CylPressurePSI, PressureUnit.PSI, units[BrakeSystemComponent.BrakeCylinder], true),
FormatStrings.FormatPressure(BrakeLine1PressurePSI, PressureUnit.PSI, units[BrakeSystemComponent.BrakePipe], true)
);
if (lastCarBrakeSystem != null && lastCarBrakeSystem != this)
{
s += " EOT " + lastCarBrakeSystem.GetStatus(units);
}
if (HandbrakePercent > 0)
{
s += string.Format(" Handbrake {0:F0}%", HandbrakePercent);
}
return(s);
}
public override void InitializeFromCopy(BrakeSystem copy)
{
AirSinglePipe thiscopy = (AirSinglePipe)copy;
MaxHandbrakeForceN = thiscopy.MaxHandbrakeForceN;
MaxBrakeForceN = thiscopy.MaxBrakeForceN;
MaxCylPressurePSI = thiscopy.MaxCylPressurePSI;
AuxCylVolumeRatio = thiscopy.AuxCylVolumeRatio;
AuxBrakeLineVolumeRatio = thiscopy.AuxBrakeLineVolumeRatio;
EmergResVolumeM3 = thiscopy.EmergResVolumeM3;
RetainerPressureThresholdPSI = thiscopy.RetainerPressureThresholdPSI;
ReleaseRatePSIpS = thiscopy.ReleaseRatePSIpS;
MaxReleaseRatePSIpS = thiscopy.MaxReleaseRatePSIpS;
MaxApplicationRatePSIpS = thiscopy.MaxApplicationRatePSIpS;
MaxAuxilaryChargingRatePSIpS = thiscopy.MaxAuxilaryChargingRatePSIpS;
EmergResChargingRatePSIpS = thiscopy.EmergResChargingRatePSIpS;
EmergAuxVolumeRatio = thiscopy.EmergAuxVolumeRatio;
TwoPipes = thiscopy.TwoPipes;
NoMRPAuxResCharging = thiscopy.NoMRPAuxResCharging;
HoldingValve = thiscopy.HoldingValve;
}
private async Task UpdateVehicleToBrakeConfigDocuments(BrakeSystem updatedBrakeSystem)
{
bool isEndReached = false;
int pageNumber = 1;
do
{
var vehicleToBrakeConfigSearchResult =
await
_vehicletoBrakeConfigSearchService.SearchAsync(null,
$"brakeSystemId eq {updatedBrakeSystem.Id}", new SearchOptions()
{
RecordCount = 1000, PageNumber = pageNumber
});
var existingVehicleToBrakeConfigDocuments = vehicleToBrakeConfigSearchResult.Documents;
if (existingVehicleToBrakeConfigDocuments != null &&
existingVehicleToBrakeConfigDocuments.Any())
{
foreach (
var existingVehicleToBrakeConfigDocument in
existingVehicleToBrakeConfigDocuments)
{
existingVehicleToBrakeConfigDocument.BrakeSystemName = updatedBrakeSystem.Name;
}
await
this._vehicleToBrakeConfigIndexingService.UploadDocumentsAsync(
existingVehicleToBrakeConfigDocuments.ToList());
pageNumber++;
}
else
{
isEndReached = true;
}
} while (!isEndReached);
}
public override async Task <long> SubmitAddChangeRequestAsync(BrakeConfig entity, string requestedBy,
List <ChangeRequestItemStaging> changeRequestItemStagings = null, CommentsStagingModel comment = null,
List <AttachmentsModel> attachmentsStagingModels = null, string changeContent = null)
{
if (entity.BrakeSystemId.Equals(default(int)) ||
entity.BrakeABSId.Equals(default(int)) ||
entity.FrontBrakeTypeId.Equals(default(int)) ||
entity.RearBrakeTypeId.Equals(default(int)))
{
throw new ArgumentException(nameof(entity));
}
changeRequestItemStagings = new List <ChangeRequestItemStaging>();
// Validation check for insert of new brake config
await ValidateConfigurationDoesNotMatchWithExistingBrakeConfig(entity);
await ValidateNoChangeRequestExistsWithSameConfiguration(entity);
await ValidateBrakeConfigLookUpHasNoChangeRequest(entity);
changeRequestItemStagings.Add(new ChangeRequestItemStaging()
{
ChangeType = ChangeType.Add,
EntityId = entity.Id.ToString(),
CreatedDateTime = DateTime.UtcNow,
Entity = typeof(BrakeConfig).Name,
Payload = base.Serializer.Serialize(entity)
});
var brakeTypeRepositoryService = Repositories.GetRepositoryService <BrakeType>() as IVcdbSqlServerEfRepositoryService <BrakeType>;
var brakeAbsRepositoryService = Repositories.GetRepositoryService <BrakeABS>() as IVcdbSqlServerEfRepositoryService <BrakeABS>;
var brakeSystemRepositoryService = Repositories.GetRepositoryService <BrakeSystem>() as IVcdbSqlServerEfRepositoryService <BrakeSystem>;
BrakeType frontBrakeType = null;
BrakeType rearBrakeType = null;
BrakeABS brakeAbs = null;
BrakeSystem brakeSystem = null;
if (brakeTypeRepositoryService != null && brakeAbsRepositoryService != null && brakeSystemRepositoryService != null)
{
var frontBrakeTypes = await brakeTypeRepositoryService.GetAsync(m => m.Id == entity.FrontBrakeTypeId && m.DeleteDate == null, 1);
if (frontBrakeTypes != null && frontBrakeTypes.Any())
{
frontBrakeType = frontBrakeTypes.First();
}
var rearBrakeTypes = await brakeTypeRepositoryService.GetAsync(m => m.Id == entity.RearBrakeTypeId && m.DeleteDate == null, 1);
if (rearBrakeTypes != null && rearBrakeTypes.Any())
{
rearBrakeType = rearBrakeTypes.First();
}
var brakeAbses = await brakeAbsRepositoryService.GetAsync(m => m.Id == entity.BrakeABSId && m.DeleteDate == null, 1);
if (brakeAbses != null && brakeAbses.Any())
{
brakeAbs = brakeAbses.First();
}
var brakeSystems = await brakeSystemRepositoryService.GetAsync(m => m.Id == entity.BrakeSystemId && m.DeleteDate == null, 1);
if (brakeSystems != null && brakeSystems.Any())
{
brakeSystem = brakeSystems.First();
}
changeContent = string.Format("{0} / {1} / {2} / {3}", frontBrakeType.Name, rearBrakeType.Name, brakeAbs.Name, brakeSystem.Name);
}
// NOTE: change-request-comments-staging perfomed on base
return(await base.SubmitAddChangeRequestAsync(entity, requestedBy, changeRequestItemStagings, comment, attachmentsStagingModels, changeContent));
}
// Get Brake information for train
public override string GetFullStatus(BrakeSystem lastCarBrakeSystem, Dictionary <BrakeSystemComponent, PressureUnit> units)
{
string s = "Manual Brake";
return(s);
}
public static ref float CylinderPressure(this BrakeSystem brakeSystem) => ref ExtraBrakeState.Instance(brakeSystem).cylinderPressure;
public override void InitializeFromCopy(BrakeSystem copy)
{
SingleTransferPipe thiscopy = (SingleTransferPipe)copy;
BrakePipeVolumeM3 = thiscopy.BrakePipeVolumeM3;
}
private static bool Prefix(HoseSeparationChecker __instance, List <HoseSeparationChecker.BrakeHoseCheckPair> ___brakeHosesToCheck, List <HoseSeparationChecker.MUCableCheckPair> ___muCablesToCheck)
{
if (NetworkManager.IsClient())
{
if (Trainset.allSets.Count == 0 || Brakeset.allSets.Count == 0)
{
return(false);
}
for (int i = ___brakeHosesToCheck.Count - 1; i >= 0; i--)
{
HoseSeparationChecker.BrakeHoseCheckPair brakeHoseCheckPair = ___brakeHosesToCheck[i];
BrakeSystem parentSystem = brakeHoseCheckPair.a.parentSystem;
BrakeSystem parentSystem2 = brakeHoseCheckPair.b.parentSystem;
if (parentSystem == null || parentSystem2 == null)
{
___brakeHosesToCheck.RemoveAt(i);
}
else
{
TrainCar component = parentSystem.GetComponent <TrainCar>();
TrainCar component2 = parentSystem2.GetComponent <TrainCar>();
if (!component.GetComponent <NetworkTrainPosSync>().hasLocalPlayerAuthority&& !component2.GetComponent <NetworkTrainPosSync>().hasLocalPlayerAuthority)
{
continue;
}
Coupler coupler = brakeHoseCheckPair.a.isFront ? component.frontCoupler : component.rearCoupler;
Coupler c = brakeHoseCheckPair.b.isFront ? component2.frontCoupler : component2.rearCoupler;
CouplingHoseRig rig = CouplingHoseRig.GetRig(coupler);
CouplingHoseRig rig2 = CouplingHoseRig.GetRig(c);
if (rig && rig2 && Vector3.SqrMagnitude(rig.ropeAnchor.position - rig2.ropeAnchor.position) > 1.9599999f)
{
Debug.Log("Breaking hose connection due to separation", __instance);
coupler.DisconnectAirHose(true);
}
}
}
for (int j = ___muCablesToCheck.Count - 1; j >= 0; j--)
{
HoseSeparationChecker.MUCableCheckPair mucableCheckPair = ___muCablesToCheck[j];
MultipleUnitModule muModule = mucableCheckPair.a.muModule;
MultipleUnitModule muModule2 = mucableCheckPair.b.muModule;
if (muModule == null || muModule2 == null)
{
Debug.LogError(string.Format("Encountered null for {0} a: {1} b: {2}, removing pair", "MultipleUnitModule", muModule == null, muModule2 == null));
___muCablesToCheck.RemoveAt(j);
}
else
{
if (!muModule.GetComponent <NetworkTrainPosSync>().hasLocalPlayerAuthority&& !muModule2.GetComponent <NetworkTrainPosSync>().hasLocalPlayerAuthority)
{
continue;
}
CouplingHoseMultipleUnitAdapter hoseAdapter = mucableCheckPair.a.HoseAdapter;
CouplingHoseRig couplingHoseRig = (hoseAdapter != null) ? hoseAdapter.rig : null;
CouplingHoseMultipleUnitAdapter hoseAdapter2 = mucableCheckPair.b.HoseAdapter;
CouplingHoseRig couplingHoseRig2 = (hoseAdapter2 != null) ? hoseAdapter2.rig : null;
if (couplingHoseRig && couplingHoseRig2 && Vector3.SqrMagnitude(couplingHoseRig.ropeAnchor.position - couplingHoseRig2.ropeAnchor.position) > 1.9599999f)
{
Debug.Log("Breaking MU hose connection due to separation", __instance);
mucableCheckPair.a.Disconnect(true);
}
}
}
return(false);
}
return(true);
}
public abstract void InitializeFromCopy(BrakeSystem copy);
private IEnumerable <CarGroup> GetCarGroups(IEnumerable <TrainCar> cars, bool individual)
{
Job? prevJob = null;
Track?prevDestTrack = null;
int startIndex = 0;
float maxStress = 0f;
var firstCar = cars.First();
var groupCars = new List <TrainCar>()
{
firstCar
};
float minBrakePipePressure = firstCar.brakeSystem.brakePipePressure;
float minBrakeReservoirPressure = GetAuxReservoirPressure(firstCar);
float maxBrakeCylinderPressure = GetBrakeCylinderPressure(firstCar);
float maxBrakeFactor = firstCar.brakeSystem.brakingFactor;
int i = 0;
foreach (var car in cars)
{
float carStress = car.GetComponent <TrainStress>().derailBuildUp;
Job? job = JobChainController.GetJobOfCar(car);
Track? nextDestination = GetNextDestinationTrack(job, car.logicCar);
BrakeSystem brakeSystem = car.brakeSystem;
float pipePressure = brakeSystem.brakePipePressure;
float auxReservoirPressure = GetAuxReservoirPressure(car);
float brakeCylinderPressure = GetBrakeCylinderPressure(car);
if (individual || nextDestination == null || nextDestination != prevDestTrack || job != prevJob)
{
// complete previous group
if (i > 0)
{
yield return(new CarGroup(
startIndex,
i,
groupCars,
maxStress,
prevJob,
prevDestTrack,
minBrakePipePressure,
minBrakeReservoirPressure,
maxBrakeCylinderPressure,
maxBrakeFactor));
}
// start new group
startIndex = i;
groupCars = new List <TrainCar>()
{
car
};
prevJob = job;
prevDestTrack = nextDestination;
maxStress = carStress;
minBrakePipePressure = pipePressure;
minBrakeReservoirPressure = auxReservoirPressure;
maxBrakeCylinderPressure = brakeCylinderPressure;
maxBrakeFactor = brakeSystem.brakingFactor;
}
else
{
groupCars.Add(car);
if (carStress > maxStress)
{
maxStress = carStress;
}
if (pipePressure < minBrakePipePressure)
{
minBrakeReservoirPressure = auxReservoirPressure;
}
if (auxReservoirPressure < minBrakeReservoirPressure)
{
minBrakeReservoirPressure = auxReservoirPressure;
}
if (brakeCylinderPressure > maxBrakeCylinderPressure)
{
maxBrakeCylinderPressure = brakeCylinderPressure;
}
if (brakeSystem.brakingFactor > maxBrakeFactor)
{
maxBrakeFactor = brakeSystem.brakingFactor;
}
}
i++;
}
// complete last group
yield return(new CarGroup(
startIndex,
i,
groupCars,
maxStress,
prevJob,
prevDestTrack,
minBrakePipePressure,
minBrakeReservoirPressure,
maxBrakeCylinderPressure,
maxBrakeFactor));
}
// Get Brake information for train
public override string GetFullStatus(BrakeSystem lastCarBrakeSystem, Dictionary <BrakeSystemComponent, Pressure.Unit> units)
{
string s = Simulator.Catalog.GetString("Manual Brake");
return(s);
}
public override void InitializeFromCopy(BrakeSystem copy)
{
SingleTransferPipe thiscopy = (SingleTransferPipe)copy;
MaxHandbrakeForceN = thiscopy.MaxHandbrakeForceN;
}
protected static void PropagateBrakeLinePressures(float elapsedClockSeconds, TrainCar trainCar, bool twoPipes)
{
var train = trainCar.Train;
var lead = trainCar as MSTSLocomotive;
var brakePipeTimeFactorS = lead == null ? 0.003f : lead.BrakePipeTimeFactorS;
int nSteps = (int)(elapsedClockSeconds * 2 / brakePipeTimeFactorS + 1);
float dt = elapsedClockSeconds / nSteps;
// Propagate brake line (1) data
if (lead != null && lead.BrakePipeChargingRatePSIpS >= 1000)
{ // pressure gradient disabled
if (lead.BrakeSystem.BrakeLine1PressurePSI < train.BrakeLine1PressurePSIorInHg)
{
var dp1 = train.BrakeLine1PressurePSIorInHg - lead.BrakeSystem.BrakeLine1PressurePSI;
lead.MainResPressurePSI -= dp1 * lead.BrakeSystem.BrakePipeVolumeM3 / lead.MainResVolumeM3;
}
foreach (TrainCar car in train.Cars)
{
if (car.BrakeSystem.BrakeLine1PressurePSI >= 0)
{
car.BrakeSystem.BrakeLine1PressurePSI = train.BrakeLine1PressurePSIorInHg;
}
}
}
else
{ // approximate pressure gradient in line1
float serviceTimeFactor = lead != null ? lead.TrainBrakeController != null && lead.TrainBrakeController.EmergencyBraking ? lead.BrakeEmergencyTimeFactorS : lead.BrakeServiceTimeFactorS : 0;
for (int i = 0; i < nSteps; i++)
{
// Trace.TraceWarning("lead.BrakeLine1PressurePSI {0} car1.BrakeLine1PressurePSI {1} car2.BrakeLine1PressurePSI {2} lead.MainResPressurePSI {3} car1.AuxResPressure {4} i {5}",
// lead.BrakeSystem.BrakeLine1PressurePSI, train.Cars[1].BrakeSystem.BrakeLine1PressurePSI, train.Cars[2].BrakeSystem.BrakeLine1PressurePSI, lead.MainResPressurePSI, (train.Cars[1].BrakeSystem as AirSinglePipe).AuxResPressurePSI, i);
if (lead != null)
{
if (lead.BrakeSystem.BrakeLine1PressurePSI < train.BrakeLine1PressurePSIorInHg)
{
float dp = dt * lead.BrakePipeChargingRatePSIpS;
if (lead.BrakeSystem.BrakeLine1PressurePSI + dp > train.BrakeLine1PressurePSIorInHg)
{
dp = train.BrakeLine1PressurePSIorInHg - lead.BrakeSystem.BrakeLine1PressurePSI;
}
if (lead.BrakeSystem.BrakeLine1PressurePSI + dp > lead.MainResPressurePSI)
{
dp = lead.MainResPressurePSI - lead.BrakeSystem.BrakeLine1PressurePSI;
}
if (dp < 0)
{
dp = 0;
}
lead.BrakeSystem.BrakeLine1PressurePSI += dp;
lead.MainResPressurePSI -= dp * lead.BrakeSystem.BrakePipeVolumeM3 / lead.MainResVolumeM3;
}
else if (lead.BrakeSystem.BrakeLine1PressurePSI > train.BrakeLine1PressurePSIorInHg)
{
lead.BrakeSystem.BrakeLine1PressurePSI *= (1 - dt / serviceTimeFactor);
}
}
TrainCar car0 = train.Cars[0];
float p0 = car0.BrakeSystem.BrakeLine1PressurePSI;
float brakePipeVolumeM30 = car0.BrakeSystem.BrakePipeVolumeM3;
foreach (TrainCar car in train.Cars)
{
float p1 = car.BrakeSystem.BrakeLine1PressurePSI;
if (car == train.Cars[0] || car.BrakeSystem.FrontBrakeHoseConnected && car.BrakeSystem.AngleCockAOpen && car0.BrakeSystem.AngleCockBOpen)
{
float dp = Math.Min(dt * (p1 - p0) / brakePipeTimeFactorS * 2, p1 - p0);
car.BrakeSystem.BrakeLine1PressurePSI -= dp * brakePipeVolumeM30 / (brakePipeVolumeM30 + car.BrakeSystem.BrakePipeVolumeM3);
car0.BrakeSystem.BrakeLine1PressurePSI += dp * car.BrakeSystem.BrakePipeVolumeM3 / (brakePipeVolumeM30 + car.BrakeSystem.BrakePipeVolumeM3);
}
if (!car.BrakeSystem.FrontBrakeHoseConnected)
{
if (car.BrakeSystem.AngleCockAOpen)
{
car.BrakeSystem.BrakeLine1PressurePSI -= dt * p1 / brakePipeTimeFactorS;
}
if (car0.BrakeSystem.AngleCockBOpen && car != car0)
{
car0.BrakeSystem.BrakeLine1PressurePSI -= dt * p0 / brakePipeTimeFactorS;
}
}
if (car == train.Cars[train.Cars.Count - 1] && car.BrakeSystem.AngleCockBOpen)
{
car.BrakeSystem.BrakeLine1PressurePSI -= dt * p1 / brakePipeTimeFactorS;
}
p0 = car.BrakeSystem.BrakeLine1PressurePSI;
car0 = car;
brakePipeVolumeM30 = car0.BrakeSystem.BrakePipeVolumeM3;
}
}
}
// Propagate main reservoir pipe (2) and engine brake pipe (3) data
int first = -1;
int last = -1;
train.FindLeadLocomotives(ref first, ref last);
float sumpv = 0;
float sumv = 0;
int continuousFromInclusive = 0;
int continuousToExclusive = train.Cars.Count;
for (int i = 0; i < train.Cars.Count; i++)
{
BrakeSystem brakeSystem = train.Cars[i].BrakeSystem;
if (i < first && (!train.Cars[i + 1].BrakeSystem.FrontBrakeHoseConnected || !brakeSystem.AngleCockBOpen || !train.Cars[i + 1].BrakeSystem.AngleCockAOpen || !train.Cars[i].BrakeSystem.TwoPipes))
{
if (continuousFromInclusive < i + 1)
{
sumv = sumpv = 0;
continuousFromInclusive = i + 1;
}
continue;
}
if (i > last && i > 0 && (!brakeSystem.FrontBrakeHoseConnected || !brakeSystem.AngleCockAOpen || !train.Cars[i - 1].BrakeSystem.AngleCockBOpen || !train.Cars[i].BrakeSystem.TwoPipes))
{
if (continuousToExclusive > i)
{
continuousToExclusive = i;
}
continue;
}
// Collect main reservoir pipe (2) data
if (first <= i && i <= last || twoPipes && continuousFromInclusive <= i && i < continuousToExclusive)
{
sumv += brakeSystem.BrakePipeVolumeM3;
sumpv += brakeSystem.BrakePipeVolumeM3 * brakeSystem.BrakeLine2PressurePSI;
var eng = train.Cars[i] as MSTSLocomotive;
if (eng != null)
{
sumv += eng.MainResVolumeM3;
sumpv += eng.MainResVolumeM3 * eng.MainResPressurePSI;
}
}
// Collect and propagate engine brake pipe (3) data
if (i < first || i > last)
{
brakeSystem.BrakeLine3PressurePSI = 0;
}
else
{
if (lead != null)
{
float p = brakeSystem.BrakeLine3PressurePSI;
if (p > 1000)
{
p -= 1000;
}
var prevState = lead.EngineBrakeState;
if (p < train.BrakeLine3PressurePSI && p < lead.MainResPressurePSI)
{
float dp = elapsedClockSeconds * lead.EngineBrakeApplyRatePSIpS / (last - first + 1);
if (p + dp > train.BrakeLine3PressurePSI)
{
dp = train.BrakeLine3PressurePSI - p;
}
p += dp;
lead.EngineBrakeState = ValveState.Apply;
sumpv -= dp * brakeSystem.GetCylVolumeM3() / lead.MainResVolumeM3;
}
else if (p > train.BrakeLine3PressurePSI)
{
float dp = elapsedClockSeconds * lead.EngineBrakeReleaseRatePSIpS / (last - first + 1);
if (p - dp < train.BrakeLine3PressurePSI)
{
dp = p - train.BrakeLine3PressurePSI;
}
p -= dp;
lead.EngineBrakeState = ValveState.Release;
}
else
{
lead.EngineBrakeState = ValveState.Lap;
}
if (lead.EngineBrakeState != prevState)
{
switch (lead.EngineBrakeState)
{
case ValveState.Release: lead.SignalEvent(Event.EngineBrakePressureIncrease); break;
case ValveState.Apply: lead.SignalEvent(Event.EngineBrakePressureDecrease); break;
case ValveState.Lap: lead.SignalEvent(Event.EngineBrakePressureStoppedChanging); break;
}
}
if (lead.BailOff || (lead.DynamicBrakeAutoBailOff && train.MUDynamicBrakePercent > 0))
{
p += 1000;
}
brakeSystem.BrakeLine3PressurePSI = p;
}
}
}
if (sumv > 0)
{
sumpv /= sumv;
}
if (!train.Cars[continuousFromInclusive].BrakeSystem.FrontBrakeHoseConnected && train.Cars[continuousFromInclusive].BrakeSystem.AngleCockAOpen ||
(continuousToExclusive == train.Cars.Count || !train.Cars[continuousToExclusive].BrakeSystem.FrontBrakeHoseConnected) && train.Cars[continuousToExclusive - 1].BrakeSystem.AngleCockBOpen)
{
sumpv = 0;
}
// Propagate main reservoir pipe (2) data
train.BrakeLine2PressurePSI = sumpv;
for (int i = 0; i < train.Cars.Count; i++)
{
if (first <= i && i <= last || twoPipes && continuousFromInclusive <= i && i < continuousToExclusive)
{
train.Cars[i].BrakeSystem.BrakeLine2PressurePSI = sumpv;
if (sumpv != 0 && train.Cars[i] is MSTSLocomotive)
{
(train.Cars[i] as MSTSLocomotive).MainResPressurePSI = sumpv;
}
}
else
{
train.Cars[i].BrakeSystem.BrakeLine2PressurePSI = train.Cars[i] is MSTSLocomotive ? (train.Cars[i] as MSTSLocomotive).MainResPressurePSI : 0;
}
}
}
