plik

Wojskowa Akademia Techniczna

im. Jarosława Dąbrowskiego w Warszawie

WYDZIAŁ CYBERNETYKI

Podstawy Symulacji

Projekt laboratoryjny

Prowadzący:

Wykonał:

dr inż. Jarosław Rulka

Marcin Socha,

gr. I7G2S1

Zestaw 3

Przy realizacji zadania należy przyjąłem następujące dane z listy przedstawionej poniżej:

NrDz = 12

a) rozkład zmiennych T

: (12 + 1) mod 6 + 1=2 T

: (12 + 2) mod 6 + 1=3;

b) rozkład zmiennych O

: (12 + 1 + 1) mod 6 + 1=3; O

: (12 + 2 + 1) mod 6 + 1=4;

c) L

: (12 + 1) mod 2 + 1=2; L

: (12 + 2) mod 2 + 1=1;

d) AL

: (12 + 1 + 2) mod 3 + 1=1; AL

: (12 + 2 + 2) mod 3 + 1=2; AL

: (12 + 3 + 2) mod 3 + 1=3;

e) R

= (12 + 1 + 5) mod 3 + 1=1; R

= (12 + 2 + 5) mod 3 + 1=2;

f) M

= (12 + 1 + 2) mod 4 + 1=4; M

= (12 + 2 + 2) mod 4 + 1=1;

g) Blokowanie zgłoszeo 1. SMO;
h) Klienci niecierpliwi w (ograniczony czas oczekiwania na rozpoczęcie obsługi);
gdzie: SMO

: N

= (12 + 1) mod 4=1; SMO

: N

= (12 + 2) mod 4=2 ;SMO

: N

= (12 + 3) mod 4=3

i – numer SMO;

j – numer strumienia;

– zmienna losowa oznaczająca czas pomiędzy kolejnymi napływami zgłoszeo do systemu;

– zmienna losowa oznaczająca czas obsługi pojedynczego zgłoszenia w gnieździe;

– zmienna losowa oznaczająca czas niecierpliwości zgłoszenia (gdy i = 0 => zgłoszenia cierpliwe);

– zmienna losowa oznaczająca wielkośd paczki zgłoszeo (wchodzących w tej samej chwili) j-tego strumienia;

– prawdopodobieostwa przemieszczenia się zgłoszenia po danym łuku;

– długośd kolejki i-tego SMO;

AL.

– algorytmy kolejek (w przypadku istnienia kolejki z priorytetami należy przyjąd, że zgłoszenia posiadają

priorytety);

1. Rozkłady zmiennych losowych:

1.1.  Wykładniczy
1.2.  Erlanga
1.3.  Normalny
1.4.  Jednostajny
1.5.  Trójkątny
1.6.  Weibulla

2. Długości kolejek pojedynczych SMO

SMO

2.1. ograniczone (możliwe straty)
2.2. nieograniczone

3. Algorytm kolejek:

3.1.  FIFO
3.2.  LIFO
3.3.  Z priorytetami

4. Liczba stanowisk obsługi w gniazdach (1-M)
5. Ilośd zgłoszeo jednocześnie napływających do systemu (1-R)
Pozostałe dane należy określad na początku symulacji.

Opis danych:
Generator1:
generuje klientów (paczki) i wysyła ich do SMO1. Czas pomiedzy kolejnymi emisjami ma
rozkład Erlanga. Ilośd zgłoszeo jednocześnie napływających do systemu ma rozkład
Wykładniczy.
Generator2:
generuje klientów (paczki) i wysyła ich do SMO3. Czas pomiędzy kolejnymi emisjami klientów
ma rozkład Normalny. Ilośd zgłoszeo jednocześnie napływających do systemu ma rozkład
Erlanga.
SMO1:

Kolejka1:
jest nieograniczona, jest FIFO. Występuje niecierpliwośd klientów z czasem niecierpliwości
określonym rozkładem Wykładniczym.
Gniazdo1:
czterokanałowe, czas obsługi jest okreslony rozkładem Normalnym.
SMO2:
Kolejka2:
jest ograniczona, jest LIFO. Występuje niecierpliwośd klientów z czasem niecierpliwości
określonym rozkładem Erlanga.
Gniazdo2:
jednokanałowe, czas obsługi jest określony rozkładem Jednostajnym.
SMO3:
Kolejka3:
jest nieograniczona, jest priorytetowa. Występuje niecierpliwośd klientów z czasem
niecierpliwości określonym rozkładem Normalnym.
Gniazdo3:
dwukanałowe, czas obsługi jest określony rozkładem Trójkątnym.

Wstęp teoretyczny:

Rozkład Erlanga

Rozkład Erlanga jest ciągłym rozkładem, który przyjmuje wartości dodatnie dla wszystkich
liczb rzeczywistych większych od zera. )określają go dwa parametry: k określający
kształt oraz współczynnik λ

Gęstośd:

Rozkład Normalny

Rozkład  normalny  nazywany  jest  też  rozkładem  Gaussa.  Jest  jednym  z  najważniejszych  rozkładów
funkcji.
Funkcja  gęstości,  która  mówi  jak  prawdopodobna  jest  każda  wartośd  zmiennej  losowej.
Równoważnymi  sposobami  zdefiniowania  rozkładu  normalnego  są:  momenty,  kumulanty,  funkcja
charakterystyczna,  funkcja  tworząca  momenty  i  funkcja  tworząca  kumulanty.  Wszystkie  kumulanty
rozkładu normalnego wynoszą 0 oprócz pierwszych dwóch.
Funkcja  gęstości  dla  rozkładu  normalnego  ze  średnią  μ  i  odchyleniem  standardowym  σ
(równoważnie: wariancją σ

) jest przykładem funkcji Gaussa.

Jeśli zmienna losowa X ma ten rozkład, piszemy X ~ N(μ, σ). Jeśli μ = 0 i σ = 1, rozkład nazywamy
standardowym rozkładem normalnym, którego funkcja gęstości opisana jest wzorem:

Dystrybuanta jest definiowana jako prawdopodobieostwo tego, że zmienna X ma wartości mniejsze
bądź równe "x"i w kategoriach funkcji gęstości wyrażana jest (dla rozkładu normalnego) wzorem:

Aby uzyskad wzór na dystrybuantę standardowego rozkładu normalnego, tradycyjnie oznaczaną jako
Φ, wystarczy podstawid pod ogólny wzór wartości μ = 0 i σ = 1,

Dystrybuanta standardowego rozkładu normalnego może byd wyrażona poprzez specjalną funkcję,
tzw. funkcję błędu jako:

Funkcję charakterystyczną definiuje się jako wartośd oczekiwaną e

itX

co otrzymujemy przez rozwinięcie kwadratu w wykładniku.

Rozkład Trójkątny:

Ten typ rozkładu jest użyteczny do opisu zmiennych losowych o stałej gęstości

prawdopodobieostwa w obrębie określonego przedziału a<b.

Obok przedstawiony jest wykres gęstości

prawdopodobieostwa.

f(x) = 1/(b-a), dla a<x<b

= 0 ,

w pozostałych

przypadkach

gdzie a<b oznaczają stałe wartości.

Rozkład jednostajny

Rozkład ten zwany też jednorodnym,

równomiernym, prostokątnym albo płaskim to ciągły
rozkład prawdopodobieostwa, dla którego gęstośd
prawdopodobieostwa w przedziale od a do b jest stała i
różna od zera, a poza nim równa zeru. Istnieje też wersja
dyskretna tego rozkładu oraz uogólnienie na dowolne
nośniki. Obok przedstawiony jest wykres gęstości
prawdopodobieostwa.

















)

(

)

(

)

(

Ponieważ rozkład jest ciągły, nie ma większego znaczenia czy punkty a i b włączy się do przedziału czy
nie. Rozkład jest określony parą parametrów a i b, takich że b>a.

Kod Źródłowy:

DEFINITION MODULE SmoMod;
FROM RandMod IMPORT RandomObj;
FROM GrpMod IMPORT QueueObj,RankedObj,StackObj,BasicGroupObj;
FROM SimMod IMPORT StartSimulation;
FROM SimMod IMPORT SimTime,TriggerObj;
FROM StatMod IMPORT IStatObj,ITimedStatObj,RStatObj,RTimedStatObj,TSINTEGER,TSREAL,SREAL,SINTEGER;
FROM IOMod IMPORT StreamObj,ALL FileUseType;
TYPE
Kolejka1Obj=OBJECT;FORWARD;
Gniazdo1Obj=OBJECT;FORWARD;
Kolejka2Obj=OBJECT;FORWARD;
Gniazdo2Obj=OBJECT;FORWARD;
Kolejka3Obj=OBJECT;FORWARD;
Gniazdo3Obj=OBJECT;FORWARD;
MonitoringObj=OBJECT;
czasprzebywania:SREAL;
liczbazgloszen:TSINTEGER;
liczbazajetychkanalow:TSINTEGER;
liczbazgloszenwkolejce:TSINTEGER;
prawdopodobienstwoobsluzeniazgloszenia:REAL;
liczbaogolem:INTEGER;
liczbaobsluzonych:INTEGER;
system:MonitoringObj;
start:INTEGER;
ASK METHOD UstawCzasPrzebywania(IN czas:REAL);
ASK METHOD UstawLiczbaZgloszen(IN l:INTEGER);
ASK METHOD UstawLiczbaZgloszenWKolejce(IN l:INTEGER);
ASK METHOD UstawLiczbaZajetychKanalow(IN l:INTEGER);
ASK METHOD ZwiekszLiczbaOgolem();
ASK METHOD ZwiekszLiczbaObsluzonych();
ASK METHOD Reset();
ASK METHOD Init(IN st:INTEGER;IN tsys:MonitoringObj);
END OBJECT;
KlientObj=OBJECT;
priorytet:INTEGER;
czaswe:REAL;
czaswesmo:REAL;
zapetlenie:BOOLEAN;
ASK METHOD UstawZapetlenie(IN flaga:BOOLEAN);
ASK METHOD UstawCzasWejscia(IN tczaswe:REAL);
ASK METHOD UstawCzasWejsciaSmo(IN tczaswesmo:REAL);
ASK METHOD UstawPriorytet(IN prio: INTEGER);
TELL METHOD StartNiecierpliwosc(IN czas:REAL;IN pojemnik:BasicGroupObj);
END OBJECT;
WyjscieZSysObj=OBJECT;
monitor:MonitoringObj;
ASK METHOD Wstaw(IN Klient:KlientObj);
ASK METHOD Init(IN mon:MonitoringObj);
END OBJECT;
Generator1Obj=OBJECT;
ASK METHOD Init(IN Mean1:REAL; IN k1:INTEGER; IN lk:INTEGER; IN kol1:Kolejka1Obj;IN mon:MonitoringObj;IN
trmax:REAL;IN trand:RandomObj);
Mean:REAL;
k:INTEGER;
Kolejka1:Kolejka1Obj;
LiczbaKlientow:INTEGER;
monitor:MonitoringObj;
Lambda:REAL;
rand:RandomObj;
TELL METHOD Generowanie();
END OBJECT;
Generator2Obj=OBJECT;
Mean, Sigma:REAL;
Mmean:REAL;
Kolejka3:Kolejka3Obj;
LiczbaKlientow:INTEGER;
monitor:MonitoringObj;
k:INTEGER;
rand:RandomObj;
TELL METHOD Generowanie();
ASK METHOD Init(IN Mean2,Sigma2,Mean3:REAL;IN lk:INTEGER; IN kol3:Kolejka3Obj;IN mon:MonitoringObj;IN
trmax:INTEGER;IN trand:RandomObj);
END OBJECT;

Kolejka1Obj=OBJECT(QueueObj);
Lambda:REAL;
Gniazdo1:Gniazdo1Obj;
monitor:MonitoringObj;
rand:RandomObj;
ASK METHOD Wstaw(INOUT elem:KlientObj);
ASK METHOD Init(IN tLambda:REAL;IN g1:Gniazdo1Obj;IN mon:MonitoringObj;IN trand:RandomObj);
OVERRIDE;
ASK METHOD Remove():ANYOBJ;
ASK METHOD RemoveThis(IN co:ANYOBJ);
ASK METHOD ObjTerminate;
END OBJECT;
Gniazdo1Obj=OBJECT;
Mean:REAL;
Sigma:REAL;
Kanaly:INTEGER;
Aktywne:INTEGER;
Kolejka1:Kolejka1Obj;;
Kolejka2:Kolejka2Obj;
monitor:MonitoringObj;
trigger2:TriggerObj;
rand:RandomObj;
TELL METHOD Obsluga();
ASK METHOD UstawAktywne(IN ak:INTEGER);
ASK METHOD Init(IN means1,sigmas1:REAL; IN k:INTEGER; IN kol1:Kolejka1Obj;IN mon:MonitoringObj;IN
ttrigger2:TriggerObj;IN trand:RandomObj;IN tKolejka2:Kolejka2Obj);
END OBJECT;
Kolejka2Obj=OBJECT(StackObj);
Pojemnosc:INTEGER;
Mean:REAL;
k:INTEGER;
Gniazdo2:Gniazdo2Obj;
monitor:MonitoringObj;
trigger2:TriggerObj;
rand:RandomObj;
ASK METHOD Wstaw(INOUT elem:KlientObj);
ASK METHOD Init(IN p:INTEGER;IN means2k:REAL; IN k2k:INTEGER; IN g2:Gniazdo2Obj;IN mon:MonitoringObj;IN
ttrigger2:TriggerObj;IN trand:RandomObj);
OVERRIDE;
ASK METHOD Remove():ANYOBJ;
ASK METHOD RemoveThis(IN co:ANYOBJ);
ASK METHOD ObjTerminate;
END OBJECT;
Gniazdo2Obj=OBJECT;
lo:REAL;
hi:REAL;
Kanaly:INTEGER;
Aktywne:INTEGER;
Kolejka2:Kolejka2Obj;
monitor:MonitoringObj;
p2:REAL;
rand:RandomObj;
outsystemsmo:WyjscieZSysObj;
ASK METHOD UstawAktywne(IN ak:INTEGER);
TELL METHOD Obsluga();
ASK METHOD Init(IN tlo, thi:REAL; IN kan:INTEGER; IN kol2:Kolejka2Obj;IN mon:MonitoringObj;IN tp2:REAL;IN
toutsystemsmo:WyjscieZSysObj;IN trand:RandomObj);
END OBJECT;
Kolejka3Obj=OBJECT(RankedObj[ANYOBJ:KlientObj]);
Lambda:REAL;
Mean:REAL;
Sigma:REAL;
trigger3:TriggerObj;
Gniazdo3:Gniazdo3Obj;
monitor:MonitoringObj;
rand:RandomObj;
ASK METHOD Wstaw(INOUT elem:KlientObj);
ASK METHOD Init(IN means3,sigmas3:REAL;IN g3:Gniazdo3Obj;IN mon:MonitoringObj;IN trand:RandomObj;IN
ttrigger3:TriggerObj);
OVERRIDE;
ASK METHOD Remove():KlientObj;
ASK METHOD RemoveThis(IN co:KlientObj);
ASK METHOD Rank(IN l,r:KlientObj):INTEGER;
ASK METHOD ObjTerminate;
END OBJECT;
Gniazdo3Obj=OBJECT;

min,m,max:REAL;
Kanaly:INTEGER;
Aktywne:INTEGER;
Kolejka3:Kolejka3Obj;
monitor:MonitoringObj;
p3:REAL;
rand:RandomObj;
outsystemsmo:WyjscieZSysObj;
ASK METHOD UstawAktywne(IN ak:INTEGER);
TELL METHOD Obsluga();
ASK METHOD Init(IN tmin,tm,tmax:REAL; IN kan:INTEGER; IN kol3:Kolejka3Obj;IN mon:MonitoringObj;IN tp3:REAL;IN
toutsystemsmo:WyjscieZSysObj;IN trand:RandomObj);
END OBJECT;
PROCEDURE IfResetMonitors(IN lr:INTEGER);
VAR
naekran: BOOLEAN;
gen1:Generator1Obj;
gen2:Generator2Obj;
gnz1:Gniazdo1Obj;
gnz2:Gniazdo2Obj;
gnz3:Gniazdo3Obj;
kol1:Kolejka1Obj;
kol2:Kolejka2Obj;
kol3:Kolejka3Obj;
mon0:MonitoringObj;
mon1:MonitoringObj;
mon2:MonitoringObj;
mon3:MonitoringObj;
out0:WyjscieZSysObj;
ran0:RandomObj;
trg0:TriggerObj;
trg1:TriggerObj;
END MODULE.

MODUŁ IMPLMENTACYJNY:

IMPLEMENTATION MODULE SmoMod;
FROM RandMod IMPORT RandomObj,FetchSeed;
FROM GrpMod IMPORT BasicGroupObj;
FROM MathMod IMPORT CEIL,SQRT;
FROM SimMod IMPORT SimTime,TriggerObj,Interrupt;
FROM StatMod IMPORT IStatObj,ITimedStatObj,RStatObj,RTimedStatObj,TSINTEGER,TSREAL,SREAL,SINTEGER;
FROM IOMod IMPORT StreamObj,ALL FileUseType;
OBJECT KlientObj;
ASK METHOD UstawCzasWejsciaSmo(IN tczaswesmo:REAL);
BEGIN
czaswesmo:=tczaswesmo;
END METHOD;
ASK METHOD UstawZapetlenie(IN flaga:BOOLEAN);
BEGIN
zapetlenie:=flaga;
END METHOD;
ASK METHOD UstawCzasWejscia(IN tczaswe:REAL);
BEGIN
czaswe:=tczaswe;
END METHOD;
ASK METHOD UstawPriorytet(IN prio: INTEGER);
BEGIN
priorytet:=prio;
END METHOD;
TELL METHOD StartNiecierpliwosc(IN czas:REAL;IN pojemnik:BasicGroupObj);
BEGIN
WAIT DURATION czas;
ASK pojemnik TO RemoveThis(SELF);
DISPOSE(SELF);
IF (naekran)
OUTPUT("Niecierpliwy klient ucieka!=",SimTime);
END IF;
ON INTERRUPT;
END WAIT;
END METHOD;
END OBJECT;
PROCEDURE IfResetMonitors(IN lr:INTEGER);
BEGIN
IF(lr=(ASK mon0 TO start))
ASK mon0 TO Reset();
END IF;

IF(lr=(ASK mon1 TO start))
ASK mon1 TO Reset();
END IF;
IF(lr=(ASK mon2 TO start))
ASK mon2 TO Reset();
END IF;
IF(lr=(ASK mon3 TO start))
ASK mon3 TO Reset();
END IF;
END PROCEDURE;
OBJECT MonitoringObj;
ASK METHOD UstawCzasPrzebywania(IN czas:REAL);
BEGIN
czasprzebywania:=czas;
END METHOD;
ASK METHOD UstawLiczbaZgloszen(IN l:INTEGER);
BEGIN
liczbazgloszen:=l;
END METHOD;
ASK METHOD UstawLiczbaZgloszenWKolejce(IN l:INTEGER);
BEGIN
liczbazgloszenwkolejce:=l;
END METHOD;
ASK METHOD UstawLiczbaZajetychKanalow(IN l:INTEGER);
BEGIN
liczbazajetychkanalow:=l;
END METHOD;
ASK METHOD ZwiekszLiczbaOgolem();
BEGIN
liczbaogolem:=liczbaogolem+1;
prawdopodobienstwoobsluzeniazgloszenia:=FLOAT(liczbaobsluzonych)/FLOAT(liczbaogolem);
END METHOD;
ASK METHOD ZwiekszLiczbaObsluzonych();
BEGIN
liczbaobsluzonych:=liczbaobsluzonych+1;
prawdopodobienstwoobsluzeniazgloszenia:=FLOAT(liczbaobsluzonych)/FLOAT(liczbaogolem);
END METHOD;
ASK METHOD Reset();
BEGIN
liczbaogolem:=liczbazgloszen;
liczbaobsluzonych:=0;
prawdopodobienstwoobsluzeniazgloszenia:=0.0;
ASK GETMONITOR(czasprzebywania,RStatObj) TO Reset();
ASK GETMONITOR(liczbazgloszen,ITimedStatObj) TO Reset();
ASK GETMONITOR(liczbazajetychkanalow,ITimedStatObj) TO Reset();
ASK GETMONITOR(liczbazgloszenwkolejce,ITimedStatObj) TO Reset();
END METHOD;
ASK METHOD Init(IN st:INTEGER;IN tsys:MonitoringObj);
BEGIN
czasprzebywania:=0.0;
liczbazgloszen:=0;
liczbazajetychkanalow:=0;
liczbazgloszenwkolejce:=0;
prawdopodobienstwoobsluzeniazgloszenia:=0.0;
liczbaogolem:=0;
liczbaobsluzonych:=0;
start:=st;
system:=tsys;
END METHOD;
END OBJECT;
OBJECT WyjscieZSysObj;
ASK METHOD Wstaw(IN Klient:KlientObj);
BEGIN
ASK monitor TO ZwiekszLiczbaObsluzonych();
ASK monitor TO UstawLiczbaZgloszen(ASK monitor TO liczbazgloszen -1);
ASK monitor TO UstawCzasPrzebywania(SimTime - ASK Klient TO czaswe);
END METHOD;
ASK METHOD Init(IN mon:MonitoringObj);
BEGIN
monitor:=mon;
END METHOD;
END OBJECT;
OBJECT Generator1Obj;
TELL METHOD Generowanie();
VAR
Klient:KlientObj;

i:INTEGER;
j:INTEGER;
lr:INTEGER;
czas:REAL;
BEGIN
FOR i:=1 TO LiczbaKlientow
IfResetMonitors(i);
czas:=ASK rand TO Erlang(Mean,k);
WAIT DURATION czas
ON INTERRUPT;
END WAIT;
lr:=CEIL(ASK rand TO Exponential(1.0/Lambda));
FOR j:=1 TO lr
NEW(Klient);
ASK Klient TO UstawPriorytet(ASK rand TO UniformInt(0,100));
ASK Klient TO UstawCzasWejscia(SimTime);
IF (naekran)
OUTPUT("Generator 1 wygenerowal klienta=",SimTime);
END IF;
ASK monitor TO UstawLiczbaZgloszen(ASK monitor TO liczbazgloszen +1);
ASK monitor TO ZwiekszLiczbaOgolem();
ASK Kolejka1 TO Wstaw(Klient);
END FOR;
END FOR;
END METHOD;
ASK METHOD Init(IN Mean1:REAL; IN k1:INTEGER; IN lk:INTEGER; IN kol1:Kolejka1Obj;IN mon:MonitoringObj;IN
trmax:REAL;IN trand:RandomObj);
BEGIN
Mean:=Mean1;
k:=k1;
Kolejka1:=kol1;
LiczbaKlientow:=lk;
monitor:=mon;
Lambda:=trmax;
rand:=trand;
END METHOD;
END OBJECT;
OBJECT Generator2Obj;
TELL METHOD Generowanie();
VAR
Klient:KlientObj;
i:INTEGER;
j:INTEGER;
lr:INTEGER;
czas:REAL;
BEGIN
FOR i:=1 TO LiczbaKlientow
IfResetMonitors(i);
czas:=ASK rand TO Normal(Mean,Sigma);
WAIT DURATION czas
ON INTERRUPT;
END WAIT;
lr:=CEIL(ASK rand TO Erlang(Mmean,k));
FOR j:=1 TO lr
NEW(Klient);
ASK Klient TO UstawPriorytet(ASK rand TO UniformInt(0,100));
ASK Klient TO UstawCzasWejscia(SimTime);
IF (naekran)
OUTPUT("Generator 2 wygenerowal klienta=",SimTime);
END IF;
ASK monitor TO UstawLiczbaZgloszen(ASK monitor TO liczbazgloszen +1);
ASK monitor TO ZwiekszLiczbaOgolem();
ASK Kolejka3 TO Wstaw(Klient);
END FOR;
END FOR;
END METHOD;
ASK METHOD Init(IN Mean2,Sigma2,Mean3:REAL;IN lk:INTEGER; IN kol3:Kolejka3Obj;IN mon:MonitoringObj;IN
trmax:INTEGER;IN trand:RandomObj);
BEGIN
Mean:=Mean2;
Sigma:=Sigma2;
Kolejka3:=kol3;
LiczbaKlientow:=lk;
monitor:=mon;
k:=trmax;
Mmean:=Mean3;

rand:=trand;
END METHOD;
END OBJECT;
OBJECT Kolejka1Obj;
ASK METHOD ObjTerminate();
VAR
el: ANYOBJ;
BEGIN
FOREACH el IN SELF
RemoveThis(el);
DISPOSE(el);
END FOREACH;
INHERITED ObjTerminate();
END METHOD;
ASK METHOD Wstaw(INOUT elem:KlientObj);
BEGIN
Add(elem);
ASK monitor TO UstawLiczbaZgloszen(ASK monitor TO liczbazgloszen +1);
ASK monitor TO UstawLiczbaZgloszenWKolejce(ASK monitor TO liczbazgloszenwkolejce +1);
ASK (ASK monitor TO system) TO UstawLiczbaZgloszenWKolejce(ASK (ASK monitor TO system) TO
liczbazgloszenwkolejce +1);
ASK elem TO UstawCzasWejsciaSmo(SimTime);
ASK monitor TO ZwiekszLiczbaOgolem();
TELL elem TO StartNiecierpliwosc(ASK rand TO Exponential(1.0/Lambda),SELF);
IF(ASK Gniazdo1 TO Aktywne < ASK Gniazdo1 TO Kanaly)
TELL Gniazdo1 TO Obsluga();
ASK Gniazdo1 TO UstawAktywne(ASK Gniazdo1 TO Aktywne+1);
END IF;
END METHOD;
ASK METHOD Remove():ANYOBJ;
BEGIN
ASK monitor TO UstawLiczbaZgloszenWKolejce(ASK monitor TO liczbazgloszenwkolejce -1);
ASK (ASK monitor TO system) TO UstawLiczbaZgloszenWKolejce(ASK (ASK monitor TO system) TO
liczbazgloszenwkolejce -1);
RETURN INHERITED Remove();
END METHOD;
ASK METHOD RemoveThis(IN co:ANYOBJ);
BEGIN
ASK monitor TO UstawLiczbaZgloszenWKolejce(ASK monitor TO liczbazgloszenwkolejce -1);
ASK monitor TO UstawLiczbaZgloszen(ASK monitor TO liczbazgloszen -1);
ASK (ASK monitor TO system) TO UstawLiczbaZgloszenWKolejce(ASK (ASK monitor TO system) TO
liczbazgloszenwkolejce -1);
ASK (ASK monitor TO system) TO UstawLiczbaZgloszen(ASK (ASK monitor TO system) TO liczbazgloszen -1);
INHERITED RemoveThis(co);
END METHOD;
ASK METHOD Init(IN tLambda:REAL;IN g1:Gniazdo1Obj;IN mon:MonitoringObj;IN trand:RandomObj);
BEGIN
Lambda:=tLambda;
Gniazdo1:=g1;
monitor:=mon;
rand:=trand;
END METHOD;
END OBJECT;
OBJECT Gniazdo1Obj;
TELL METHOD Obsluga();
VAR
Klient: KlientObj;
BEGIN
ASK (ASK monitor TO system) TO UstawLiczbaZajetychKanalow(ASK (ASK monitor TO system) TO
liczbazajetychkanalow +1);
ASK monitor TO UstawLiczbaZajetychKanalow(ASK monitor TO liczbazajetychkanalow +1);
WHILE(ASK Kolejka1 TO numberIn>0)
Klient:=ASK Kolejka1 TO Remove();
IF (naekran)
OUTPUT("Gniazdo 1 obsluguje klienta czas=",SimTime);
END IF;
Interrupt(Klient,"StartNiecierpliwosc");
WAIT DURATION ASK rand TO Normal(Mean,Sigma);
ON INTERRUPT;
END WAIT;
WHILE(ASK Kolejka2 TO Pojemnosc=ASK Kolejka2 TO numberIn)
IF(naekran)
OUTPUT("W kol2 nie ma miejsca na klienta w Time=",SimTime);
END IF;
WAIT FOR trigger2 TO Fire();
ON INTERRUPT;

END WAIT;
END WHILE;
IF (naekran)
OUTPUT("Gniazdo 1 wypuszcza klienta i on idzie do kol2 w czasie=",SimTime);
END IF;
ASK monitor TO UstawLiczbaZgloszen(ASK monitor TO liczbazgloszen -1);
ASK monitor TO UstawCzasPrzebywania(SimTime - ASK Klient TO czaswesmo);
ASK monitor TO ZwiekszLiczbaObsluzonych();
ASK Kolejka2 TO Wstaw(Klient);
END WHILE;
Aktywne:=Aktywne-1;
ASK monitor TO UstawLiczbaZajetychKanalow(ASK monitor TO liczbazajetychkanalow -1);
ASK (ASK monitor TO system) TO UstawLiczbaZajetychKanalow(ASK (ASK monitor TO system) TO
liczbazajetychkanalow -1);
END METHOD;
ASK METHOD Init(IN means1,sigmas1:REAL; IN k:INTEGER; IN kol1:Kolejka1Obj;IN mon:MonitoringObj;IN
ttrigger2:TriggerObj;IN trand:RandomObj;IN tKolejka2:Kolejka2Obj);
BEGIN
Sigma:=sigmas1;
Mean:=means1;
Kanaly:=k;
Kolejka1:=kol1;
Aktywne:=0;
monitor:=mon;
trigger2:=ttrigger2;
rand:=trand;
Kolejka2:=tKolejka2;
END METHOD;
ASK METHOD UstawAktywne(IN ak:INTEGER);
BEGIN
Aktywne:=ak;
END METHOD;
END OBJECT;
OBJECT Kolejka2Obj;
ASK METHOD ObjTerminate();
VAR
el: ANYOBJ;
BEGIN
FOREACH el IN SELF
RemoveThis(el);
DISPOSE(el);
END FOREACH;
INHERITED ObjTerminate();
END METHOD;
ASK METHOD Wstaw(INOUT elem:KlientObj);
BEGIN
IF(Pojemnosc>numberIn)
Add(elem);
ASK monitor TO UstawLiczbaZgloszenWKolejce(ASK monitor TO liczbazgloszenwkolejce +1);
ASK (ASK monitor TO system) TO UstawLiczbaZgloszenWKolejce(ASK (ASK monitor TO system) TO
liczbazgloszenwkolejce +1);
IF(ASK elem TO zapetlenie=FALSE)
ASK monitor TO ZwiekszLiczbaOgolem();
ASK monitor TO UstawLiczbaZgloszen(ASK monitor TO liczbazgloszen +1);
ASK elem TO UstawCzasWejsciaSmo(SimTime);
END IF;
ASK elem TO UstawZapetlenie(FALSE);
TELL elem TO StartNiecierpliwosc(ASK rand TO Erlang(Mean,k),SELF);
IF(ASK Gniazdo2 TO Aktywne < ASK Gniazdo2 TO Kanaly)
TELL Gniazdo2 TO Obsluga();
ASK Gniazdo2 TO UstawAktywne(ASK Gniazdo2 TO Aktywne+1);
END IF;
ELSE
DISPOSE(elem);
IF (naekran)
OUTPUT("w kolejce 2 nie ma miejsca, czas=",SimTime);
END IF;
ASK (ASK monitor TO system) TO UstawLiczbaZgloszen(ASK (ASK monitor TO system) TO liczbazgloszen -1);
END IF;
END METHOD;
ASK METHOD Remove():ANYOBJ;
BEGIN
ASK monitor TO UstawLiczbaZgloszenWKolejce(ASK monitor TO liczbazgloszenwkolejce -1);
ASK (ASK monitor TO system) TO UstawLiczbaZgloszenWKolejce(ASK (ASK monitor TO system) TO
liczbazgloszenwkolejce -1);
RETURN INHERITED Remove();

END METHOD;
ASK METHOD RemoveThis(IN co:ANYOBJ);
BEGIN
ASK monitor TO UstawLiczbaZgloszenWKolejce(ASK monitor TO liczbazgloszenwkolejce -1);
ASK monitor TO UstawLiczbaZgloszen(ASK monitor TO liczbazgloszen -1);
ASK (ASK monitor TO system) TO UstawLiczbaZgloszenWKolejce(ASK (ASK monitor TO system) TO
liczbazgloszenwkolejce -1);
ASK (ASK monitor TO system) TO UstawLiczbaZgloszen(ASK (ASK monitor TO system) TO liczbazgloszen -1);
INHERITED RemoveThis(co);
END METHOD;
ASK METHOD Init(IN p:INTEGER;IN means2k:REAL; IN k2k:INTEGER; IN g2:Gniazdo2Obj;IN mon:MonitoringObj;IN
ttrigger2:TriggerObj;IN trand:RandomObj);
BEGIN
Pojemnosc:=p;
Mean:=means2k;
k:=k2k;
Gniazdo2:=g2;
monitor:=mon;
trigger2:=ttrigger2;
rand:=trand;
END METHOD;
END OBJECT;
OBJECT Gniazdo2Obj;
TELL METHOD Obsluga();
VAR
Klient: KlientObj;
BEGIN
ASK (ASK monitor TO system) TO UstawLiczbaZajetychKanalow(ASK (ASK monitor TO system) TO
liczbazajetychkanalow +1);
ASK monitor TO UstawLiczbaZajetychKanalow(ASK monitor TO liczbazajetychkanalow +1);
WHILE(ASK Kolejka2 TO numberIn>0)
Klient:=ASK Kolejka2 TO Remove();
IF (naekran)
OUTPUT("klient wchodzi do gniazda smo2, czas=",SimTime);
END IF;
Interrupt(Klient,"StartNiecierpliwosc");
WAIT DURATION ASK rand TO UniformReal(lo,hi);
ON INTERRUPT;
END WAIT;
IF (ASK rand TO Sample < p2)
IF (naekran)
OUTPUT("klient zawraca i znow wchodzi do smo2, czas=",SimTime);
END IF;
ASK Klient TO UstawZapetlenie(TRUE);
ASK Kolejka2 TO Wstaw(Klient);
ELSE
ASK monitor TO UstawLiczbaZgloszen(ASK monitor TO liczbazgloszen -1);
ASK monitor TO ZwiekszLiczbaObsluzonych();
ASK monitor TO UstawCzasPrzebywania(SimTime - ASK Klient TO czaswesmo);
ASK outsystemsmo TO Wstaw(Klient);
IF (naekran)
OUTPUT("klient idzie do wyjscia, czas=",SimTime);
END IF;
END IF;
END WHILE;
Aktywne:=Aktywne-1;
ASK monitor TO UstawLiczbaZajetychKanalow(ASK monitor TO liczbazajetychkanalow -1);
ASK (ASK monitor TO system) TO UstawLiczbaZajetychKanalow(ASK (ASK monitor TO system) TO
liczbazajetychkanalow -1);
END METHOD;
ASK METHOD Init(IN tlo, thi:REAL; IN kan:INTEGER; IN kol2:Kolejka2Obj;IN mon:MonitoringObj;IN tp2:REAL;IN
toutsystemsmo:WyjscieZSysObj;IN trand:RandomObj);
BEGIN
lo:=tlo;
hi:=thi;
Kanaly:=kan;
Kolejka2:=kol2;
Aktywne:=0;
monitor:=mon;
p2:=tp2;
outsystemsmo:=toutsystemsmo;
rand:=trand;
END METHOD;
ASK METHOD UstawAktywne(IN ak:INTEGER);
BEGIN
Aktywne:=ak;

END METHOD;
END OBJECT;
OBJECT Kolejka3Obj;
ASK METHOD ObjTerminate();
VAR
el: ANYOBJ;
BEGIN
FOREACH el IN SELF
RemoveThis(el);
DISPOSE(el);
END FOREACH;
INHERITED ObjTerminate();
END METHOD;
ASK METHOD Wstaw(INOUT elem:KlientObj);
BEGIN
Add(elem);
ASK monitor TO UstawLiczbaZgloszenWKolejce(ASK monitor TO liczbazgloszenwkolejce +1);
ASK (ASK monitor TO system) TO UstawLiczbaZgloszenWKolejce(ASK (ASK monitor TO system) TO
liczbazgloszenwkolejce +1);
IF(ASK elem TO zapetlenie=FALSE)
ASK monitor TO ZwiekszLiczbaOgolem();
ASK elem TO UstawCzasWejsciaSmo(SimTime);
ASK monitor TO UstawLiczbaZgloszen(ASK monitor TO liczbazgloszen +1);
END IF;
ASK elem TO UstawZapetlenie(FALSE);
TELL elem TO StartNiecierpliwosc(ASK rand TO Normal(Mean,Sigma),SELF);
IF(ASK Gniazdo3 TO Aktywne < ASK Gniazdo3 TO Kanaly)
TELL Gniazdo3 TO Obsluga();
ASK Gniazdo3 TO UstawAktywne(ASK Gniazdo3 TO Aktywne+1);
END IF;
END METHOD;
ASK METHOD Rank(IN l,r:KlientObj):INTEGER;
BEGIN
IF(l.priorytet < r.priorytet)
RETURN 1;
ELSIF(l.priorytet > r.priorytet)
RETURN -1;
ELSE
RETURN 0;
END IF;
END METHOD;
ASK METHOD RemoveThis(IN co:KlientObj);
BEGIN
ASK trigger3 TO Release;
ASK monitor TO UstawLiczbaZgloszenWKolejce(ASK monitor TO liczbazgloszenwkolejce -1);
ASK monitor TO UstawLiczbaZgloszen(ASK monitor TO liczbazgloszen -1);
ASK (ASK monitor TO system) TO UstawLiczbaZgloszen(ASK (ASK monitor TO system) TO liczbazgloszen -1);
ASK (ASK monitor TO system) TO UstawLiczbaZgloszenWKolejce(ASK (ASK monitor TO system) TO
liczbazgloszenwkolejce -1);
INHERITED RemoveThis(co);
END METHOD;
ASK METHOD Remove():KlientObj;
BEGIN
ASK trigger3 TO Release;
ASK monitor TO UstawLiczbaZgloszenWKolejce(ASK monitor TO liczbazgloszenwkolejce -1);
ASK (ASK monitor TO system) TO UstawLiczbaZgloszenWKolejce(ASK (ASK monitor TO system) TO
liczbazgloszenwkolejce -1);
RETURN INHERITED Remove();
END METHOD;
ASK METHOD Init(IN means3,sigmas3:REAL;IN g3:Gniazdo3Obj;IN mon:MonitoringObj;IN trand:RandomObj;IN
ttrigger3:TriggerObj);
BEGIN
Mean:=means3;
Sigma:=sigmas3;
Gniazdo3:=g3;
monitor:=mon;
rand:=trand;
trigger3:=ttrigger3;
END METHOD;
END OBJECT;
OBJECT Gniazdo3Obj;
TELL METHOD Obsluga();
VAR
Klient: KlientObj;
BEGIN
ASK (ASK monitor TO system) TO UstawLiczbaZajetychKanalow(ASK (ASK monitor TO system) TO

liczbazajetychkanalow +1);
ASK monitor TO UstawLiczbaZajetychKanalow(ASK monitor TO liczbazajetychkanalow +1);
WHILE(ASK Kolejka3 TO numberIn>0)
Klient:=ASK Kolejka3 TO Remove();
IF (naekran)
OUTPUT("klient wchodzi do gniazda smo3, czas=",SimTime);
END IF;
Interrupt(Klient,"StartNiecierpliwosc");
WAIT DURATION ASK rand TO Triangular(min,m,max);
ON INTERRUPT;
END WAIT;
IF (ASK rand TO Sample < p3)
IF (naekran)
OUTPUT("klient zawraca i znow wchodzi do smo3, czas=",SimTime);
END IF;
ASK Klient TO UstawZapetlenie(TRUE);
ASK Kolejka3 TO Wstaw(Klient);
ELSE
ASK monitor TO UstawLiczbaZgloszen(ASK monitor TO liczbazgloszen -1);
ASK monitor TO ZwiekszLiczbaObsluzonych();
ASK monitor TO UstawCzasPrzebywania(SimTime - ASK Klient TO czaswesmo);
ASK outsystemsmo TO Wstaw(Klient);
IF (naekran)
OUTPUT("klient idzie do wyjscia, czas=",SimTime);
END IF;
END IF;
END WHILE;
Aktywne:=Aktywne-1;
ASK monitor TO UstawLiczbaZajetychKanalow(ASK monitor TO liczbazajetychkanalow -1);
ASK (ASK monitor TO system) TO UstawLiczbaZajetychKanalow(ASK (ASK monitor TO system) TO
liczbazajetychkanalow -1);
END METHOD;
ASK METHOD Init(IN tmin,tm,tmax:REAL; IN kan:INTEGER; IN kol3:Kolejka3Obj;IN mon:MonitoringObj;IN tp3:REAL;IN
toutsystemsmo:WyjscieZSysObj;IN trand:RandomObj);
BEGIN
min:=tmin;
m:=tm;
max:=tmax;
Kanaly:=kan;
Kolejka3:=kol3;
Aktywne:=0;
monitor:=mon;
p3:=tp3;
outsystemsmo:=toutsystemsmo;
rand:=trand;
END METHOD;
ASK METHOD UstawAktywne(IN ak:INTEGER);
BEGIN
Aktywne:=ak;
END METHOD;
END OBJECT;
END MODULE.

MODUŁ GŁÓWNY:

MAIN MODULE Mzal;
FROM SimMod IMPORT StartSimulation,SimTime,ResetSimTime;
FROM SmoMod IMPORT
Generator1Obj,Generator2Obj,Gniazdo1Obj,Gniazdo2Obj,Gniazdo3Obj,Kolejka1Obj,Kolejka2Obj,Kolejka3Obj,KlientObj,Moni
toringObj,WyjscieZSysObj;
FROM SmoMod IMPORT kol1,kol2,kol3,gnz1,gnz2,gnz3,gen1,gen2,mon0,mon1,mon2,mon3,out0,ran0,trg0,naekran;
FROM StatMod IMPORT IStatObj,ITimedStatObj,RStatObj,RTimedStatObj,TSINTEGER,TSREAL,SREAL,SINTEGER;
FROM IOMod IMPORT StreamObj,ALL FileUseType;
FROM RandMod IMPORT RandomObj,FetchSeed;
FROM MathMod IMPORT FLOOR;
TYPE
Rekdanych=RECORD;
LExp:INTEGER;
LstartMon:INTEGER;
Gen1Mean,Gen1Lambda:REAL;
Gen1kPaczka,Gen1LKlientow:INTEGER;
Gen2Mean,Gen2Sigma,Gen2Meanil:REAL;
Gen2kil,Gen2LKlientow:INTEGER;
Kol1Lambda:REAL;
Gnz1Mean,Gnz1Sigma:REAL;
Gnz1Kanaly:INTEGER;
Kol2pojem:INTEGER;

Kol2Mean:REAL;
Kol2k:INTEGER;
Gnz2lo,Gnz2hi,Gnz2prawd2:REAL;
Gnz2Kanaly:INTEGER;
Kol3Mean:REAL;
Kol3Sigma:REAL;
Gnz3min,Gnz3max,Gnz3m,Gnz3prawd3:REAL;
Gnz3Kanaly:INTEGER;
END RECORD;
WynikiSMO=ARRAY [0..35] OF SREAL;
PROCEDURE ReadInt(INOUT file:StreamObj;OUT B:INTEGER);
VAR
str:STRING;
chr:CHAR;
BEGIN
ASK file TO ReadChar(chr);
ASK file TO ReadLine(str);
ASK file TO ReadInt(B);
END PROCEDURE;
PROCEDURE ReadReal(INOUT file:StreamObj;OUT A:REAL);
VAR
str:STRING;
chr:CHAR;
BEGIN
ASK file TO ReadChar(chr);
ASK file TO ReadLine(str);
ASK file TO ReadReal(A);
END PROCEDURE;
PROCEDURE ReadFromFile(OUT config:Rekdanych);
VAR
file:StreamObj;
BEGIN
NEW(file);
ASK file TO Open("dane.txt",Input);
config.LstartMon:=1;
ReadInt(file,config.LExp);
ReadReal(file,config.Gen1Mean);
ReadReal(file,config.Gen1Lambda);
ReadInt(file,config.Gen1kPaczka);
ReadInt(file,config.Gen1LKlientow);
ReadReal(file,config.Gen2Mean);
ReadReal(file,config.Gen2Sigma);
ReadReal(file,config.Gen2Meanil);
ReadInt(file,config.Gen2kil);
ReadInt(file,config.Gen2LKlientow);
ReadReal(file,config.Kol1Lambda);
ReadReal(file,config.Gnz1Mean);
ReadReal(file,config.Gnz1Sigma);
ReadInt(file,config.Gnz1Kanaly);
ReadInt(file,config.Kol2pojem);
ReadReal(file,config.Kol2Mean);
ReadInt(file,config.Kol2k);
ReadReal(file,config.Gnz2lo);
ReadReal(file,config.Gnz2hi);
ReadReal(file,config.Gnz2prawd2);
ReadInt(file,config.Gnz2Kanaly);
ReadReal(file,config.Kol3Mean);
ReadReal(file,config.Kol3Sigma);
ReadReal(file,config.Gnz3min);
ReadReal(file,config.Gnz3max);
ReadReal(file,config.Gnz3m);
ReadReal(file,config.Gnz3prawd3);
ReadInt(file,config.Gnz3Kanaly);
DISPOSE(file);
END PROCEDURE;
PROCEDURE Symuluj(INOUT wyniki:WynikiSMO;INOUT config:Rekdanych);
BEGIN
NEW(gen1);
NEW(gen2);
NEW(gnz1);
NEW(gnz2);
NEW(gnz3);
NEW(kol1);
NEW(kol2);
NEW(kol3);
NEW(mon0);

NEW(mon1);
NEW(mon2);
NEW(mon3);
NEW(out0);
NEW(trg0);
NEW(trg0);
ASK mon0 TO Init(config.LstartMon,mon0);
ASK mon1 TO Init(config.LstartMon,mon1);
ASK mon2 TO Init(config.LstartMon,mon2);
ASK mon3 TO Init(config.LstartMon,mon3);
ASK gnz3 TO
Init(config.Gnz3min,config.Gnz3m,config.Gnz3max,config.Gnz3Kanaly,kol3,mon3,config.Gnz3prawd3,out0,ran0);
ASK kol3 TO Init(config.Kol3Mean,config.Kol3Sigma,gnz3,mon3,ran0,trg0);
ASK gnz2 TO Init(config.Gnz2lo,config.Gnz2hi,config.Gnz2Kanaly,kol2,mon2,config.Gnz2prawd2,out0,ran0);
ASK kol2 TO Init(config.Kol2pojem,config.Kol2Mean,config.Kol2k,gnz2,mon2,trg0,ran0);
ASK gnz1 TO Init(config.Gnz1Mean,config.Gnz1Sigma,config.Gnz1Kanaly,kol1,mon1,trg0,ran0,kol2);
ASK kol1 TO Init(config.Kol1Lambda,gnz1,mon1,ran0);
ASK gen1 TO Init(config.Gen1Mean,config.Gen1kPaczka,config.Gen1LKlientow,kol1,mon0,config.Gen1Lambda,ran0);
ASK gen2 TO
Init(config.Gen2Mean,config.Gen2Sigma,config.Gen2Meanil,config.Gen2LKlientow,kol3,mon0,config.Gen2kil,ran0);
ASK out0 TO Init(mon0);
TELL gen1 TO Generowanie;
TELL gen2 TO Generowanie;
StartSimulation;
wyniki[0]:=GETMONITOR(mon0.czasprzebywania,RStatObj).Mean();
wyniki[1]:=GETMONITOR(mon1.czasprzebywania,RStatObj).Mean();
wyniki[2]:=GETMONITOR(mon2.czasprzebywania,RStatObj).Mean();
wyniki[3]:=GETMONITOR(mon3.czasprzebywania,RStatObj).Mean();
wyniki[4]:=GETMONITOR(mon0.czasprzebywania,RStatObj).StdDev();
wyniki[5]:=GETMONITOR(mon1.czasprzebywania,RStatObj).StdDev();
wyniki[6]:=GETMONITOR(mon2.czasprzebywania,RStatObj).StdDev();
wyniki[7]:=GETMONITOR(mon3.czasprzebywania,RStatObj).StdDev();
wyniki[8]:=GETMONITOR(mon0.liczbazgloszen,ITimedStatObj).Mean();
wyniki[9]:=GETMONITOR(mon1.liczbazgloszen,ITimedStatObj).Mean();
wyniki[10]:=GETMONITOR(mon2.liczbazgloszen,ITimedStatObj).Mean();
wyniki[11]:=GETMONITOR(mon3.liczbazgloszen,ITimedStatObj).Mean();
wyniki[12]:=GETMONITOR(mon0.liczbazgloszen,ITimedStatObj).StdDev();
wyniki[13]:=GETMONITOR(mon1.liczbazgloszen,ITimedStatObj).StdDev();
wyniki[14]:=GETMONITOR(mon2.liczbazgloszen,ITimedStatObj).StdDev();
wyniki[15]:=GETMONITOR(mon3.liczbazgloszen,ITimedStatObj).StdDev();
wyniki[16]:=GETMONITOR(mon0.liczbazajetychkanalow,ITimedStatObj).Mean();
wyniki[17]:=GETMONITOR(mon1.liczbazajetychkanalow,ITimedStatObj).Mean();
wyniki[18]:=GETMONITOR(mon2.liczbazajetychkanalow,ITimedStatObj).Mean();
wyniki[19]:=GETMONITOR(mon3.liczbazajetychkanalow,ITimedStatObj).Mean();
wyniki[20]:=GETMONITOR(mon0.liczbazajetychkanalow,ITimedStatObj).StdDev();
wyniki[21]:=GETMONITOR(mon1.liczbazajetychkanalow,ITimedStatObj).StdDev();
wyniki[22]:=GETMONITOR(mon2.liczbazajetychkanalow,ITimedStatObj).StdDev();
wyniki[23]:=GETMONITOR(mon3.liczbazajetychkanalow,ITimedStatObj).StdDev();
wyniki[24]:=GETMONITOR(mon0.liczbazgloszenwkolejce,ITimedStatObj).Mean();
wyniki[25]:=GETMONITOR(mon1.liczbazgloszenwkolejce,ITimedStatObj).Mean();
wyniki[26]:=GETMONITOR(mon2.liczbazgloszenwkolejce,ITimedStatObj).Mean();
wyniki[27]:=GETMONITOR(mon3.liczbazgloszenwkolejce,ITimedStatObj).Mean();
wyniki[28]:=GETMONITOR(mon0.liczbazgloszenwkolejce,ITimedStatObj).StdDev();
wyniki[29]:=GETMONITOR(mon1.liczbazgloszenwkolejce,ITimedStatObj).StdDev();
wyniki[30]:=GETMONITOR(mon2.liczbazgloszenwkolejce,ITimedStatObj).StdDev();
wyniki[31]:=GETMONITOR(mon3.liczbazgloszenwkolejce,ITimedStatObj).StdDev();
wyniki[32]:=mon0.prawdopodobienstwoobsluzeniazgloszenia;
wyniki[33]:=mon1.prawdopodobienstwoobsluzeniazgloszenia;
wyniki[34]:=mon2.prawdopodobienstwoobsluzeniazgloszenia;
wyniki[35]:=mon3.prawdopodobienstwoobsluzeniazgloszenia;
ResetSimTime(0.0);
DISPOSE(gen1);
DISPOSE(gen2);
DISPOSE(gnz1);
DISPOSE(gnz2);
DISPOSE(gnz3);
DISPOSE(kol1);
DISPOSE(kol2);
DISPOSE(kol3);
DISPOSE(mon0);
DISPOSE(mon1);
DISPOSE(mon2);
DISPOSE(mon3);
DISPOSE(out0);
END PROCEDURE;
PROCEDURE WynikiNaEkran(INOUT wyniki:WynikiSMO);

VAR
p:INTEGER;
BEGIN
OUTPUT("");
OUTPUT("");
OUTPUT("***********************");
OUTPUT(" Wyniki ");
OUTPUT("");
OUTPUT("Sredni czas przebywania zgloszenia w Systemie:",GETMONITOR(wyniki[0],RStatObj).Mean());
OUTPUT("Odychlenie standardowe czasu przebywania zgloszenia w
Systemie:",GETMONITOR(wyniki[4],RStatObj).Mean());
OUTPUT("Sredni czas przebywania zgloszenia w SMO1:",GETMONITOR(wyniki[1],RStatObj).Mean());
OUTPUT("Odychlenie standardowe czasu przebywania zgloszenia w
SMO1:",GETMONITOR(wyniki[5],RStatObj).Mean());
OUTPUT("Sredni czas przebywania zgloszenia w SMO2:",GETMONITOR(wyniki[2],RStatObj).Mean());
OUTPUT("Odychlenie standardowe czasu przebywania zgloszenia w
SMO2:",GETMONITOR(wyniki[6],RStatObj).Mean());
OUTPUT("Sredni czas przebywania zgloszenia w SMO3:",GETMONITOR(wyniki[3],RStatObj).Mean());
OUTPUT("Odychlenie standardowe czasu przebywania zgloszenia w
SMO3:",GETMONITOR(wyniki[7],RStatObj).Mean());
OUTPUT("***********************");
OUTPUT("Srednia liczba zgloszen w Systemie:",GETMONITOR(wyniki[8],RStatObj).Mean());
OUTPUT("Odychlenie standardowe liczby zgloszen w Systemie:",GETMONITOR(wyniki[12],RStatObj).Mean());
OUTPUT("Srednia liczba zgloszen w SMO1:",GETMONITOR(wyniki[9],RStatObj).Mean());
OUTPUT("Odychlenie standardowe liczby zgloszen w SMO1:",GETMONITOR(wyniki[13],RStatObj).Mean());
OUTPUT("Srednia liczba zgloszen w SMO2:",GETMONITOR(wyniki[10],RStatObj).Mean());
OUTPUT("Odychlenie standardowe liczby zgloszen w SMO2:",GETMONITOR(wyniki[14],RStatObj).Mean());
OUTPUT("Srednia liczba zgloszen w SMO3:",GETMONITOR(wyniki[11],RStatObj).Mean());
OUTPUT("Odychlenie standardowe liczby zgloszen w SMO3:",GETMONITOR(wyniki[15],RStatObj).Mean());
OUTPUT("**********************");
OUTPUT("Srednia liczba zajetych kanalow w Systemie:",GETMONITOR(wyniki[16],RStatObj).Mean());
OUTPUT("Odychlenie standardowe liczby zajetych kanalow w
Systemie:",GETMONITOR(wyniki[20],RStatObj).Mean());
OUTPUT("Srednia liczba zajetych kanalow w SMO1:",GETMONITOR(wyniki[17],RStatObj).Mean());
OUTPUT("Odychlenie standardowe liczby zajetych kanalow w SMO1:",GETMONITOR(wyniki[21],RStatObj).Mean());
OUTPUT("Srednia liczba zajetych kanalow w SMO2:",GETMONITOR(wyniki[18],RStatObj).Mean());
OUTPUT("Odychlenie standardowe liczby zajetych kanalow w SMO2:",GETMONITOR(wyniki[22],RStatObj).Mean());
OUTPUT("Srednia liczba zajetych kanalow w SMO3:",GETMONITOR(wyniki[19],RStatObj).Mean());
OUTPUT("Odychlenie standardowe liczby zajetych kanalow w SMO3:",GETMONITOR(wyniki[23],RStatObj).Mean());
OUTPUT("**********************");
OUTPUT("Srednia liczba zgloszen w kolejce w Systemie:",GETMONITOR(wyniki[24],RStatObj).Mean());
OUTPUT("Odychlenie standardowe liczby zgloszen w kolejce w
Systemie:",GETMONITOR(wyniki[28],RStatObj).Mean());
OUTPUT("Srednia liczba zgloszen w kolejce w SMO1:",GETMONITOR(wyniki[25],RStatObj).Mean());
OUTPUT("Odychlenie standardowe liczby zgloszen w kolejce w SMO1:",GETMONITOR(wyniki[29],RStatObj).Mean());
OUTPUT("Srednia liczba zgloszen w kolejce w SMO2:",GETMONITOR(wyniki[26],RStatObj).Mean());
OUTPUT("Odychlenie standardowe liczby zgloszen w kolejce w SMO2:",GETMONITOR(wyniki[30],RStatObj).Mean());
OUTPUT("Srednia liczba zgloszen w kolejce w SMO3:",GETMONITOR(wyniki[27],RStatObj).Mean());
OUTPUT("Odychlenie standardowe liczby zgloszen w kolejce w SMO3:",GETMONITOR(wyniki[31],RStatObj).Mean());
OUTPUT("**********************");
OUTPUT("Prawdopodobienstwo obsluzenia zgloszenia w Systemie:",GETMONITOR(wyniki[32],RStatObj).Mean());
OUTPUT("Prawdopodobienstwo obsluzenia zgloszenia w SMO1:",GETMONITOR(wyniki[33],RStatObj).Mean());
OUTPUT("Prawdopodobienstwo obsluzenia zgloszenia w SMO2:",GETMONITOR(wyniki[34],RStatObj).Mean());
OUTPUT("Prawdopodobienstwo obsluzenia zgloszenia w SMO3:",GETMONITOR(wyniki[35],RStatObj).Mean());
INPUT(p);
END PROCEDURE;
VAR
config:Rekdanych;
wyniki:WynikiSMO;
i:INTEGER;
l:INTEGER;
j:INTEGER;
z:INTEGER;
BEGIN
NEW(ran0);
naekran:=TRUE;
NEW(config);
NEW(wyniki,0..35);
ReadFromFile(config);
FOR i:=0 TO 35
wyniki[i]:=0.0;
END FOR;
z:=1;
FOR i:=1 TO config.LExp
ASK ran0 TO SetSeed(FetchSeed(z));
Symuluj(wyniki,config);