From fcd06c35c59f6374161cebaa7e039ba84860409d Mon Sep 17 00:00:00 2001 From: firleju Date: Wed, 14 Sep 2016 22:19:47 +0200 Subject: [PATCH] =?UTF-8?q?Translacja=20Oerlikon=5FEst.=20Pliki=20wynikowe?= =?UTF-8?q?=20z=20t=C5=82umacza.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- McZapkie/Oerlikon_ESt.cpp | 625 ++++++++++++++++++++++++++++++++++++++ McZapkie/Oerlikon_ESt.h | 236 ++++++++++++++ 2 files changed, 861 insertions(+) create mode 100644 McZapkie/Oerlikon_ESt.cpp create mode 100644 McZapkie/Oerlikon_ESt.h diff --git a/McZapkie/Oerlikon_ESt.cpp b/McZapkie/Oerlikon_ESt.cpp new file mode 100644 index 00000000..95c7171c --- /dev/null +++ b/McZapkie/Oerlikon_ESt.cpp @@ -0,0 +1,625 @@ +/* +This Source Code Form is subject to the +terms of the Mozilla Public License, v. +2.0. If a copy of the MPL was not +distributed with this file, You can +obtain one at +http://mozilla.org/MPL/2.0/. +*/ +/* +MaSzyna EU07 - SPKS +Brakes. Oerlikon ESt. +Copyright (C) 2007-2014 Maciej Cierniak +*/ + +#include "Oerlikon_ESt.h" + +double d2A(double d) +{ double result; + d2A =( d*d )*0.7854*1.0/1000; +return result; +} + +// ------ RURA ------ + +double TRura::P() +{ double result; + P =Next.P; +return result; +} + +void TRura::Update(double dt) +{ + Next.Flow( dVol ); + dVol =0; +} + +// ------ PRZECIWPOSLIG ------ + +void TPrzeciwposlizg::SetPoslizg(bool flag) +{ + Poslizg =flag; +} + +void TPrzeciwposlizg::Update(double dt) +{ + if( ( Poslizg ) ) + { + BrakeRes.Flow( dVol ); + Next.Flow( PF( Next.P, 0, d2A( 10 ) )*dt ); + } + else + Next.Flow( dVol ); + dVol =0; +} + + +// ------ PRZEKLADNIK ------ + +void TPrzekladnik::Update(double dt) +{ double BCP; double BVP; double dV; + + + BCP =Next.P; + BVP =BrakeRes.P; + + if( ( BCP>P ) ) + dV =-PFVd( BCP, 0, d2A( 10 ), P )*dt;else + if( ( BCP

0 ) + BrakeRes.Flow( -dV ); + +} + +// ------ PRZEKLADNIK RAPID ------ + +void TRapid::SetRapidParams(double mult, double size) +{ + RapidMult =mult; + RapidStatus =false; + if( ( size>0.1 ) ) //dopasowywanie srednicy przekladnika + { + DN =d2A( size*0.4 ); + DL =d2A( size*0.4 ); + } + else + { + DN =d2A( 5 ); + DL =d2A( 5 ); + } +} + +void TRapid::SetRapidStatus(bool rs) +{ + RapidStatus =rs; +} + +void TRapid::Update(double dt) +{ double BCP; double BVP; double dV; double ActMult; + + BVP =BrakeRes.P; + BCP =Next.P; + + if( ( RapidStatus ) ) + { + ActMult =RapidMult; + } + else + { + ActMult =1; + } + + if( ( BCP*RapidMult>P*ActMult ) ) + dV =-PFVd( BCP, 0, DL, P*ActMult*1.0/RapidMult )*dt;else + if( ( BCP*RapidMult0 ) + BrakeRes.Flow( -dV ); + +} + +// ------ PRZEKŁADNIK CIĄGŁY ------ + +void TPrzekCiagly::SetMult(double m) +{ + mult =m; +} + +void TPrzekCiagly::Update(double dt) +{ double BCP; double BVP; double dV; + + BVP =BrakeRes.P; + BCP =Next.P; + + if( ( BCP>P*mult ) ) + dV =-PFVd( BCP, 0, d2A( 8 ), P*mult )*dt;else + if( ( BCP0 ) + BrakeRes.Flow( -dV ); + +} + +// ------ PRZEKŁADNIK CIĄGŁY ------ + +void TPrzek_PZZ::SetLBP(double P) +{ + LBP =P; +} + +void TPrzek_PZZ::Update(double dt) +{ double BCP; double BVP; double dV; double Pgr; + + BVP =BrakeRes.P; + BCP =Next.P; + + Pgr =Max0R( LBP, P ); + + if( ( BCP>Pgr ) ) + dV =-PFVd( BCP, 0, d2A( 8 ), Pgr )*dt;else + if( ( BCP0 ) + BrakeRes.Flow( -dV ); + +} + +// ------ PRZECIWPOSLIG ------ + +void TPrzekED::SetP(double P) +{ + MaxP =P; +} + +void TPrzekED::Update(double dt) +{ + if( Next.P>MaxP ) + { + BrakeRes.Flow( dVol ); + Next.Flow( PFVd( Next.P, 0, d2A( 10 )*dt, MaxP ) ); + } + else + Next.Flow( dVol ); + dVol =0; +} + + +// ------ OERLIKON EST NA BOGATO ------ + +double TNESt3::GetPF(double PP, double dt, double Vel) //przeplyw miedzy komora wstepna i PG +{ double result; double dV; double dV1; double temp; + double VVP; double BVP; double BCP; double CVP; double MPP; double nastG; + unsigned char i; + + BVP =BrakeRes.P; + VVP =ValveRes.P; +// BCP:=BrakeCyl.P; + BCP =Przekladniki[ 1 ].P; + CVP =CntrlRes.P-0.0; + MPP =Miedzypoj.P; + dV1 =0; + + nastG =( BrakeDelayFlag && bdelay_G ); + +//sprawdzanie stanu + CheckState( BCP , dV1 ); + CheckReleaser( dt ); + +//luzowanie + if( ( BrakeStatus && b_hld )==b_off ) + dV =PF( 0, BCP, Nozzles[ dTO ]*nastG+( 1-nastG )*Nozzles[ dOO ] )*dt*( 0.1+4.9*Min0R( 0.2, BCP-( ( CVP-0.05-VVP )*BVM+0.1 ) ) );else dV =0; +// BrakeCyl.Flow(-dV); + Przekladniki[ 1 ].Flow( -dV ); + if( ( ( BrakeStatus && b_on )==b_on )&&( Przekladniki[ 1 ].P*HBG30070 ) || ( ( RapidStatus ) && ( abs( Vel )>50 ) ) || ( RapidStaly ) ) ); + ( Przekladniki[ i ] as TRapid ).SetRapidStatus( RapidStatus ); + } + else + if( ( Przekladniki[ i ] is TPrzeciwposlizg ) ) + ( Przekladniki[ i ] as TPrzeciwposlizg ).SetPoslizg( ( BrakeStatus && b_asb )==b_asb );else + if( ( Przekladniki[ i ] is TPrzekED ) ) + if( ( Vel<-15 ) ) + ( Przekladniki[ i ] as TPrzekED ).SetP( 0 );else ( Przekladniki[ i ] as TPrzekED ).SetP( MaxBP*3 );else + if( ( Przekladniki[ i ] is TPrzekCiagly ) ) + ( Przekladniki[ i ] as TPrzekCiagly ).SetMult( LoadC );else + if( ( Przekladniki[ i ] is TPrzek_PZZ ) ) + ( Przekladniki[ i ] as TPrzek_PZZ ).SetLBP( LBP ); + }} + + +//przeplyw testowy miedzypojemnosci + dV =PF( MPP, VVP, BVs( BCP ) )+PF( MPP, CVP, CVs( BCP ) ); + if( ( MPP-0.05>BVP ) ) + dV =dV+PF( MPP-0.05, BVP, Nozzles[ dPT ]*nastG+( 1-nastG )*Nozzles[ dPO ] ); + if( MPP>VVP ) dV =dV+PF( MPP, VVP, d2A( 5 ) ); + Miedzypoj.Flow( dV*dt*0.15 ); + + +//przeplyw ZS <-> PG + temp =CVs( BCP ); + dV =PF( CVP, MPP, temp )*dt; + CntrlRes.Flow( +dV ); + ValveRes.Flow( -0.02*dV ); + dV1 =dV1+0.98*dV; + +//przeplyw ZP <-> MPJ + if( ( MPP-0.05>BVP ) ) + dV =PF( BVP, MPP-0.05, Nozzles[ dPT ]*nastG+( 1-nastG )*Nozzles[ dPO ] )*dt;else dV =0; + BrakeRes.Flow( dV ); + dV1 =dV1+dV*0.98; + ValveRes.Flow( -0.02*dV ); +//przeplyw PG <-> rozdzielacz + dV =PF( PP, VVP, 0.005 )*dt; //0.01 + ValveRes.Flow( -dV ); + + + ValveRes.Act; + BrakeCyl.Act; + BrakeRes.Act; + CntrlRes.Act; + Miedzypoj.Act; + Przekladniki[ 1 ].Act; + Przekladniki[ 2 ].Act; + Przekladniki[ 3 ].Act; + GetPF =dV-dV1; +return result; +} + + +void TNESt3::EStParams(double i_crc) //parametry charakterystyczne dla ESt +{ + +} + + +void TNESt3::Init(double PP, double HPP, double LPP, double BP, unsigned char BDF) +{ + ValveRes.CreatePress( 1*PP ); + BrakeCyl.CreatePress( 1*BP ); + BrakeRes.CreatePress( 1*PP ); + CntrlRes =TReservoir.Create; + CntrlRes.CreateCap( 15 ); + CntrlRes.CreatePress( 1*HPP ); + BrakeStatus =unsigned char( BP>1 )*1; + Miedzypoj =TReservoir.Create; + Miedzypoj.CreateCap( 5 ); + Miedzypoj.CreatePress( PP ); + + BVM =1*1.0/( HPP-0.05-LPP )*MaxBP; + + BrakeDelayFlag =BDF; + + Zamykajacy =false; + + if( !( ( FM is TDisk1 ) || ( FM is TDisk2 ) ) ) //jesli zeliwo to schodz + RapidStaly =false;else + RapidStaly =true; + +} + + +double TNESt3::GetCRP() +{ double result; + GetCRP =CntrlRes.P; +// GetCRP:=Przekladniki[1].P; +// GetCRP:=Miedzypoj.P; +return result; +} + + +void TNESt3::CheckState(double BCP, double & dV1) //glowny przyrzad rozrzadczy +{ double VVP; double BVP; double CVP; double MPP; + + BVP =BrakeRes.P; //-> tu ma byc komora rozprezna + VVP =ValveRes.P; + CVP =CntrlRes.P; + MPP =Miedzypoj.P; + + if( ( BCP<0.25 )&&( VVP+0.08>CVP ) ) Przys_blok =false; + +//sprawdzanie stanu +// if ((BrakeStatus and 1)=1)and(BCP>0.25)then + if( ( VVP+0.01+BCP*1.0/BVMCVP-0.05 ) ) + BrakeStatus =( BrakeStatus && 252 ) //luzowanie;else if( ( VVP+BCP*1.0/BVM>CVP-0.05 ) ) + BrakeStatus =( BrakeStatus && 253 ) //zatrzymanie napelaniania;else if( ( VVP+( BCP-0.1 )*1.0/BVM0.25 ) ) //zatrzymanie luzowania + BrakeStatus =( BrakeStatus || 1 ); + + if( ( BrakeStatus && 1 )==0 ) + SoundFlag =SoundFlag || sf_CylU; + + if( ( VVP+0.100.5 ) ) + Zamykajacy =true;else if( ( VVP-0.6 PG + if( ( MPPCVP-0.08 ) ) + CVs =Nozzles[ dSd ];else + CVs =Nozzles[ dSm ]; +return result; +} + + +double TNESt3::BVs(double BCP) //napelniacz pomocniczego +{ double result; double CVP; double MPP; + + CVP =CntrlRes.P; + MPP =Miedzypoj.P; + +//przeplyw ZP <-> rozdzielacz + if( ( MPP0 ) + { + Podskok =0.7; + Przekladniki[ 1 ] =TRura.Create; + Przekladniki[ 3 ] =TRura.Create; + } + else + { + Podskok =-1; + Przekladniki[ 1 ] =TRapid.Create; + if( Pos( "-s216", params )>0 ) + ( Przekladniki[ 1 ] as TRapid ).SetRapidParams( 2, 16 );else + ( Przekladniki[ 1 ] as TRapid ).SetRapidParams( 2, 0 ); + Przekladniki[ 3 ] =TPrzeciwposlizg.Create; + if( Pos( "-ED", params )>0 ) + { + Przekladniki[ 3 ].Free( ); + ( Przekladniki[ 1 ] as TRapid ).SetRapidParams( 2, 18 ); + Przekladniki[ 3 ] =TPrzekED.Create; + } + } + + if( Pos( "AL2", params )>0 ) + Przekladniki[ 2 ] =TPrzekCiagly.Create;else + if( Pos( "PZZ", params )>0 ) + Przekladniki[ 2 ] =TPrzek_PZZ.Create;else + Przekladniki[ 2 ] =TRura.Create; + + if( ( Pos( "3d", params )+Pos( "4d", params )>0 ) ) autom =false;else autom =true; + if( ( Pos( "HBG300", params )>0 ) ) HBG300 =1;else HBG300 =0; + + switch( size ) { + case 16: + { //dON,dOO,dTN,dTO,dP,dS + Nozzles[ dON ] =5.0;//5.0; + Nozzles[ dOO ] =3.4;//3.4; + Nozzles[ dTN ] =2.0; + Nozzles[ dTO ] =1.75; + Nozzles[ dP ] =3.8; + Nozzles[ dPd ] =2.70; + Nozzles[ dPm ] =1.25; + Nozzles[ dPO ] =Nozzles[ dON ]; + Nozzles[ dPT ] =Nozzles[ dTN ]; + } + case 14: + { //dON,dOO,dTN,dTO,dP,dS + Nozzles[ dON ] =4.3; + Nozzles[ dOO ] =2.85; + Nozzles[ dTN ] =1.83; + Nozzles[ dTO ] =1.57; + Nozzles[ dP ] =3.4; + Nozzles[ dPd ] =2.20; + Nozzles[ dPm ] =1.10; + Nozzles[ dPO ] =Nozzles[ dON ]; + Nozzles[ dPT ] =Nozzles[ dTN ]; + } + case 12: + { //dON,dOO,dTN,dTO,dP,dS + Nozzles[ dON ] =3.7; + Nozzles[ dOO ] =2.50; + Nozzles[ dTN ] =1.65; + Nozzles[ dTO ] =1.39; + Nozzles[ dP ] =2.65; + Nozzles[ dPd ] =1.80; + Nozzles[ dPm ] =0.85; + Nozzles[ dPO ] =Nozzles[ dON ]; + Nozzles[ dPT ] =Nozzles[ dTN ]; + } + case 10: + { //dON,dOO,dTN,dTO,dP,dS + Nozzles[ dON ] =3.1; + Nozzles[ dOO ] =2.0; + Nozzles[ dTN ] =1.35; + Nozzles[ dTO ] =1.13; + Nozzles[ dP ] =1.6; + Nozzles[ dPd ] =1.55; + Nozzles[ dPm ] =0.7; + Nozzles[ dPO ] =Nozzles[ dON ]; + Nozzles[ dPT ] =Nozzles[ dTN ]; + } + case 200: + { //dON,dOO,dTN,dTO,dP,dS + Nozzles[ dON ] =dNO1l; + Nozzles[ dOO ] =dOO1l*1.0/1.15; + Nozzles[ dTN ] =dNT1l; + Nozzles[ dTO ] =dOT1l; + Nozzles[ dP ] =7.4; + Nozzles[ dPd ] =5.3; + Nozzles[ dPm ] =2.5; + Nozzles[ dPO ] =7.28; + Nozzles[ dPT ] =2.96; + } + case 375: + { //dON,dOO,dTN,dTO,dP,dS + Nozzles[ dON ] =dNO1l; + Nozzles[ dOO ] =dOO1l*1.0/1.15; + Nozzles[ dTN ] =dNT1l; + Nozzles[ dTO ] =dOT1l; + Nozzles[ dP ] =13.0; + Nozzles[ dPd ] =9.6; + Nozzles[ dPm ] =4.4; + Nozzles[ dPO ] =9.92; + Nozzles[ dPT ] =3.99; + } + case 150: + { //dON,dOO,dTN,dTO,dP,dS + Nozzles[ dON ] =dNO1l; + Nozzles[ dOO ] =dOO1l; + Nozzles[ dTN ] =dNT1l; + Nozzles[ dTO ] =dOT1l; + Nozzles[ dP ] =5.8; + Nozzles[ dPd ] =4.1; + Nozzles[ dPm ] =1.9; + Nozzles[ dPO ] =6.33; + Nozzles[ dPT ] =2.58; + } + case 100: + { //dON,dOO,dTN,dTO,dP,dS + Nozzles[ dON ] =dNO1l; + Nozzles[ dOO ] =dOO1l; + Nozzles[ dTN ] =dNT1l; + Nozzles[ dTO ] =dOT1l; + Nozzles[ dP ] =4.2; + Nozzles[ dPd ] =2.9; + Nozzles[ dPm ] =1.4; + Nozzles[ dPO ] =5.19; + Nozzles[ dPT ] =2.14; + } + default: + { + Nozzles[ dON ] =0; + Nozzles[ dOO ] =0; + Nozzles[ dTN ] =0; + Nozzles[ dTO ] =0; + Nozzles[ dP ] =0; + Nozzles[ dPd ] =0; + Nozzles[ dPm ] =0; + } + } + + Nozzles[ dSd ] =1.1; + Nozzles[ dSm ] =0.9; + + //przeliczanie z mm^2 na l/m + { long i_end = dMAX+1 ; for( i = 0 ; i < i_end ; ++i ) + { + Nozzles[ i ] =d2A( Nozzles[ i ] ); //(/1000^2*pi/4*1000) + }} + + { long i_end = 4 ; for( i = 1 ; i < i_end ; ++i ) + { + Przekladniki[ i ].BrakeRes =&BrakeRes; + Przekladniki[ i ].CreateCap( i ); + Przekladniki[ i ].CreatePress( BrakeCyl.P ); + if( i<3 ) + Przekladniki[ i ].Next =&Przekladniki[ i+1 ];else + Przekladniki[ i ].Next =&BrakeCyl; + }} +} + + + +//END diff --git a/McZapkie/Oerlikon_ESt.h b/McZapkie/Oerlikon_ESt.h new file mode 100644 index 00000000..8c5cf109 --- /dev/null +++ b/McZapkie/Oerlikon_ESt.h @@ -0,0 +1,236 @@ +#pragma once +#ifndef INCLUDED_OERLIKON_EST_H +#define INCLUDED_OERLIKON_EST_H + /*fizyka hamulcow Oerlikon ESt dla symulatora*/ + +/* +This Source Code Form is subject to the +terms of the Mozilla Public License, v. +2.0. If a copy of the MPL was not +distributed with this file, You can +obtain one at +http://mozilla.org/MPL/2.0/. +*/ +/* + MaSzyna EU07 - SPKS + Brakes. Oerlikon ESt. + Copyright (C) 2007-2014 Maciej Cierniak +*/ + +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit + +/* +(C) youBy +Co jest: +- glowny przyrzad rozrzadczy +- napelniacz zbiornika pomocniczego +- napelniacz zbiornika sterujacego +- zawor podskoku +- nibyprzyspieszacz +- tylko 16",14",12",10" +- nieprzekladnik rura +- przekladnik 1:1 +- przekladniki AL2 +- przeciwposlizgi +- rapid REL2 +- HGB300 +- inne srednice +Co brakuje: +- dobry przyspieszacz +- mozliwosc zasilania z wysokiego cisnienia ESt4 +- ep: EP1 i EP2 +- samoczynne ep +- PZZ dla dodatkowego +*/ + + + static double/*?*/ const dMAX = 10; //dysze + static double/*?*/ const dON = 0; //osobowy napelnianie (+ZP) + static double/*?*/ const dOO = 1; //osobowy oproznianie + static double/*?*/ const dTN = 2; //towarowy napelnianie (+ZP) + static double/*?*/ const dTO = 3; //towarowy oproznianie + static double/*?*/ const dP = 4; //zbiornik pomocniczy + static double/*?*/ const dSd = 5; //zbiornik sterujacy + static double/*?*/ const dSm = 6; //zbiornik sterujacy + static double/*?*/ const dPd = 7; //duzy przelot zamykajcego + static double/*?*/ const dPm = 8; //maly przelot zamykajacego + static double/*?*/ const dPO = 9; //zasilanie pomocniczego O + static double/*?*/ const dPT = 10; //zasilanie pomocniczego T + +//przekladniki + static double/*?*/ const p_none = 0; + static double/*?*/ const p_rapid = 1; + static double/*?*/ const p_pp = 2; + static double/*?*/ const p_al2 = 3; + static double/*?*/ const p_ppz = 4; + static double/*?*/ const P_ed = 5; + + + + + +struct/*class*/ TPrzekladnik: public TReservoir //przekladnik (powtarzacz) + +{ +private: + +public: + PReservoir BrakeRes; + PReservoir Next; + virtual void Update(double dt); + +}; + + + +struct/*class*/ TRura: public TPrzekladnik //nieprzekladnik, rura laczaca + +{ +private: + +public: + double P()/*override*/; + void Update(double dt)/*override*/; + +}; + + + +struct/*class*/ TPrzeciwposlizg: public TRura //przy napelnianiu - rura, przy poslizgu - upust + +{ +private: + bool Poslizg; + +public: + void SetPoslizg(bool flag); + void Update(double dt)/*override*/; + +}; + + + +struct/*class*/ TRapid: public TPrzekladnik //przekladnik dwustopniowy + +{ +private: + bool RapidStatus; //status rapidu + double RapidMult; //przelozenie (w dol) +// Komora2: real; + double DN; double DL; //srednice dysz napelniania i luzowania + +public: + void SetRapidParams(double mult, double size); + void SetRapidStatus(bool rs); + void Update(double dt)/*override*/; + +}; + + + +struct/*class*/ TPrzekCiagly: public TPrzekladnik //AL2 + +{ +private: + double mult; + +public: + void SetMult(double m); + void Update(double dt)/*override*/; + +}; + + + +struct/*class*/ TPrzek_PZZ: public TPrzekladnik //podwojny zawor zwrotny + +{ +private: + double LBP; + +public: + void SetLBP(double P); + void Update(double dt)/*override*/; + +}; + + + +struct/*class*/ TPrzekZalamany: public TPrzekladnik //Knicksventil + +{ +private: + +public: + +}; + + + +struct/*class*/ TPrzekED: public TRura //przy napelnianiu - rura, przy hamowaniu - upust + +{ +private: + double MaxP; + +public: + void SetP(double P); + void Update(double dt)/*override*/; + +}; + + + +struct/*class*/ TNESt3: public TBrake + +{ +private: + double Nozzles[dMAX+1]; //dysze + TReservoir CntrlRes; //zbiornik sterujący + double BVM; //przelozenie PG-CH +// ValveFlag: byte; //polozenie roznych zaworkow + bool Zamykajacy; //pamiec zaworka zamykajacego +// Przys_wlot: boolean; //wlot do komory przyspieszacza + bool Przys_blok; //blokada przyspieszacza + TReservoir Miedzypoj; //pojemnosc posrednia (urojona) do napelniania ZP i ZS + TPrzekladnik Przekladniki[ /*?*//*1..3*/ (3)-(1)+1 ]; + bool RapidStatus; + bool RapidStaly; + double LoadC; + double TareM; double LoadM; //masa proznego i pelnego + double TareBP; //cisnienie dla proznego + double HBG300; //zawor ograniczajacy cisnienie + double Podskok; //podskok preznosci poczatkowej +// HPBR: real; //zasilanie ZP z wysokiego cisnienia + bool autom; //odluzniacz samoczynny + double LBP; //cisnienie hamulca pomocniczego + +public: + double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG + void EStParams(double i_crc); //parametry charakterystyczne dla ESt + void Init(double PP, double HPP, double LPP, double BP, unsigned char BDF)/*override*/; + double GetCRP()/*override*/; + void CheckState(double BCP, double & dV1); //glowny przyrzad rozrzadczy + void CheckReleaser(double dt); //odluzniacz + double CVs(double BP); //napelniacz sterujacego + double BVs(double BCP); //napelniacz pomocniczego + void SetSize(int size, std::string params); //ustawianie dysz (rozmiaru ZR), przekladniki + void PLC(double mass); //wspolczynnik cisnienia przystawki wazacej + void SetLP(double TM, double LM, double TBP); //parametry przystawki wazacej + void ForceEmptiness()/*override*/; //wymuszenie bycia pustym + void SetLBP(double P); //cisnienie z hamulca pomocniczego + +}; + + +double d2A(double d); + + + +#endif//INCLUDED_OERLIKON_EST_H +//END