reformat: parameters can be made const

McZapkie/Mover.cpp

@@ -33,12 +33,12 @@ std::vector<std::string> const TMoverParameters::eimc_labels = {"dfic: ", "dfmax
 std::vector<std::string> const TMoverParameters::eimv_labels = {
     "Fkrt:", "Fmax:", "ks:  ", "df:  ", "fp:  ", "Us:  ", "pole:", "Ic:  ", "If:  ", "M:   ", "Fr:  ", "Ipoj:", "Pm:  ", "Pe:  ", "eta: ", "fkr: ", "Uzsm:", "Pmax:", "Fzad:", "Imax:", "Fful:"};
 
-inline double square(double val) // SQR() zle liczylo w current() ...
+inline double square(const double val) // SQR() zle liczylo w current() ...
 {
 	return val * val;
 }
 
-double ComputeCollision(double &v1, double &v2, double m1, double m2, double beta, bool vc)
+double ComputeCollision(double &v1, double &v2, const double m1, const double m2, const double beta, const bool vc)
 { // oblicza zmiane predkosci i przyrost pedu wskutek kolizji
 	assert(beta < 1.0);
 
@@ -55,12 +55,12 @@ double ComputeCollision(double &v1, double &v2, double m1, double m2, double bet
 	}
 }
 
-int DirPatch(int Coupler1, int Coupler2)
+int DirPatch(const int Coupler1, const int Coupler2)
 { // poprawka dla liczenia sil przy ustawieniu przeciwnym obiektow
 	return Coupler1 != Coupler2 ? 1 : -1;
 }
 
-int DirF(int CouplerN)
+int DirF(const int CouplerN)
 {
 	switch (CouplerN)
 	{
@@ -73,7 +73,7 @@ int DirF(int CouplerN)
 	}
 }
 
-void TSecuritySystem::set_enabled(bool e)
+void TSecuritySystem::set_enabled(const bool e)
 {
 	if (vigilance_enabled || cabsignal_enabled || radiostop_enabled)
 		enabled = e;
@@ -118,7 +118,7 @@ void TSecuritySystem::cabsignal_reset()
 	}
 }
 
-void TSecuritySystem::update(double dt, double vel, bool pwr, int cab)
+void TSecuritySystem::update(const double dt, const double vel, const bool pwr, const int cab)
 {
 	if (!enabled || !pwr || DebugModeFlag)
 	{
@@ -218,7 +218,7 @@ bool TSecuritySystem::radiostop_available() const
 	return radiostop_enabled;
 }
 
-void TSecuritySystem::set_cabsignal_lock(bool v)
+void TSecuritySystem::set_cabsignal_lock(const bool v)
 {
 	cabsignal_lock = v;
 }
@@ -231,7 +231,7 @@ bool TSecuritySystem::is_engine_blocked() const
 	return velocity < AwareMinSpeed && pressed;
 }
 
-void TSecuritySystem::load(std::string const &line, double Vmax)
+void TSecuritySystem::load(std::string const &line, const double Vmax)
 {
 	const std::string awaresystem = extract_value("AwareSystem", line);
 	if (awaresystem.find("Active") != std::string::npos)
@@ -254,7 +254,7 @@ void TSecuritySystem::load(std::string const &line, double Vmax)
 	extract_value(CabDependent, "CabDependent", line, "");
 }
 
-double TableInterpolation(std::map<double, double> &Map, double Parameter)
+double TableInterpolation(std::map<double, double> &Map, const double Parameter)
 {
 	if (Map.size() == 0)
 		return 0.0;
@@ -282,7 +282,7 @@ double TableInterpolation(std::map<double, double> &Map, double Parameter)
 // Q: 20160716
 // Obliczanie natężenie prądu w silnikach
 // *************************************************************************************************
-double TMoverParameters::Current(double n, double U)
+double TMoverParameters::Current(const double n, const double U)
 {
 	// wazna funkcja - liczy prad plynacy przez silniki polaczone szeregowo lub rownolegle
 	// w zaleznosci od polozenia nastawnikow MainCtrl i ScndCtrl oraz predkosci obrotowej n
@@ -463,7 +463,7 @@ double TMoverParameters::Current(double n, double U)
 // *************************************************************************************************
 //  główny konstruktor
 // *************************************************************************************************
-TMoverParameters::TMoverParameters(double VelInitial, std::string TypeNameInit, std::string NameInit, int Cab) : TypeName(TypeNameInit), Name(NameInit), CabOccupied(Cab)
+TMoverParameters::TMoverParameters(const double VelInitial, std::string TypeNameInit, std::string NameInit, const int Cab) : TypeName(TypeNameInit), Name(NameInit), CabOccupied(Cab)
 {
 	WriteLog("------------------------------------------------------");
 	WriteLog("init default physic values for " + NameInit + ", [" + TypeNameInit + "]");
@@ -582,7 +582,7 @@ double TMoverParameters::CouplerDist(TMoverParameters const *Left, TMoverParamet
 	return Distance(Left->Loc, Right->Loc, Left->Dim, Right->Dim); // odległość pomiędzy sprzęgami (kula!)
 };
 
-bool TMoverParameters::Attach(int ConnectNo, int ConnectToNr, TMoverParameters *ConnectTo, int CouplingType, bool Enforce, bool Audible)
+bool TMoverParameters::Attach(const int ConnectNo, const int ConnectToNr, TMoverParameters *ConnectTo, const int CouplingType, const bool Enforce, const bool Audible)
 { // łączenie do swojego sprzęgu (ConnectNo) pojazdu (ConnectTo) stroną (ConnectToNr)
 	// Ra: zwykle wykonywane dwukrotnie, dla każdego pojazdu oddzielnie
 	// Ra: trzeba by odróżnić wymóg dociśnięcia od uszkodzenia sprzęgu przy podczepianiu AI do składu
@@ -641,7 +641,7 @@ bool TMoverParameters::Attach(int ConnectNo, int ConnectToNr, TMoverParameters *
 	return true;
 }
 
-int TMoverParameters::DettachStatus(int ConnectNo)
+int TMoverParameters::DettachStatus(const int ConnectNo)
 { // Ra: sprawdzenie, czy odległość jest dobra do rozłączania
 	// powinny być 3 informacje: =0 sprzęg już rozłączony, <0 da się rozłączyć. >0 nie da się rozłączyć
 	if (!Couplers[ConnectNo].Connected)
@@ -656,7 +656,7 @@ int TMoverParameters::DettachStatus(int ConnectNo)
 	return Neighbours[ConnectNo].distance > 0.2 ? -Couplers[ConnectNo].CouplingFlag : Couplers[ConnectNo].CouplingFlag;
 };
 
-bool TMoverParameters::Dettach(int ConnectNo)
+bool TMoverParameters::Dettach(const int ConnectNo)
 { // rozlaczanie
 
 	auto &coupler{Couplers[ConnectNo]};
@@ -723,7 +723,7 @@ bool TMoverParameters::DirectionForward()
 
 // Nastawianie hamulców
 
-void TMoverParameters::BrakeLevelSet(double b)
+void TMoverParameters::BrakeLevelSet(const double b)
 { // ustawienie pozycji hamulca na wartość (b) w zakresie od -2 do BrakeCtrlPosNo
 	// jedyny dopuszczalny sposób przestawienia hamulca zasadniczego
 	if (fBrakeCtrlPos == b)
@@ -764,7 +764,7 @@ void TMoverParameters::BrakeLevelSet(double b)
 	*/
 };
 
-bool TMoverParameters::BrakeLevelAdd(double b)
+bool TMoverParameters::BrakeLevelAdd(const double b)
 { // dodanie wartości (b) do pozycji hamulca (w tym ujemnej)
 	// zwraca false, gdy po dodaniu było by poza zakresem
 	BrakeLevelSet(fBrakeCtrlPos + b);
@@ -781,7 +781,7 @@ bool TMoverParameters::DecBrakeLevel()
 	return BrakeLevelAdd(-1.0);
 }; // nowa wersja na użytek AI, false gdy osiągnięto pozycję -1
 
-bool TMoverParameters::ChangeCab(int direction)
+bool TMoverParameters::ChangeCab(const int direction)
 { // zmiana kabiny i resetowanie ustawien
 	if (std::abs(CabOccupied + direction) < 2)
 	{
@@ -838,7 +838,7 @@ bool TMoverParameters::IsMotorOverloadRelayHighThresholdOn() const
 }
 
 // KURS90 - sprężarka pantografów; Ra 2014-07: teraz jest to zbiornik rozrządu, chociaż to jeszcze nie tak
-void TMoverParameters::UpdatePantVolume(double dt)
+void TMoverParameters::UpdatePantVolume(const double dt)
 {
 	// check the pantograph compressor while at it
 	// TODO: move the check to a separate method
@@ -934,7 +934,7 @@ void TMoverParameters::UpdatePantVolume(double dt)
 	}
 };
 
-void TMoverParameters::UpdateBatteryVoltage(double dt)
+void TMoverParameters::UpdateBatteryVoltage(const double dt)
 { // przeliczenie obciążenia baterii
 	double sn1 = 0.0, sn2 = 0.0, sn3 = 0.0, sn4 = 0.0,
 	       sn5 = 0.0; // Ra: zrobić z tego amperomierz NN
@@ -1354,7 +1354,7 @@ void TMoverParameters::Derail(DerailReason const Reason)
 // *************************************************************************************************
 // Oblicza przemieszczenie taboru
 // *************************************************************************************************
-double TMoverParameters::ComputeMovement(double dt, double dt1, const TTrackShape &Shape, TTrackParam &Track, TTractionParam &ElectricTraction, TLocation const &NewLoc, TRotation const &NewRot)
+double TMoverParameters::ComputeMovement(const double dt, const double dt1, const TTrackShape &Shape, TTrackParam &Track, TTractionParam &ElectricTraction, TLocation const &NewLoc, TRotation const &NewRot)
 {
 	constexpr double Vepsilon = 1e-5;
 	constexpr double Aepsilon = 1e-3; // ASBSpeed=0.8;
@@ -1478,7 +1478,7 @@ double TMoverParameters::ComputeMovement(double dt, double dt1, const TTrackShap
 // Oblicza przemieszczenie taboru - uproszczona wersja
 // *************************************************************************************************
 
-double TMoverParameters::FastComputeMovement(double dt, const TTrackShape &Shape, TTrackParam &Track, TLocation const &NewLoc, TRotation const &NewRot)
+double TMoverParameters::FastComputeMovement(const double dt, const TTrackShape &Shape, TTrackParam &Track, TLocation const &NewLoc, TRotation const &NewRot)
 {
 	int b;
 	// T_MoverParameters::FastComputeMovement(dt, Shape, Track, NewLoc, NewRot);
@@ -1990,7 +1990,7 @@ void TMoverParameters::PowerCouplersCheck(double const Deltatime, coupling const
 	}
 }
 
-double TMoverParameters::ShowEngineRotation(int VehN)
+double TMoverParameters::ShowEngineRotation(const int VehN)
 { // Zwraca wartość prędkości obrotowej silnika wybranego pojazdu. Do 3 pojazdów (3×SN61).
 	int b;
 	switch (VehN)
@@ -2340,7 +2340,7 @@ void TMoverParameters::LightsCheck(double const Timestep)
 	                  light.dimming;
 }
 
-double TMoverParameters::ShowCurrent(int AmpN) const
+double TMoverParameters::ShowCurrent(const int AmpN) const
 { // Odczyt poboru prądu na podanym amperomierzu
 	switch (EngineType)
 	{
@@ -2372,7 +2372,7 @@ double TMoverParameters::ShowCurrent(int AmpN) const
 // zwiększenie nastawinika
 // *************************************************************************************************
 
-bool TMoverParameters::IncMainCtrl(int CtrlSpeed)
+bool TMoverParameters::IncMainCtrl(const int CtrlSpeed)
 {
 	// basic fail conditions:
 	if (MainCtrlPosNo <= 0 || CabActive == 0)
@@ -2555,7 +2555,7 @@ bool TMoverParameters::IncMainCtrl(int CtrlSpeed)
 // Q: 20160710
 // zmniejszenie nastawnika
 // *****************************************************************************
-bool TMoverParameters::DecMainCtrl(int CtrlSpeed)
+bool TMoverParameters::DecMainCtrl(const int CtrlSpeed)
 {
 	bool OK = false;
 	// basic fail conditions:
@@ -2729,7 +2729,7 @@ int TMoverParameters::MainCtrlPowerPos() const
 // Q: 20160710
 // zwiększenie bocznika
 // *************************************************************************************************
-bool TMoverParameters::IncScndCtrl(int CtrlSpeed)
+bool TMoverParameters::IncScndCtrl(const int CtrlSpeed)
 {
 	bool OK = false;
 
@@ -2802,7 +2802,7 @@ bool TMoverParameters::IncScndCtrl(int CtrlSpeed)
 // Q: 20160710
 // zmniejszenie bocznika
 // *************************************************************************************************
-bool TMoverParameters::DecScndCtrl(int CtrlSpeed)
+bool TMoverParameters::DecScndCtrl(const int CtrlSpeed)
 {
 	bool OK = false;
 
@@ -2968,7 +2968,7 @@ bool TMoverParameters::CabDeactivisationAuto(bool const Enforce)
 // Q: 20160710
 // Siła napędzająca drezynę po naciśnięciu wajhy
 // *************************************************************************************************
-bool TMoverParameters::AddPulseForce(int Multipler)
+bool TMoverParameters::AddPulseForce(const int Multipler)
 {
 	bool APF;
 	if (EngineType == TEngineType::WheelsDriven && EnginePowerSource.SourceType == TPowerSource::InternalSource && EnginePowerSource.PowerType == TPowerType::BioPower)
@@ -3106,7 +3106,7 @@ bool TMoverParameters::Sandbox(bool const State, range_t const Notify)
 // yB: 20190909
 // włączenie / wyłączenie automatycznej piasecznicy
 // *************************************************************************************************
-bool TMoverParameters::SandboxAutoAllow(bool State)
+bool TMoverParameters::SandboxAutoAllow(const bool State)
 {
 	// SendCtrlToNext("SandboxAutoAllow", int(State), CabActive, ctrain_controll);
 
@@ -3136,7 +3136,7 @@ void TMoverParameters::SecuritySystemReset(void) // zbijanie czuwaka/SHP
 // Q: 20160711
 // sprawdzanie stanu CA/SHP
 // *************************************************************************************************
-void TMoverParameters::SecuritySystemCheck(double dt)
+void TMoverParameters::SecuritySystemCheck(const double dt)
 {
 	const bool isPower = Power24vIsAvailable || Power110vIsAvailable;
 	SecuritySystem.update(dt, Vel, isPower, CabActive);
@@ -3151,7 +3151,7 @@ void TMoverParameters::SecuritySystemCheck(double dt)
 // Q: 20160710
 // włączenie / wyłączenie baterii
 // *************************************************************************************************
-bool TMoverParameters::BatterySwitch(bool State, range_t const Notify)
+bool TMoverParameters::BatterySwitch(const bool State, range_t const Notify)
 {
 	auto const initialstate{Battery};
 
@@ -3175,7 +3175,7 @@ bool TMoverParameters::BatterySwitch(bool State, range_t const Notify)
 // Q: 20160710
 // włączenie / wyłączenie hamulca elektro-pneumatycznego
 // *************************************************************************************************
-bool TMoverParameters::EpFuseSwitch(bool State)
+bool TMoverParameters::EpFuseSwitch(const bool State)
 {
 	if (EpFuse != State)
 	{
@@ -3192,7 +3192,7 @@ bool TMoverParameters::EpFuseSwitch(bool State)
 // yB: 20190906
 // włączenie / wyłączenie hamulca sprezynowego
 // *************************************************************************************************
-bool TMoverParameters::SpringBrakeActivate(bool State)
+bool TMoverParameters::SpringBrakeActivate(const bool State)
 {
 	if (Power24vIsAvailable || Power110vIsAvailable)
 	{
@@ -3211,7 +3211,7 @@ bool TMoverParameters::SpringBrakeActivate(bool State)
 // yB: 20190906
 // włączenie / wyłączenie odciecia hamulca sprezynowego
 // *************************************************************************************************
-bool TMoverParameters::SpringBrakeShutOff(bool State)
+bool TMoverParameters::SpringBrakeShutOff(const bool State)
 {
 	if (SpringBrake.ShuttOff != State)
 	{
@@ -3289,7 +3289,7 @@ bool TMoverParameters::AntiSlippingButton(void)
 }
 
 // water pump breaker state toggle
-bool TMoverParameters::WaterPumpBreakerSwitch(bool State, range_t const Notify)
+bool TMoverParameters::WaterPumpBreakerSwitch(const bool State, range_t const Notify)
 {
 	/*
 	    if( FuelPump.start_type == start::automatic ) {
@@ -3310,7 +3310,7 @@ bool TMoverParameters::WaterPumpBreakerSwitch(bool State, range_t const Notify)
 }
 
 // water pump state toggle
-bool TMoverParameters::WaterPumpSwitch(bool State, range_t const Notify)
+bool TMoverParameters::WaterPumpSwitch(const bool State, range_t const Notify)
 {
 
 	if (WaterPump.start_type == start_t::battery)
@@ -3332,7 +3332,7 @@ bool TMoverParameters::WaterPumpSwitch(bool State, range_t const Notify)
 }
 
 // water pump state toggle
-bool TMoverParameters::WaterPumpSwitchOff(bool State, range_t const Notify)
+bool TMoverParameters::WaterPumpSwitchOff(const bool State, range_t const Notify)
 {
 
 	if (WaterPump.start_type == start_t::battery)
@@ -3354,7 +3354,7 @@ bool TMoverParameters::WaterPumpSwitchOff(bool State, range_t const Notify)
 }
 
 // water heater breaker state toggle
-bool TMoverParameters::WaterHeaterBreakerSwitch(bool State, range_t const Notify)
+bool TMoverParameters::WaterHeaterBreakerSwitch(const bool State, range_t const Notify)
 {
 	/*
 	    if( FuelPump.start_type == start::automatic ) {
@@ -3375,7 +3375,7 @@ bool TMoverParameters::WaterHeaterBreakerSwitch(bool State, range_t const Notify
 }
 
 // water heater state toggle
-bool TMoverParameters::WaterHeaterSwitch(bool State, range_t const Notify)
+bool TMoverParameters::WaterHeaterSwitch(const bool State, range_t const Notify)
 {
 	/*
 	    if( FuelPump.start_type == start::automatic ) {
@@ -3396,7 +3396,7 @@ bool TMoverParameters::WaterHeaterSwitch(bool State, range_t const Notify)
 }
 
 // water circuits link state toggle
-bool TMoverParameters::WaterCircuitsLinkSwitch(bool State, range_t const Notify)
+bool TMoverParameters::WaterCircuitsLinkSwitch(const bool State, range_t const Notify)
 {
 
 	if (false == dizel_heat.auxiliary_water_circuit)
@@ -3418,7 +3418,7 @@ bool TMoverParameters::WaterCircuitsLinkSwitch(bool State, range_t const Notify)
 }
 
 // fuel pump state toggle
-bool TMoverParameters::FuelPumpSwitch(bool State, range_t const Notify)
+bool TMoverParameters::FuelPumpSwitch(const bool State, range_t const Notify)
 {
 
 	if (FuelPump.start_type == start_t::automatic)
@@ -3439,7 +3439,7 @@ bool TMoverParameters::FuelPumpSwitch(bool State, range_t const Notify)
 	return FuelPump.is_enabled != initialstate;
 }
 
-bool TMoverParameters::FuelPumpSwitchOff(bool State, range_t const Notify)
+bool TMoverParameters::FuelPumpSwitchOff(const bool State, range_t const Notify)
 {
 
 	if (FuelPump.start_type == start_t::automatic)
@@ -3461,7 +3461,7 @@ bool TMoverParameters::FuelPumpSwitchOff(bool State, range_t const Notify)
 }
 
 // oil pump state toggle
-bool TMoverParameters::OilPumpSwitch(bool State, range_t const Notify)
+bool TMoverParameters::OilPumpSwitch(const bool State, range_t const Notify)
 {
 
 	if (OilPump.start_type == start_t::automatic)
@@ -3482,7 +3482,7 @@ bool TMoverParameters::OilPumpSwitch(bool State, range_t const Notify)
 	return OilPump.is_enabled != initialstate;
 }
 
-bool TMoverParameters::OilPumpSwitchOff(bool State, range_t const Notify)
+bool TMoverParameters::OilPumpSwitchOff(const bool State, range_t const Notify)
 {
 
 	if (OilPump.start_type == start_t::automatic)
@@ -3503,7 +3503,7 @@ bool TMoverParameters::OilPumpSwitchOff(bool State, range_t const Notify)
 	return OilPump.is_disabled != initialstate;
 }
 
-bool TMoverParameters::MotorBlowersSwitch(bool State, end const Side, range_t const Notify)
+bool TMoverParameters::MotorBlowersSwitch(const bool State, end const Side, range_t const Notify)
 {
 
 	auto &fan{MotorBlowers[Side]};
@@ -3527,7 +3527,7 @@ bool TMoverParameters::MotorBlowersSwitch(bool State, end const Side, range_t co
 	return fan.is_enabled != initialstate;
 }
 
-bool TMoverParameters::MotorBlowersSwitchOff(bool State, end const Side, range_t const Notify)
+bool TMoverParameters::MotorBlowersSwitchOff(const bool State, end const Side, range_t const Notify)
 {
 
 	auto &fan{MotorBlowers[Side]};
@@ -3551,7 +3551,7 @@ bool TMoverParameters::MotorBlowersSwitchOff(bool State, end const Side, range_t
 	return fan.is_disabled != initialstate;
 }
 
-bool TMoverParameters::CompartmentLightsSwitch(bool State, range_t const Notify)
+bool TMoverParameters::CompartmentLightsSwitch(const bool State, range_t const Notify)
 {
 
 	if (CompartmentLights.start_type == start_t::automatic)
@@ -3573,7 +3573,7 @@ bool TMoverParameters::CompartmentLightsSwitch(bool State, range_t const Notify)
 }
 
 // water pump state toggle
-bool TMoverParameters::CompartmentLightsSwitchOff(bool State, range_t const Notify)
+bool TMoverParameters::CompartmentLightsSwitchOff(const bool State, range_t const Notify)
 {
 
 	if (CompartmentLights.start_type == start_t::automatic)
@@ -3699,7 +3699,7 @@ bool TMoverParameters::MainSwitchCheck() const
 // Q: 20160713
 // włączenie / wyłączenie przetwornicy
 // *************************************************************************************************
-bool TMoverParameters::ConverterSwitch(bool State, range_t const Notify)
+bool TMoverParameters::ConverterSwitch(const bool State, range_t const Notify)
 {
 
 	auto const initialstate{ConverterAllow};
@@ -3721,7 +3721,7 @@ bool TMoverParameters::ConverterSwitch(bool State, range_t const Notify)
 // Q: 20160713
 // włączenie / wyłączenie sprężarki
 // *************************************************************************************************
-bool TMoverParameters::CompressorSwitch(bool State, range_t const Notify)
+bool TMoverParameters::CompressorSwitch(const bool State, range_t const Notify)
 {
 
 	if (CompressorStart != start_t::manual)
@@ -3920,7 +3920,7 @@ bool TMoverParameters::DecDynamicBrakeLevel(float const CtrlSpeed)
 // *************************************************************************************************
 // bezposrednie ustawienie nastawnika hamulca elektrodynamicznego (DynamicBrakeCtrl)
 // *************************************************************************************************
-bool TMoverParameters::DynamicBrakeLevelSet(double Position)
+bool TMoverParameters::DynamicBrakeLevelSet(const double Position)
 {
 	if (false == SplitEDPneumaticBrake)
 		return false;
@@ -4002,7 +4002,7 @@ bool TMoverParameters::DecManualBrakeLevel(int CtrlSpeed)
 // Q: 20160713
 // reczne przelaczanie hamulca elektrodynamicznego
 // *************************************************************************************************
-bool TMoverParameters::DynamicBrakeSwitch(bool Switch)
+bool TMoverParameters::DynamicBrakeSwitch(const bool Switch)
 {
 	bool DBS;
 
@@ -4030,7 +4030,7 @@ bool TMoverParameters::DynamicBrakeSwitch(bool Switch)
 // Q: 20160711
 // włączenie / wyłączenie hamowania awaryjnego
 // *************************************************************************************************
-bool TMoverParameters::RadiostopSwitch(bool Switch)
+bool TMoverParameters::RadiostopSwitch(const bool Switch)
 {
 	bool EBS;
 	if (BrakeSystem != TBrakeSystem::Individual && BrakeCtrlPosNo > 0)
@@ -4096,7 +4096,7 @@ bool TMoverParameters::AntiSlippingBrake(void)
 // Q: 20160711
 // włączenie / wyłączenie odluźniacza
 // *************************************************************************************************
-bool TMoverParameters::BrakeReleaser(int state)
+bool TMoverParameters::BrakeReleaser(const int state)
 {
 	bool OK = true; // false tylko jeśli nie uda się wysłać, GF 20161124
 	if (state != 0)
@@ -4120,7 +4120,7 @@ bool TMoverParameters::BrakeReleaser(int state)
 // yB: 20160711
 // włączenie / wyłączenie uniwersalnego przycisku hamulcowego
 // *************************************************************************************************
-bool TMoverParameters::UniversalBrakeButton(int button, int state)
+bool TMoverParameters::UniversalBrakeButton(const int button, const int state)
 {
 	constexpr bool OK = true; // false tylko jeśli nie uda się wysłać, GF 20161124
 	UniversalBrakeButtonActive[button] = state > 0;
@@ -4150,7 +4150,7 @@ bool TMoverParameters::UniversalBrakeButton(int button, int state)
 // Q: 20160711
 // włączenie / wyłączenie hamulca elektro-pneumatycznego
 // *************************************************************************************************
-bool TMoverParameters::SwitchEPBrake(int state)
+bool TMoverParameters::SwitchEPBrake(const int state)
 {
 	bool OK;
 
@@ -4173,7 +4173,7 @@ bool TMoverParameters::SwitchEPBrake(int state)
 // Q: 20160711
 // zwiększenie ciśnienia hamowania
 // *************************************************************************************************
-bool TMoverParameters::IncBrakePress(double &brake, double PressLimit, double dp)
+bool TMoverParameters::IncBrakePress(double &brake, const double PressLimit, double dp)
 {
 	bool IBP;
 	//  if (DynamicBrakeType<>dbrake_switch) and (DynamicBrakeType<>dbrake_none) and
@@ -4202,7 +4202,7 @@ bool TMoverParameters::IncBrakePress(double &brake, double PressLimit, double dp
 // Q: 20160711
 // zmniejszenie ciśnienia hamowania
 // *************************************************************************************************
-bool TMoverParameters::DecBrakePress(double &brake, double PressLimit, double dp)
+bool TMoverParameters::DecBrakePress(double &brake, const double PressLimit, const double dp)
 {
 	bool DBP;
 
@@ -4228,7 +4228,7 @@ bool TMoverParameters::DecBrakePress(double &brake, double PressLimit, double dp
 // Q: 20160711
 // przełączenie nastawy hamulca O/P/T
 // *************************************************************************************************
-bool TMoverParameters::BrakeDelaySwitch(int BDS)
+bool TMoverParameters::BrakeDelaySwitch(const int BDS)
 {
 	bool rBDS;
 	if (Hamulec->SetBDF(BDS))
@@ -4297,7 +4297,7 @@ bool TMoverParameters::DecBrakeMult(void)
 // Q: 20160712
 // zaktualizowanie ciśnienia w hamulcach
 // *************************************************************************************************
-void TMoverParameters::UpdateBrakePressure(double dt)
+void TMoverParameters::UpdateBrakePressure(const double dt)
 {
 	// const double LBDelay = 5.0; // stala czasowa hamulca
 	// double Rate, Speed, dp, sm;
@@ -4316,7 +4316,7 @@ void TMoverParameters::UpdateBrakePressure(double dt)
 // Q: 20160712
 // Obliczanie pracy sprężarki
 // *************************************************************************************************
-void TMoverParameters::CompressorCheck(double dt)
+void TMoverParameters::CompressorCheck(const double dt)
 {
 
 	if (CompressorSpeed == 0.0)
@@ -4473,7 +4473,7 @@ void TMoverParameters::CompressorCheck(double dt)
 // Q: 20160712
 // aktualizacja ciśnienia w przewodzie głównym
 // *************************************************************************************************
-void TMoverParameters::UpdatePipePressure(double dt)
+void TMoverParameters::UpdatePipePressure(const double dt)
 {
 	if (PipePress > 1.0)
 	{
@@ -4760,7 +4760,7 @@ void TMoverParameters::UpdatePipePressure(double dt)
 // Q: 20160713
 // Aktualizacja ciśnienia w przewodzie zasilającym
 // *************************************************************************************************
-void TMoverParameters::UpdateScndPipePressure(double dt)
+void TMoverParameters::UpdateScndPipePressure(const double dt)
 {
 	if (ScndPipePress > 1.0)
 	{
@@ -4859,7 +4859,7 @@ void TMoverParameters::UpdateSpringBrake(double dt)
 // Q: 20160715
 // oblicza i zwraca przepływ powietrza pomiędzy pojazdami
 // *************************************************************************************************
-double TMoverParameters::GetDVc(double dt)
+double TMoverParameters::GetDVc(const double dt)
 {
 	// T_MoverParameters *c;
 	TMoverParameters *c;
@@ -4996,7 +4996,7 @@ void TMoverParameters::ComputeMass()
 // Obliczanie wypadkowej siły z wszystkich działających sił
 // *************************************************************************************************
 // TBD, TODO: move some of the calculations out of the method, they're relevant to more than just force calculations
-void TMoverParameters::ComputeTotalForce(double dt)
+void TMoverParameters::ComputeTotalForce(const double dt)
 {
 
 	Vel = std::abs(V) * 3.6; // prędkość w km/h
@@ -5136,7 +5136,7 @@ void TMoverParameters::ComputeTotalForce(double dt)
 	FTotal = FTrain - Sign(V) * FStand;
 }
 
-double TMoverParameters::BrakeForceR(double ratio, double velocity)
+double TMoverParameters::BrakeForceR(double ratio, const double velocity)
 {
 	double press = 0;
 	if (MBPM > 2)
@@ -5165,7 +5165,7 @@ double TMoverParameters::BrakeForceR(double ratio, double velocity)
 	return BrakeForceP(press * ratio, velocity);
 }
 
-double TMoverParameters::BrakeForceP(double press, double velocity)
+double TMoverParameters::BrakeForceP(const double press, const double velocity)
 {
 	double BFP = 0;
 	double K = ((press * P2FTrans - BrakeCylSpring) * BrakeCylMult[0] - BrakeSlckAdj) * BrakeRigEff;
@@ -5264,7 +5264,7 @@ double TMoverParameters::FrictionForce() const
 // Q: 20160713
 // Oblicza przyczepność
 // *************************************************************************************************
-double TMoverParameters::Adhesive(double staticfriction) const
+double TMoverParameters::Adhesive(const double staticfriction) const
 {
 	double adhesion = 0.0;
 	constexpr double adh_factor = 0.25; // współczynnik określający, jak bardzo spada tarcie przy poślizgu
@@ -5319,7 +5319,7 @@ double TMoverParameters::Adhesive(double staticfriction) const
 // Q: 20160713
 // Obliczanie sił dzialających na sprzęgach
 // *************************************************************************************************
-double TMoverParameters::CouplerForce(int const End, double dt)
+double TMoverParameters::CouplerForce(int const End, const double dt)
 {
 
 	auto &coupler{Couplers[End]};
@@ -5477,7 +5477,7 @@ double TMoverParameters::CouplerForce(int const End, double dt)
 // Q: 20160714
 // oblicza sile trakcyjna lokomotywy (dla elektrowozu tez calkowity prad)
 // *************************************************************************************************
-double TMoverParameters::TractionForce(double dt)
+double TMoverParameters::TractionForce(const double dt)
 {
 	double PosRatio, dmoment, dtrans, tmp;
 
@@ -6568,7 +6568,7 @@ double TMoverParameters::TractionForce(double dt)
 // Q: 20160713
 // Obliczenie predkości obrotowej kół???
 // *************************************************************************************************
-double TMoverParameters::ComputeRotatingWheel(double WForce, double dt, double n) const
+double TMoverParameters::ComputeRotatingWheel(const double WForce, const double dt, const double n) const
 {
 	double newn = 0, eps = 0;
 	if (n == 0 && WForce * Sign(V) < 0)
@@ -6742,7 +6742,7 @@ double TMoverParameters::v2n(void)
 // Q: 20160714
 // Oblicza moment siły wytwarzany przez silnik
 // *************************************************************************************************
-double TMoverParameters::Momentum(double I)
+double TMoverParameters::Momentum(const double I)
 {
 	// liczy moment sily wytwarzany przez silnik elektryczny}
 	int SP;
@@ -6760,7 +6760,7 @@ double TMoverParameters::Momentum(double I)
 // Q: 20160714
 // Oblicza moment siły do sterowania wzbudzeniem
 // *************************************************************************************************
-double TMoverParameters::MomentumF(double I, double Iw, int SCP)
+double TMoverParameters::MomentumF(const double I, const double Iw, const int SCP)
 {
 	// umozliwia dokladne sterowanie wzbudzeniem
 
@@ -6789,7 +6789,7 @@ bool TMoverParameters::CutOffEngine(void)
 // Q: 20160713
 // Przełączenie wysoki / niski prąd rozruchu
 // *************************************************************************************************
-bool TMoverParameters::MaxCurrentSwitch(bool State, range_t const Notify)
+bool TMoverParameters::MaxCurrentSwitch(const bool State, range_t const Notify)
 {
 	auto const initialstate{MotorOverloadRelayHighThreshold};
 
@@ -6807,7 +6807,7 @@ bool TMoverParameters::MaxCurrentSwitch(bool State, range_t const Notify)
 // Q: 20160713
 // Przełączenie wysoki / niski prąd rozruchu automatycznego
 // *************************************************************************************************
-bool TMoverParameters::MinCurrentSwitch(bool State)
+bool TMoverParameters::MinCurrentSwitch(const bool State)
 {
 	bool MCS = false;
 	if ((EngineType == TEngineType::ElectricSeriesMotor && IminHi > IminLo) || (TrainType == dt_EZT && EngineType != TEngineType::ElectricInductionMotor))
@@ -6855,7 +6855,7 @@ bool TMoverParameters::ResistorsFlagCheck(void) const
 // Q: 20160713
 // Włączenie / wyłączenie automatycznego rozruchu
 // *************************************************************************************************
-bool TMoverParameters::AutoRelaySwitch(bool State)
+bool TMoverParameters::AutoRelaySwitch(const bool State)
 {
 	bool ARS;
 	if (AutoRelayType == 2 && AutoRelayFlag != State)
@@ -7323,7 +7323,7 @@ bool TMoverParameters::DropAllPantographs(bool const State, range_t const Notify
 	return State != initialstate;
 }
 
-void TMoverParameters::CheckEIMIC(double dt)
+void TMoverParameters::CheckEIMIC(const double dt)
 {
 	const double offset = EIMCtrlAdditionalZeros ? 1.0 : 0.0;
 	const double multiplier = (EIMCtrlEmergency ? 1.0 : 0.0) + offset;
@@ -7511,7 +7511,7 @@ void TMoverParameters::CheckEIMIC(double dt)
 	eimic = std::clamp(eimic, -1.0, eimicpowerenabled ? eimic_max : 0.0);
 }
 
-void TMoverParameters::CheckSpeedCtrl(double dt)
+void TMoverParameters::CheckSpeedCtrl(const double dt)
 {
 	if (EIMCtrlType == 0)
 	{
@@ -7613,7 +7613,7 @@ void TMoverParameters::CheckSpeedCtrl(double dt)
 	}
 }
 
-void TMoverParameters::SpeedCtrlButton(int button)
+void TMoverParameters::SpeedCtrlButton(const int button)
 {
 	if (SpeedCtrl && ScndCtrlPos > 0)
 	{
@@ -7667,7 +7667,7 @@ bool TMoverParameters::SpeedCtrlPowerDec()
 // Q: 20160715
 // Zmienia parametr do którego dąży sprzęgło
 // *************************************************************************************************
-bool TMoverParameters::dizel_EngageSwitch(double state)
+bool TMoverParameters::dizel_EngageSwitch(const double state)
 {
 	if (EngineType == TEngineType::DieselEngine && state <= 1 && state >= 0 && state != dizel_engagestate)
 	{
@@ -7871,7 +7871,7 @@ bool TMoverParameters::dizel_StartupCheck()
 // Q: 20160715
 // Aktualizacja stanu silnika
 // *************************************************************************************************
-bool TMoverParameters::dizel_Update(double dt)
+bool TMoverParameters::dizel_Update(const double dt)
 {
 
 	WaterPumpCheck(dt);
@@ -7925,7 +7925,7 @@ bool TMoverParameters::dizel_Update(double dt)
 // Q: 20160715
 // oblicza napelnienie, uzwglednia regulator obrotow
 // *************************************************************************************************
-double TMoverParameters::dizel_fillcheck(int mcp, double dt)
+double TMoverParameters::dizel_fillcheck(const int mcp, const double dt)
 {
 	auto realfill{0.0};
 
@@ -8027,7 +8027,7 @@ double TMoverParameters::dizel_fillcheck(int mcp, double dt)
 // Q: 20160715
 // Oblicza moment siły wytwarzany przez silnik spalinowy
 // *************************************************************************************************
-double TMoverParameters::dizel_Momentum(double dizel_fill, double n, double dt)
+double TMoverParameters::dizel_Momentum(const double dizel_fill, double n, const double dt)
 { // liczy moment sily wytwarzany przez silnik spalinowy}
 	double Moment = 0, enMoment = 0, gearMoment = 0, eps = 0, newn = 0, friction = 0, neps = 0;
 	double TorqueH = 0, TorqueL = 0, TorqueC = 0;
@@ -8200,7 +8200,7 @@ double TMoverParameters::dizel_Momentum(double dizel_fill, double n, double dt)
 	return gearMoment;
 }
 
-double TMoverParameters::dizel_MomentumRetarder(double n, double dt)
+double TMoverParameters::dizel_MomentumRetarder(double n, const double dt)
 {
 	double RetarderRequest = Mains ? std::max(0.0, -eimic_real) : 0;
 	if (hydro_R_WithIndividual)
@@ -8876,7 +8876,7 @@ void TMoverParameters::update_doors(double const Deltatime)
 // Q: 20160713
 // Przesuwa pojazd o podaną wartość w bok względem toru (dla samochodów)
 // *************************************************************************************************
-bool TMoverParameters::ChangeOffsetH(double DeltaOffset)
+bool TMoverParameters::ChangeOffsetH(const double DeltaOffset)
 {
 	bool COH = false;
 	if (TestFlag(CategoryFlag, 2) && TestFlag(RunningTrack.CategoryFlag, 2))
@@ -8898,7 +8898,7 @@ bool TMoverParameters::ChangeOffsetH(double DeltaOffset)
 // Q: 20160713
 // Testuje zmienną (narazie tylko 0) i na podstawie uszkodzenia zwraca informację tekstową
 // *************************************************************************************************
-std::string TMoverParameters::EngineDescription(int what) const
+std::string TMoverParameters::EngineDescription(const int what) const
 {
 	std::string outstr{"OK"};
 	switch (what)
@@ -11709,7 +11709,7 @@ TEngineType TMoverParameters::LoadFIZ_EngineDecode(std::string const &Engine)
 // Q: 20160717
 // *************************************************************************************************
 
-bool TMoverParameters::CheckLocomotiveParameters(bool ReadyFlag, int Dir)
+bool TMoverParameters::CheckLocomotiveParameters(const bool ReadyFlag, int Dir)
 {
 	WriteLog("check locomotive parameters...");
 	int b;
@@ -12097,7 +12097,7 @@ bool TMoverParameters::CheckLocomotiveParameters(bool ReadyFlag, int Dir)
 // Q: 20160714
 // Wstawia komendę z parametrem, od sprzęgu i w lokalizacji do pojazdu
 // *************************************************************************************************
-void TMoverParameters::PutCommand(std::string NewCommand, double NewValue1, double NewValue2, const TLocation &NewLocation)
+void TMoverParameters::PutCommand(std::string NewCommand, const double NewValue1, const double NewValue2, const TLocation &NewLocation)
 {
 	CommandLast = NewCommand; // zapamiętanie komendy
 
@@ -12122,7 +12122,7 @@ double TMoverParameters::GetExternalCommand(std::string &Command)
 // Q: 20160714
 // Ustawienie komendy wraz z parametrami
 // *************************************************************************************************
-bool TMoverParameters::SetInternalCommand(std::string NewCommand, double NewValue1, double NewValue2, int const Couplertype)
+bool TMoverParameters::SetInternalCommand(std::string NewCommand, const double NewValue1, const double NewValue2, int const Couplertype)
 {
 	bool SIC;
 	if (CommandIn.Command == NewCommand && CommandIn.Value1 == NewValue1 && CommandIn.Value2 == NewValue2 && CommandIn.Coupling == Couplertype)
@@ -12187,7 +12187,7 @@ bool TMoverParameters::SendCtrlToNext(std::string const CtrlCommand, double cons
 // Komenda musi być zdefiniowana tutaj, a jeśli się wywołuje funkcję, to ona nie może
 // sama przesyłać do kolejnych pojazdów. Należy też się zastanowić, czy dla uzyskania
 // jakiejś zmiany (np. IncMainCtrl) lepiej wywołać funkcję, czy od razu wysłać komendę.
-bool TMoverParameters::RunCommand(std::string Command, double CValue1, double CValue2, int const Couplertype)
+bool TMoverParameters::RunCommand(std::string Command, const double CValue1, const double CValue2, int const Couplertype)
 {
 	bool OK{false};
 
@@ -12753,7 +12753,7 @@ bool TMoverParameters::RunInternalCommand()
 // Q: 20160714
 // Zwraca wartość natężenia prądu na wybranym amperomierzu. Podfunkcja do ShowCurrent.
 // *************************************************************************************************
-double TMoverParameters::ShowCurrentP(int AmpN) const
+double TMoverParameters::ShowCurrentP(const int AmpN) const
 {
 	int b, Bn;
 	bool Grupowy;

McZapkie/Oerlikon_ESt.cpp

@@ -36,12 +36,12 @@ void TRura::Update(double dt)
 
 // ------ PRZECIWPOSLIG ------
 
-void TPrzeciwposlizg::SetPoslizg(bool flag)
+void TPrzeciwposlizg::SetPoslizg(const bool flag)
 {
     Poslizg = flag;
 }
 
-void TPrzeciwposlizg::Update(double dt)
+void TPrzeciwposlizg::Update(const double dt)
 {
     if (true == Poslizg)
     {
@@ -55,7 +55,7 @@ void TPrzeciwposlizg::Update(double dt)
 
 // ------ PRZEKLADNIK ------
 
-void TPrzekladnik::Update(double dt)
+void TPrzekladnik::Update(const double dt)
 {
     double dV;
 
@@ -78,7 +78,7 @@ void TPrzekladnik::Update(double dt)
 
 // ------ PRZEKLADNIK RAPID ------
 
-void TRapid::SetRapidParams(double mult, double size)
+void TRapid::SetRapidParams(const double mult, const double size)
 {
     RapidMult = mult;
     RapidStatus = false;
@@ -94,12 +94,12 @@ void TRapid::SetRapidParams(double mult, double size)
     }
 }
 
-void TRapid::SetRapidStatus(bool rs)
+void TRapid::SetRapidStatus(const bool rs)
 {
     RapidStatus = rs;
 }
 
-void TRapid::Update(double dt)
+void TRapid::Update(const double dt)
 {
 	const double BVP{ BrakeRes->P() };
 	const double BCP{ Next->P() };
@@ -129,12 +129,12 @@ void TRapid::Update(double dt)
 
 // ------ PRZEKŁADNIK CIĄGŁY ------
 
-void TPrzekCiagly::SetMult(double m)
+void TPrzekCiagly::SetMult(const double m)
 {
     Mult = m;
 }
 
-void TPrzekCiagly::Update(double dt)
+void TPrzekCiagly::Update(const double dt)
 {
     double const BVP{ BrakeRes->P() };
     double const BCP{ Next->P() };
@@ -154,12 +154,12 @@ void TPrzekCiagly::Update(double dt)
 
 // ------ PRZEKŁADNIK CIĄGŁY ------
 
-void TPrzek_PZZ::SetLBP(double P)
+void TPrzek_PZZ::SetLBP(const double P)
 {
     LBP = P;
 }
 
-void TPrzek_PZZ::Update(double dt)
+void TPrzek_PZZ::Update(const double dt)
 {
 
     double const BVP{ BrakeRes->P() };
@@ -181,12 +181,12 @@ void TPrzek_PZZ::Update(double dt)
 
 // ------ PRZECIWPOSLIG ------
 
-void TPrzekED::SetP(double P)
+void TPrzekED::SetP(const double P)
 {
     MaxP = P;
 }
 
-void TPrzekED::Update(double dt)
+void TPrzekED::Update(const double dt)
 {
     if (Next->P() > MaxP)
     {

McZapkie/Oerlikon_ESt.h

@@ -205,7 +205,7 @@ class TNESt3 : public TBrake {
     double LBP = 0.0; // cisnienie hamulca pomocniczego
 
   public:
-	TNESt3(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) :
+	TNESt3(const double i_mbp, const double i_bcr, const double i_bcd, const double i_brc, const int i_bcn, const int i_BD, const int i_mat, const int i_ba, const int i_nbpa) :
            TBrake(       i_mbp,        i_bcr,        i_bcd,        i_brc,     i_bcn,     i_BD,     i_mat,     i_ba,     i_nbpa)
 	{}
     void Init( double PP, double HPP, double LPP, double BP, int BDF ) /*override*/;

McZapkie/friction.cpp

@@ -20,7 +20,7 @@ double TFricMat::GetFC(double N, double Vel)
     return 1;
 }
 
-double TP10Bg::GetFC(double N, double Vel)
+double TP10Bg::GetFC(const double N, const double Vel)
 {
     //  GetFC:=0.60*((1.6*N+100)/(8.0*N+100))*((Vel+100)/(5*Vel+100))*(1.0032-0.0007*N-0.0001*N*N);
     //  GetFC:=47/(2*Vel+100)*(2.145-0.0538*N+0.00074*N*N-0.00000536*N*N*N)/2.145;
@@ -34,7 +34,7 @@ double TP10Bg::GetFC(double N, double Vel)
             0.384 * exp(-Vel * 1.0 / 25.7) - 0.028;
 }
 
-double TP10Bgu::GetFC(double N, double Vel)
+double TP10Bgu::GetFC(const double N, const double Vel)
 {
     //  GetFC:=0.60*((1.6*N+100)/(8.0*N+100))*((Vel+100)/(5*Vel+100));
     //  GetFC:=47/(2*Vel+100)*(2.137-0.0514*N+0.000832*N*N-0.00000604*N*N*N)/2.137;
@@ -49,7 +49,7 @@ double TP10Bgu::GetFC(double N, double Vel)
             0.381 * exp(-Vel * 1.0 / 25.7) - 0.022; // 0.05*exp(-0.2*N);
 }
 
-double TP10yBg::GetFC(double N, double Vel)
+double TP10yBg::GetFC(const double N, const double Vel)
 {
     double A;
     double C;
@@ -63,7 +63,7 @@ double TP10yBg::GetFC(double N, double Vel)
     return u0 + C * exp(-Vel * 1.0 / V0);
 }
 
-double TP10yBgu::GetFC(double N, double Vel)
+double TP10yBgu::GetFC(const double N, const double Vel)
 {
     double A;
     double C;
@@ -77,14 +77,14 @@ double TP10yBgu::GetFC(double N, double Vel)
     return u0 + C * exp(-Vel * 1.0 / V0);
 }
 
-double TP10::GetFC(double N, double Vel)
+double TP10::GetFC(const double N, const double Vel)
 {
     return
         0.60 * ((1.6 * N + 100) * 1.0 / (8.0 * N + 100)) * ((Vel + 100) * 1.0 / (5 * Vel + 100));
     //  GetFC:=43/(2*Vel+100)*(2.145-0.0538*N+0.00074*N*N-0.00000536*N*N*N)/2.145
 }
 
-double TFR513::GetFC(double N, double Vel)
+double TFR513::GetFC(double N, const double Vel)
 {
     return 0.3 - Vel * 0.00081;
     //  GetFC:=43/(2*Vel+100)*(2.145-0.0538*N+0.00074*N*N-0.00000536*N*N*N)/2.145
@@ -95,7 +95,7 @@ double TCosid::GetFC(double N, double Vel)
     return 0.27;
 }
 
-double TDisk1::GetFC(double N, double Vel)
+double TDisk1::GetFC(const double N, double Vel)
 {
     return 0.2375 + 0.000885 * N - 0.000345 * N * N;
 }

McZapkie/hamulce.cpp

@@ -43,7 +43,7 @@ double const TFVE408::pos_table[11] = {0, 10, 0, 0, 10, 7, 8, 9, 0, 1, 5};
 /// <param name="P1">Source pressure [bar].</param>
 /// <param name="P2">Destination pressure [bar].</param>
 /// <returns>Dimensionless flow driver (positive when P2 &gt; P1).</returns>
-double PR(double P1, double P2)
+double PR(const double P1, const double P2)
 {
 	const double PH = std::max(P1, P2) + 0.1;
 	const double PL = P1 + P2 - PH + 0.2;
@@ -57,7 +57,7 @@ double PR(double P1, double P2)
 /// <param name="P2">Destination pressure [bar].</param>
 /// <param name="S">Effective orifice cross-section.</param>
 /// <returns>Volumetric flow rate (signed).</returns>
-double PF_old(double P1, double P2, double S)
+double PF_old(const double P1, const double P2, const double S)
 {
 	const double PH = std::max(P1, P2) + 1;
 	const double PL = P1 + P2 - PH + 2;
@@ -203,7 +203,7 @@ double PFVd(double PH, double PL, double const S, double LIM, double const DP)
 /// <param name="pos">Continuous handle position.</param>
 /// <param name="i_pos">Detent centre to compare against.</param>
 /// <returns>True if pos is within ±0.5 of i_pos.</returns>
-bool is_EQ(double pos, double i_pos)
+bool is_EQ(const double pos, const double i_pos)
 {
 	return pos <= i_pos + 0.5 && pos > i_pos - 0.5;
 }
@@ -233,7 +233,7 @@ double TReservoir::P()
 /// The change is applied to <c>Vol</c> on the next call to <see cref="Act"/>.
 /// </summary>
 /// <param name="dv">Flow delta (positive = into reservoir, negative = out).</param>
-void TReservoir::Flow(double dv)
+void TReservoir::Flow(const double dv)
 {
 	dVol = dVol + dv;
 }
@@ -252,7 +252,7 @@ void TReservoir::Act()
 /// Sets the reservoir capacity in liters.
 /// </summary>
 /// <param name="Capacity">Capacity in liters.</param>
-void TReservoir::CreateCap(double Capacity)
+void TReservoir::CreateCap(const double Capacity)
 {
 	Cap = Capacity;
 }
@@ -262,7 +262,7 @@ void TReservoir::CreateCap(double Capacity)
 /// and clears any pending flow.
 /// </summary>
 /// <param name="Press">Initial pressure in bar.</param>
-void TReservoir::CreatePress(double Press)
+void TReservoir::CreatePress(const double Press)
 {
 	Vol = Cap * Press;
 	dVol = 0;
@@ -367,7 +367,7 @@ end  ; */
 /// <param name="i_mat">Friction material id (bp_* constant, optionally OR'ed with bp_MHS).</param>
 /// <param name="i_ba">Number of braked axles.</param>
 /// <param name="i_nbpa">Number of blocks per axle.</param>
-TBrake::TBrake(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa)
+TBrake::TBrake(const double i_mbp, const double i_bcr, const double i_bcd, const double i_brc, const int i_bcn, const int i_BD, int i_mat, const int i_ba, const int i_nbpa)
 {
 	// inherited:: Create;
 	MaxBP = i_mbp;
@@ -1313,7 +1313,7 @@ void TEStEP2::SetLP(double const TM, double const LM, double const TBP)
 /// quadratic-in-EPS rate and a load-weighing-aware ceiling at MaxBP * LoadC.
 /// </summary>
 /// <param name="dt">Time step [s].</param>
-void TEStEP2::EPCalc(double dt)
+void TEStEP2::EPCalc(const double dt)
 {
 	const double temp = BrakeRes->P() * int(EPS > 0);
 	const double dv = PF(temp, LBP, 0.00053 + 0.00060 * int(EPS < 0)) * dt * EPS * EPS * int(LBP * EPS < MaxBP * LoadC);
@@ -1327,7 +1327,7 @@ void TEStEP2::EPCalc(double dt)
 /// opening with a clamped error term S.
 /// </summary>
 /// <param name="dt">Time step [s].</param>
-void TEStEP1::EPCalc(double dt)
+void TEStEP1::EPCalc(const double dt)
 {
 	const double temp = EPS - std::floor(EPS); // część ułamkowa jest hamulcem EP
 	const double LBPLim = std::min(MaxBP * LoadC * temp, BrakeRes->P()); // do czego dążymy
@@ -2940,14 +2940,14 @@ double TDriverHandle::GetEP(double pos)
 /// Latches the manual overcharge / assimilation button state.
 /// </summary>
 /// <param name="Active">True while the button is pressed.</param>
-void TDriverHandle::OvrldButton(bool Active)
+void TDriverHandle::OvrldButton(const bool Active)
 {
 	ManualOvrldActive = Active;
 }
 
 /// <summary>Stores the universal-button flags (combined ub_* values).</summary>
 /// <param name="flag">Universal-button bitfield.</param>
-void TDriverHandle::SetUniversalFlag(int flag)
+void TDriverHandle::SetUniversalFlag(const int flag)
 {
 	UniversalFlag = flag;
 }
@@ -2966,7 +2966,7 @@ void TDriverHandle::SetUniversalFlag(int flag)
 /// <param name="dt">Time step [s].</param>
 /// <param name="ep">EP / equalising input [bar].</param>
 /// <returns>Brake pipe volume change for this step.</returns>
-double TFV4a::GetPF(double i_bcp, double PP, double HP, double dt, double ep)
+double TFV4a::GetPF(const double i_bcp, const double PP, const double HP, const double dt, double ep)
 {
 	static constexpr int LBDelay = 100;
 
@@ -3034,7 +3034,7 @@ double TFV4a::GetPF(double i_bcp, double PP, double HP, double dt, double ep)
 
 /// <summary>Initialises CP and RP to the supplied pressure.</summary>
 /// <param name="Press">Initial pressure [bar].</param>
-void TFV4a::Init(double Press)
+void TFV4a::Init(const double Press)
 {
 	CP = Press;
 	RP = Press;
@@ -3055,7 +3055,7 @@ void TFV4a::Init(double Press)
 /// <param name="dt">Time step [s].</param>
 /// <param name="ep">EP / equalising input [bar].</param>
 /// <returns>Brake pipe volume change for this step.</returns>
-double TFV4aM::GetPF(double i_bcp, double PP, double HP, double dt, double ep)
+double TFV4aM::GetPF(double i_bcp, const double PP, const double HP, const double dt, double ep)
 {
 	constexpr int LBDelay{100};
 	constexpr double xpM{0.3}; // mnoznik membrany komory pod
@@ -3213,7 +3213,7 @@ double TFV4aM::GetPF(double i_bcp, double PP, double HP, double dt, double ep)
 
 /// <summary>Initialises CP and RP to the supplied pressure.</summary>
 /// <param name="Press">Initial pressure [bar].</param>
-void TFV4aM::Init(double Press)
+void TFV4aM::Init(const double Press)
 {
 	CP = Press;
 	RP = Press;
@@ -3221,14 +3221,14 @@ void TFV4aM::Init(double Press)
 
 /// <summary>Sets the reductor adjustment offset (turning the reductor cap).</summary>
 /// <param name="nAdj">Pressure correction [bar].</param>
-void TFV4aM::SetReductor(double nAdj)
+void TFV4aM::SetReductor(const double nAdj)
 {
 	RedAdj = nAdj;
 }
 
 /// <summary>Returns Sounds[i] for valid indices, 0 otherwise.</summary>
 /// <param name="i">Sound channel index (s_fv4a_*).</param>
-double TFV4aM::GetSound(int i)
+double TFV4aM::GetSound(const int i)
 {
 	if (i > 4)
 		return 0;
@@ -3238,7 +3238,7 @@ double TFV4aM::GetSound(int i)
 
 /// <summary>Returns pos_table[i] (handle position for the requested function code).</summary>
 /// <param name="i">Function code (bh_*).</param>
-double TFV4aM::GetPos(int i)
+double TFV4aM::GetPos(const int i)
 {
 	return pos_table[i];
 }
@@ -3262,7 +3262,7 @@ double TFV4aM::GetRP()
 /// </summary>
 /// <param name="pos">Continuous handle position.</param>
 /// <returns>Interpolated target pressure [bar].</returns>
-double TFV4aM::LPP_RP(double pos) // cisnienie z zaokraglonej pozycji;
+double TFV4aM::LPP_RP(const double pos) // cisnienie z zaokraglonej pozycji;
 {
 	int const i_pos = 2 + std::floor(pos); // zaokraglone w dol
 
@@ -3271,7 +3271,7 @@ double TFV4aM::LPP_RP(double pos) // cisnienie z zaokraglonej pozycji;
 /// <summary>Returns true if pos is within ±0.5 of i_pos (detent test).</summary>
 /// <param name="pos">Continuous handle position.</param>
 /// <param name="i_pos">Detent centre.</param>
-bool TFV4aM::EQ(double pos, double i_pos)
+bool TFV4aM::EQ(const double pos, const double i_pos)
 {
 	return pos <= i_pos + 0.5 && pos > i_pos - 0.5;
 }
@@ -3291,7 +3291,7 @@ bool TFV4aM::EQ(double pos, double i_pos)
 /// <param name="dt">Time step [s].</param>
 /// <param name="ep">EP / equalising input [bar].</param>
 /// <returns>Brake pipe volume change for this step.</returns>
-double TMHZ_EN57::GetPF(double i_bcp, double PP, double HP, double dt, double ep)
+double TMHZ_EN57::GetPF(double i_bcp, const double PP, const double HP, const double dt, double ep)
 {
 	static constexpr int LBDelay = 100;
 
@@ -3387,21 +3387,21 @@ double TMHZ_EN57::GetPF(double i_bcp, double PP, double HP, double dt, double ep
 
 /// <summary>Initialises CP to the supplied pressure.</summary>
 /// <param name="Press">Initial pressure [bar].</param>
-void TMHZ_EN57::Init(double Press)
+void TMHZ_EN57::Init(const double Press)
 {
 	CP = Press;
 }
 
 /// <summary>Sets the reductor adjustment offset.</summary>
 /// <param name="nAdj">Pressure correction [bar].</param>
-void TMHZ_EN57::SetReductor(double nAdj)
+void TMHZ_EN57::SetReductor(const double nAdj)
 {
 	RedAdj = nAdj;
 }
 
 /// <summary>Returns Sounds[i] for valid indices, 0 otherwise.</summary>
 /// <param name="i">Sound channel index.</param>
-double TMHZ_EN57::GetSound(int i)
+double TMHZ_EN57::GetSound(const int i)
 {
 	if (i > 4)
 		return 0;
@@ -3411,7 +3411,7 @@ double TMHZ_EN57::GetSound(int i)
 
 /// <summary>Returns pos_table[i].</summary>
 /// <param name="i">Function code (bh_*).</param>
-double TMHZ_EN57::GetPos(int i)
+double TMHZ_EN57::GetPos(const int i)
 {
 	return pos_table[i];
 }
@@ -3433,7 +3433,7 @@ double TMHZ_EN57::GetRP()
 /// (linear ramp 0..1 between positions 0 and 8, zero above 9.5).
 /// </summary>
 /// <param name="pos">Handle position.</param>
-double TMHZ_EN57::GetEP(double pos)
+double TMHZ_EN57::GetEP(const double pos)
 {
 	if (pos < 9.5)
 		return std::clamp(0.125 * pos, 0., 1.);
@@ -3448,7 +3448,7 @@ double TMHZ_EN57::GetEP(double pos)
 /// </summary>
 /// <param name="pos">Continuous handle position.</param>
 /// <returns>Target brake-pipe pressure [bar].</returns>
-double TMHZ_EN57::LPP_RP(double pos) // cisnienie z zaokraglonej pozycji;
+double TMHZ_EN57::LPP_RP(const double pos) // cisnienie z zaokraglonej pozycji;
 {
 	if (pos > 8.5)
 		return 5.0 - 0.15 * pos - 0.35;
@@ -3470,7 +3470,7 @@ double TMHZ_EN57::LPP_RP(double pos) // cisnienie z zaokraglonej pozycji;
 /// <param name="OverP">Unbrake over-pressure [bar].</param>
 /// <param name="OMP">Overload (assimilation) max pressure.</param>
 /// <param name="OPD">Overload pressure decay rate.</param>
-void TMHZ_EN57::SetParams(bool AO, bool MO, double OverP, double, double OMP, double OPD)
+void TMHZ_EN57::SetParams(const bool AO, const bool MO, const double OverP, double, const double OMP, const double OPD)
 {
 	AutoOvrld = AO;
 	ManualOvrld = MO;
@@ -3481,7 +3481,7 @@ void TMHZ_EN57::SetParams(bool AO, bool MO, double OverP, double, double OMP, do
 }
 
 /// <summary>Returns true if pos is within ±0.5 of i_pos (detent test).</summary>
-bool TMHZ_EN57::EQ(double pos, double i_pos)
+bool TMHZ_EN57::EQ(const double pos, const double i_pos)
 {
 	return pos <= i_pos + 0.5 && pos > i_pos - 0.5;
 }
@@ -3500,7 +3500,7 @@ bool TMHZ_EN57::EQ(double pos, double i_pos)
 /// <param name="dt">Time step [s].</param>
 /// <param name="ep">EP / equalising input [bar].</param>
 /// <returns>Brake pipe volume change for this step.</returns>
-double TMHZ_K5P::GetPF(double i_bcp, double PP, double HP, double dt, double ep)
+double TMHZ_K5P::GetPF(double i_bcp, const double PP, const double HP, const double dt, double ep)
 {
 	static constexpr int LBDelay = 100;
 
@@ -3599,7 +3599,7 @@ double TMHZ_K5P::GetPF(double i_bcp, double PP, double HP, double dt, double ep)
 
 /// <summary>Initialises CP and enables the time / EP-time chambers.</summary>
 /// <param name="Press">Initial pressure [bar].</param>
-void TMHZ_K5P::Init(double Press)
+void TMHZ_K5P::Init(const double Press)
 {
 	CP = Press;
 	Time = true;
@@ -3608,14 +3608,14 @@ void TMHZ_K5P::Init(double Press)
 
 /// <summary>Sets the reductor adjustment offset.</summary>
 /// <param name="nAdj">Pressure correction [bar].</param>
-void TMHZ_K5P::SetReductor(double nAdj)
+void TMHZ_K5P::SetReductor(const double nAdj)
 {
 	RedAdj = nAdj;
 }
 
 /// <summary>Returns Sounds[i] for valid indices, 0 otherwise.</summary>
 /// <param name="i">Sound channel index.</param>
-double TMHZ_K5P::GetSound(int i)
+double TMHZ_K5P::GetSound(const int i)
 {
 	if (i > 4)
 		return 0;
@@ -3625,7 +3625,7 @@ double TMHZ_K5P::GetSound(int i)
 
 /// <summary>Returns pos_table[i].</summary>
 /// <param name="i">Function code (bh_*).</param>
-double TMHZ_K5P::GetPos(int i)
+double TMHZ_K5P::GetPos(const int i)
 {
 	return pos_table[i];
 }
@@ -3653,7 +3653,7 @@ double TMHZ_K5P::GetRP()
 /// <param name="FSF">Filling-stroke factor offset (FillingStrokeFactor = 1 + FSF).</param>
 /// <param name="OMP">Overload max pressure.</param>
 /// <param name="OPD">Overload pressure decay rate.</param>
-void TMHZ_K5P::SetParams(bool AO, bool MO, double OverP, double FSF, double OMP, double OPD)
+void TMHZ_K5P::SetParams(const bool AO, const bool MO, const double OverP, const double FSF, const double OMP, const double OPD)
 {
 	AutoOvrld = AO;
 	ManualOvrld = MO;
@@ -3665,7 +3665,7 @@ void TMHZ_K5P::SetParams(bool AO, bool MO, double OverP, double FSF, double OMP,
 }
 
 /// <summary>Returns true if pos is within ±0.5 of i_pos (detent test).</summary>
-bool TMHZ_K5P::EQ(double pos, double i_pos)
+bool TMHZ_K5P::EQ(const double pos, const double i_pos)
 {
 	return pos <= i_pos + 0.5 && pos > i_pos - 0.5;
 }
@@ -3683,7 +3683,7 @@ bool TMHZ_K5P::EQ(double pos, double i_pos)
 /// <param name="dt">Time step [s].</param>
 /// <param name="ep">EP / equalising input [bar].</param>
 /// <returns>Brake pipe volume change for this step.</returns>
-double TMHZ_6P::GetPF(double i_bcp, double PP, double HP, double dt, double ep)
+double TMHZ_6P::GetPF(double i_bcp, const double PP, const double HP, const double dt, double ep)
 {
 	static constexpr int LBDelay = 100;
 
@@ -3782,7 +3782,7 @@ double TMHZ_6P::GetPF(double i_bcp, double PP, double HP, double dt, double ep)
 
 /// <summary>Initialises CP and enables the time / EP-time chambers.</summary>
 /// <param name="Press">Initial pressure [bar].</param>
-void TMHZ_6P::Init(double Press)
+void TMHZ_6P::Init(const double Press)
 {
 	CP = Press;
 	Time = true;
@@ -3791,14 +3791,14 @@ void TMHZ_6P::Init(double Press)
 
 /// <summary>Sets the reductor adjustment offset.</summary>
 /// <param name="nAdj">Pressure correction [bar].</param>
-void TMHZ_6P::SetReductor(double nAdj)
+void TMHZ_6P::SetReductor(const double nAdj)
 {
 	RedAdj = nAdj;
 }
 
 /// <summary>Returns Sounds[i] for valid indices, 0 otherwise.</summary>
 /// <param name="i">Sound channel index.</param>
-double TMHZ_6P::GetSound(int i)
+double TMHZ_6P::GetSound(const int i)
 {
 	if (i > 4)
 		return 0;
@@ -3808,7 +3808,7 @@ double TMHZ_6P::GetSound(int i)
 
 /// <summary>Returns pos_table[i].</summary>
 /// <param name="i">Function code (bh_*).</param>
-double TMHZ_6P::GetPos(int i)
+double TMHZ_6P::GetPos(const int i)
 {
 	return pos_table[i];
 }
@@ -3836,7 +3836,7 @@ double TMHZ_6P::GetRP()
 /// <param name="FSF">Filling-stroke factor offset.</param>
 /// <param name="OMP">Overload max pressure.</param>
 /// <param name="OPD">Overload pressure decay rate.</param>
-void TMHZ_6P::SetParams(bool AO, bool MO, double OverP, double FSF, double OMP, double OPD)
+void TMHZ_6P::SetParams(const bool AO, const bool MO, const double OverP, const double FSF, const double OMP, const double OPD)
 {
 	AutoOvrld = AO;
 	ManualOvrld = MO;
@@ -3848,7 +3848,7 @@ void TMHZ_6P::SetParams(bool AO, bool MO, double OverP, double FSF, double OMP,
 }
 
 /// <summary>Returns true if pos is within ±0.5 of i_pos (detent test).</summary>
-bool TMHZ_6P::EQ(double pos, double i_pos)
+bool TMHZ_6P::EQ(const double pos, const double i_pos)
 {
 	return pos <= i_pos + 0.5 && pos > i_pos - 0.5;
 }
@@ -3867,7 +3867,7 @@ bool TMHZ_6P::EQ(double pos, double i_pos)
 /// <param name="dt">Time step [s].</param>
 /// <param name="ep">EP / equalising input [bar].</param>
 /// <returns>Brake pipe volume change for this step.</returns>
-double TM394::GetPF(double i_bcp, double PP, double HP, double dt, double ep)
+double TM394::GetPF(const double i_bcp, const double PP, const double HP, const double dt, double ep)
 {
 	static constexpr int LBDelay = 65;
 
@@ -3916,7 +3916,7 @@ double TM394::GetPF(double i_bcp, double PP, double HP, double dt, double ep)
 
 /// <summary>Initialises CP and enables the time chamber.</summary>
 /// <param name="Press">Initial pressure [bar].</param>
-void TM394::Init(double Press)
+void TM394::Init(const double Press)
 {
 	CP = Press;
 	Time = true;
@@ -3924,7 +3924,7 @@ void TM394::Init(double Press)
 
 /// <summary>Sets the reductor adjustment offset.</summary>
 /// <param name="nAdj">Pressure correction [bar].</param>
-void TM394::SetReductor(double nAdj)
+void TM394::SetReductor(const double nAdj)
 {
 	RedAdj = nAdj;
 }
@@ -3943,7 +3943,7 @@ double TM394::GetRP()
 
 /// <summary>Returns pos_table[i].</summary>
 /// <param name="i">Function code (bh_*).</param>
-double TM394::GetPos(int i)
+double TM394::GetPos(const int i)
 {
 	return pos_table[i];
 }
@@ -3963,7 +3963,7 @@ double TM394::GetPos(int i)
 /// <param name="dt">Time step [s].</param>
 /// <param name="ep">EP / equalising input [bar].</param>
 /// <returns>Brake pipe volume change for this step.</returns>
-double TH14K1::GetPF(double i_bcp, double PP, double HP, double dt, double ep)
+double TH14K1::GetPF(const double i_bcp, const double PP, const double HP, const double dt, double ep)
 {
 	constexpr int LBDelay = 100; // szybkosc + zasilanie sterujacego
 	//   static double const BPT_K[/*?*/ /*-1..4*/ (4) - (-1) + 1][2] =
@@ -4009,7 +4009,7 @@ double TH14K1::GetPF(double i_bcp, double PP, double HP, double dt, double ep)
 
 /// <summary>Initialises CP and enables the time / EP-time chambers.</summary>
 /// <param name="Press">Initial pressure [bar].</param>
-void TH14K1::Init(double Press)
+void TH14K1::Init(const double Press)
 {
 	CP = Press;
 	Time = true;
@@ -4018,7 +4018,7 @@ void TH14K1::Init(double Press)
 
 /// <summary>Sets the reductor adjustment offset.</summary>
 /// <param name="nAdj">Pressure correction [bar].</param>
-void TH14K1::SetReductor(double nAdj)
+void TH14K1::SetReductor(const double nAdj)
 {
 	RedAdj = nAdj;
 }
@@ -4037,7 +4037,7 @@ double TH14K1::GetRP()
 
 /// <summary>Returns pos_table[i].</summary>
 /// <param name="i">Function code (bh_*).</param>
-double TH14K1::GetPos(int i)
+double TH14K1::GetPos(const int i)
 {
 	return pos_table[i];
 }
@@ -4055,7 +4055,7 @@ double TH14K1::GetPos(int i)
 /// <param name="dt">Time step [s].</param>
 /// <param name="ep">EP / equalising input [bar].</param>
 /// <returns>Brake pipe volume change for this step.</returns>
-double TSt113::GetPF(double i_bcp, double PP, double HP, double dt, double ep)
+double TSt113::GetPF(const double i_bcp, const double PP, const double HP, const double dt, double ep)
 {
 	static constexpr int LBDelay = 100; // szybkosc + zasilanie sterujacego
 	static constexpr double NomPress = 5.0;
@@ -4121,7 +4121,7 @@ double TSt113::GetEP()
 
 /// <summary>Returns pos_table[i].</summary>
 /// <param name="i">Function code (bh_*).</param>
-double TSt113::GetPos(int i)
+double TSt113::GetPos(const int i)
 {
 	return pos_table[i];
 }
@@ -4147,7 +4147,7 @@ void TSt113::Init(double Press)
 /// <param name="dt">Time step [s].</param>
 /// <param name="ep">EP / equalising input [bar].</param>
 /// <returns>Brake pipe volume change for this step.</returns>
-double Ttest::GetPF(double i_bcp, double PP, double HP, double dt, double ep)
+double Ttest::GetPF(const double i_bcp, const double PP, const double HP, const double dt, double ep)
 {
 	static constexpr int LBDelay = 100;
 
@@ -4182,7 +4182,7 @@ double Ttest::GetPF(double i_bcp, double PP, double HP, double dt, double ep)
 
 /// <summary>Initialises CP to the supplied pressure.</summary>
 /// <param name="Press">Initial pressure [bar].</param>
-void Ttest::Init(double Press)
+void Ttest::Init(const double Press)
 {
 	CP = Press;
 }
@@ -4200,7 +4200,7 @@ void Ttest::Init(double Press)
 /// <param name="dt">Time step [s].</param>
 /// <param name="ep">EP / equalising input (unused).</param>
 /// <returns>Negated cylinder pressure delta for this step.</returns>
-double TFD1::GetPF(double i_bcp, double PP, double HP, double dt, double ep)
+double TFD1::GetPF(const double i_bcp, double PP, const double HP, const double dt, double ep)
 {
 	double DP;
 	double temp;
@@ -4215,7 +4215,7 @@ double TFD1::GetPF(double i_bcp, double PP, double HP, double dt, double ep)
 
 /// <summary>Initialises MaxBP and the action speed (defaults to 1.0).</summary>
 /// <param name="Press">Maximum cylinder pressure [bar].</param>
-void TFD1::Init(double Press)
+void TFD1::Init(const double Press)
 {
 	MaxBP = Press;
 	Speed = 1.0;
@@ -4229,7 +4229,7 @@ double TFD1::GetCP()
 
 /// <summary>Sets the action speed multiplier (scales the response time).</summary>
 /// <param name="nSpeed">Speed multiplier.</param>
-void TFD1::SetSpeed(double nSpeed)
+void TFD1::SetSpeed(const double nSpeed)
 {
 	Speed = nSpeed;
 }
@@ -4248,7 +4248,7 @@ void TFD1::SetSpeed(double nSpeed)
 /// <param name="dt">Time step [s].</param>
 /// <param name="ep">EP / equalising input (unused).</param>
 /// <returns>Negated cylinder pressure delta for this step.</returns>
-double TH1405::GetPF(double i_bcp, double PP, double HP, double dt, double ep)
+double TH1405::GetPF(const double i_bcp, double PP, const double HP, const double dt, double ep)
 {
 	double DP;
 	double temp;
@@ -4274,7 +4274,7 @@ double TH1405::GetPF(double i_bcp, double PP, double HP, double dt, double ep)
 
 /// <summary>Initialises MaxBP and enables the time chamber.</summary>
 /// <param name="Press">Maximum cylinder pressure [bar].</param>
-void TH1405::Init(double Press)
+void TH1405::Init(const double Press)
 {
 	MaxBP = Press;
 	Time = true;
@@ -4300,7 +4300,7 @@ double TH1405::GetCP()
 /// <param name="dt">Time step [s].</param>
 /// <param name="ep">EP / equalising input (unused).</param>
 /// <returns>Brake pipe volume change for this step.</returns>
-double TFVel6::GetPF(double i_bcp, double PP, double HP, double dt, double ep)
+double TFVel6::GetPF(const double i_bcp, const double PP, const double HP, const double dt, double ep)
 {
 	static constexpr int LBDelay = 100;
 
@@ -4361,14 +4361,14 @@ double TFVel6::GetEP()
 
 /// <summary>Returns pos_table[i].</summary>
 /// <param name="i">Function code (bh_*).</param>
-double TFVel6::GetPos(int i)
+double TFVel6::GetPos(const int i)
 {
 	return pos_table[i];
 }
 
 /// <summary>Returns Sounds[i] for valid indices, 0 otherwise.</summary>
 /// <param name="i">Sound channel index (0..2).</param>
-double TFVel6::GetSound(int i)
+double TFVel6::GetSound(const int i)
 {
 	if (i > 2)
 		return 0;
@@ -4397,7 +4397,7 @@ void TFVel6::Init(double Press)
 /// <param name="dt">Time step [s].</param>
 /// <param name="ep">EP / equalising input (unused).</param>
 /// <returns>Brake pipe volume change for this step.</returns>
-double TFVE408::GetPF(double i_bcp, double PP, double HP, double dt, double ep)
+double TFVE408::GetPF(const double i_bcp, const double PP, const double HP, const double dt, double ep)
 {
 	static constexpr int LBDelay = 100;
 
@@ -4464,14 +4464,14 @@ double TFVE408::GetRP()
 
 /// <summary>Returns pos_table[i].</summary>
 /// <param name="i">Function code (bh_*).</param>
-double TFVE408::GetPos(int i)
+double TFVE408::GetPos(const int i)
 {
 	return pos_table[i];
 }
 
 /// <summary>Returns Sounds[i] for valid indices, 0 otherwise.</summary>
 /// <param name="i">Sound channel index (0..2).</param>
-double TFVE408::GetSound(int i)
+double TFVE408::GetSound(const int i)
 {
 	if (i > 2)
 		return 0;

McZapkie/hamulce.h

@@ -500,7 +500,7 @@ class TBrake
 	virtual void SetED(double const EDstate) {}; // stan hamulca ED do luzowania
 	/// <summary>Sets the universal-button flags (see TUniversalBrake).</summary>
 	/// <param name="flag">Combined ub_* flags.</param>
-	virtual void SetUniversalFlag(int flag)
+	virtual void SetUniversalFlag(const int flag)
 	{
 		UniversalFlag = flag;
 	} // przycisk uniwersalny
@@ -556,7 +556,7 @@ class TWest : public TBrake
 	void SetLP(double TM, double LM, double TBP); // parametry przystawki wazacej
 
 	/// <summary>Constructs the distributor by forwarding all parameters to TBrake.</summary>
-	TWest(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) : TBrake(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa) {}
+	TWest(const double i_mbp, const double i_bcr, const double i_bcd, const double i_brc, const int i_bcn, const int i_BD, const int i_mat, const int i_ba, const int i_nbpa) : TBrake(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa) {}
 };
 
 /// <summary>
@@ -614,7 +614,7 @@ class TESt : public TBrake
 	void ForceEmptiness() /*override*/; // wymuszenie bycia pustym
 
 	/// <summary>Constructs the ESt distributor and creates the control reservoir.</summary>
-	TESt(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) : TBrake(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa)
+	TESt(const double i_mbp, const double i_bcr, const double i_bcd, const double i_brc, const int i_bcn, const int i_BD, const int i_mat, const int i_ba, const int i_nbpa) : TBrake(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa)
 	{
 		CntrlRes = std::make_shared<TReservoir>();
 	}
@@ -636,7 +636,7 @@ class TESt3 : public TESt
 	double GetPF(double PP, double dt, double Vel) /*override*/; // przeplyw miedzy komora wstepna i PG
 
 	/// <summary>Constructs the ESt3 distributor.</summary>
-	TESt3(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) : TESt(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa) {}
+	TESt3(const double i_mbp, const double i_bcr, const double i_bcd, const double i_brc, const int i_bcn, const int i_BD, const int i_mat, const int i_ba, const int i_nbpa) : TESt(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa) {}
 };
 
 /// <summary>
@@ -669,7 +669,7 @@ class TESt3AL2 : public TESt3
 	void SetLP(double TM, double LM, double TBP); // parametry przystawki wazacej
 
 	/// <summary>Constructs the distributor and creates the impulse chamber.</summary>
-	TESt3AL2(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) : TESt3(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa)
+	TESt3AL2(const double i_mbp, const double i_bcr, const double i_bcd, const double i_brc, const int i_bcn, const int i_BD, const int i_mat, const int i_ba, const int i_nbpa) : TESt3(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa)
 	{
 		ImplsRes = std::make_shared<TReservoir>();
 	}
@@ -700,7 +700,7 @@ class TESt4R : public TESt
 	double GetPF(double PP, double dt, double Vel) /*override*/; // przeplyw miedzy komora wstepna i PG
 
 	/// <summary>Constructs the distributor and creates the impulse chamber.</summary>
-	TESt4R(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) : TESt(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa)
+	TESt4R(const double i_mbp, const double i_bcr, const double i_bcd, const double i_brc, const int i_bcn, const int i_BD, const int i_mat, const int i_ba, const int i_nbpa) : TESt(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa)
 	{
 		ImplsRes = std::make_shared<TReservoir>();
 	}
@@ -743,7 +743,7 @@ class TLSt : public TESt4R
 	virtual void SetED(double EDstate); // stan hamulca ED do luzowania
 
 	/// <summary>Constructs the LSt distributor.</summary>
-	TLSt(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) : TESt4R(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa) {}
+	TLSt(const double i_mbp, const double i_bcr, const double i_bcd, const double i_brc, const int i_bcn, const int i_BD, const int i_mat, const int i_ba, const int i_nbpa) : TESt4R(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa) {}
 };
 
 /// <summary>
@@ -826,7 +826,7 @@ class TEStEP2 : public TLSt
 	void virtual EPCalc(double dt);
 
 	/// <summary>Constructs the EP2 distributor.</summary>
-	TEStEP2(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) : TLSt(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa) {}
+	TEStEP2(const double i_mbp, const double i_bcr, const double i_bcd, const double i_brc, const int i_bcn, const int i_BD, const int i_mat, const int i_ba, const int i_nbpa) : TLSt(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa) {}
 };
 
 /// <summary>
@@ -845,7 +845,7 @@ class TEStEP1 : public TEStEP2
 	void SetEPS(double nEPS) override; // stan hamulca EP
 
 	/// <summary>Constructs the EP1 distributor.</summary>
-	TEStEP1(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) : TEStEP2(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa)
+	TEStEP1(const double i_mbp, const double i_bcr, const double i_bcd, const double i_brc, const int i_bcn, const int i_BD, const int i_mat, const int i_ba, const int i_nbpa) : TEStEP2(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa)
 	{
 	}
 };
@@ -884,7 +884,7 @@ class TCV1 : public TBrake
 	void ForceEmptiness() /*override*/; // wymuszenie bycia pustym
 
 	/// <summary>Constructs the CV1 distributor and creates the control reservoir.</summary>
-	TCV1(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) : TBrake(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa)
+	TCV1(const double i_mbp, const double i_bcr, const double i_bcd, const double i_brc, const int i_bcn, const int i_BD, const int i_mat, const int i_ba, const int i_nbpa) : TBrake(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa)
 	{
 		CntrlRes = std::make_shared<TReservoir>();
 	}
@@ -931,7 +931,7 @@ class TCV1L_TR : public TCV1
 	double GetHPFlow(double HP, double dt) /*override*/; // przeplyw - 8 bar
 
 	/// <summary>Constructs the CV1-L-TR and creates the impulse chamber.</summary>
-	TCV1L_TR(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) : TCV1(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa)
+	TCV1L_TR(const double i_mbp, const double i_bcr, const double i_bcd, const double i_brc, const int i_bcn, const int i_BD, const int i_mat, const int i_ba, const int i_nbpa) : TCV1(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa)
 	{
 		ImplsRes = std::make_shared<TReservoir>();
 	}
@@ -998,7 +998,7 @@ class TKE : public TBrake
 	void ForceEmptiness() /*override*/; // wymuszenie bycia pustym
 
 	/// <summary>Constructs the KE distributor and creates the control / impulse / secondary reservoirs.</summary>
-	TKE(double i_mbp, double i_bcr, double i_bcd, double i_brc, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa) : TBrake(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa)
+	TKE(const double i_mbp, const double i_bcr, const double i_bcd, const double i_brc, const int i_bcn, const int i_BD, const int i_mat, const int i_ba, const int i_nbpa) : TBrake(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa)
 	{
 		ImplsRes = std::make_shared<TReservoir>();
 		CntrlRes = std::make_shared<TReservoir>();