WOJSKOWA AKADEMIA TECHNICZNA

PODSTAWY SYMULACJI

Sprawozdanie z wykonania projektu

Prowadzący: dr inż. Jarosław Rulka

Kalinowski Kamil I8B1S1

Zadanie 1, numer 10

1. Treść zadania:

Napisać program symulujący działanie sieci SMO jak na rysunku:

Przy realizacji zadania należy przyjąć następujące dane z listy przedstawionej poniżej:
a) rozkład zmiennych T

j

: (nrDz + i) mod 6 + 1;

b) rozkład zmiennych O

i

: (nrDz + i + 1) mod 6 + 1;

c) L

i

: (nrDz + i) mod 2 + 1;

d) AL

i

: (nrDz + i + 2) mod 3 + 1;

e) R

j

= (nrDz + i + 5) mod 3 + 1;

f) M

i

= (nrDz + i + 2) mod 4 + 1;

g) Blokowanie zgłoszeń 1. SMO;
h) Klienci niecierpliwi w SMO

i

: N

i

= (nrDz + i) mod 4 (ograniczony czas oczekiwania na

rozpoczęcie obsługi);

gdzie:
i – numer SMO;
j – numer strumienia;
T

j

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

O

i

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

N

i

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

cierpliwe);
R

j

– zmienna losowa oznaczająca wielkość paczki zgłoszeń (wchodzących w tej samej chwili) j-

tego strumienia;
p

k

– prawdopodobieństwa przemieszczenia się zgłoszenia po danym łuku;

L

i

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

AL.

i

– algorytmy kolejek (w przypadku istnienia kolejki z priorytetami należy przyjąć, ż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

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ść zgłoszeń jednocześnie napływających do systemu (1-R)
Pozostałe dane należy określać na początku symulacji. Dane wejściowe i wyniki
odczytywane/zapisywane z/do pliku. Program powinien działać w trybie z i bez komunikatów
ekranowych.

Program powinien umo liwić oszacowanie następujących charakterystyk granicznych systemu oraz
poszczególnych SMO:
• czas przebywania zgłoszenia (średnia, odchylenie standardowe),
• liczbę zgłoszeń (średnia, odchylenie standardowe),
• liczbę zajętych kanałów (średnia, odchylenie standardowe),
• liczbę zgłoszeń w kolejce (średnia, odchylenie standardowe).
• prawdopodobieństwo obsłu enia zgłoszenia.
W sprawozdaniu należy zawrzeć:
− kod źródłowy programu (z komentarzem);
− opis metody wyznaczania charakterystyk (sposób realizacji, wzory estymatorów);
Zadanie zrealizować w języku MODSIM II.
Termin rozliczenia się z realizacji zadania na ostatnich zajęciach laboratoryjnych.

2. Wyznaczenie potrzebnych danych.

Przy realizacji zadania posłużyłem się moim numerem na liście, którego wartość wynosi 10.

a) Rozkład zmiennych losowych T

j

oznaczających czas pomiędzy kolejnymi napływami

zgłoszeń do systemu:

T

j

: (nrDz + i) mod 6 + 1

T

1

: (10 + 1) mod 6 + 1= 6 => Rozkład Weibulla

T

2

: (10 + 2) mod 6 + 1= 6 => Rozkład Wykładniczy

b) Rozklad zmiennych losowych O

i

zmienna losowa oznaczająca czas

obsługi pojedynczego zgłoszenia w gnieździe:

O

i

: (10 + i + 1) mod 6 + 1

O

1

: (10 + 1 + 1) mod 6 + 1=1 => Rozkład Wykładniczy

O

2

: (10 + 2 + 1) mod 6 + 1=2 => Rozkład Erlanga

O

3

: (10 + 3 + 1) mod 6 + 1=3 => Rozkład Normalny

c) Długość kolejki i-tego SMO L

i

L

i

: (nrDz + i) mod 2 + 1

L

3

: (10 + 3) mod 2 + 1 = 2 => Nieograniczona

L

2

: (10 + 2) mod 2 + 1 = 1 => Ograniczona

L

1

: (10 + 1) mod 2 + 1 = 2 => Nieograniczona

d) Algorytmy kolejek (w przypadku istnienia kolejki z priorytetami należy przyjąć, że
zgłoszenia posiadają priorytety) Al

i

:

AL

i

: (nrDz + i + 2) mod 3 + 1

AL

3

: (10 + 3 + 2) mod 3 + 1 = 1 => FIFO

AL

2

: (10 + 2 + 2) mod 3 + 1 = 3 => Priorytetowa

AL

1

: (10 + 1 + 2) mod 3 + 1 = 2 => LIFO

e) Zmienna losowa oznaczająca wielkość paczki zgłoszeń (wchodzących
w tej samej chwili) j-tego strumienia R

j

:

R

j

= (nrDz + i + 5) mod 3 + 1

R

2

= (10 + 2 + 5) mod 3 + 1 = 3 => Rozkład Normalny

R

1

= (10 + 1 + 5) mod 3 + 1 = 2 => Rozkład Erlanga

f) Liczba stanowisk obsługi w gniazdach M

i

:

M

i

= (nrDz + i + 2) mod 4 + 1

M

3

= (10 + 3 + 2) mod 4 + 1 = 4

M

2

= (10 + 2 + 2) mod 4 + 1 = 3

M

1

= (10 + 1 + 2) mod 4 + 1 = 2

h) Klienci niecierpliwi w SMO

i

: N

i

(ograniczony czas oczekiwania na

rozpoczęcie obsługi):
N

i

= (nrDz + i) mod 4

N

3

= (10 + 3) mod 4 = 1 => Rozkład Wykładniczy

N

2

= (10 + 2) mod 4 = 0 => Klient cierpliwy

N

1

= (10 + 1) mod 4 = 3 => Rozkład Normalny

Wzory:

–

Rozkład wykładniczy

-Rozkład Erlanga

-Rozkład Normalny

-Rozkład Weibulla

–

Średnia

–

Odchylenie standardowe

3. Opis działania symulacji.

Klienci generowani są przez dwa generatory. W zależności od generatora

wędrują do kolejki LIFO lub priorytetowej. Następnie po odczekaniu na swoją kolej
(zgodnie z założeniami działania kolejek) są obsługiwani przez gniazdo. Klient
czekający w kolejce pierwszej (LIFO) może się zniecierpliwić. Wtedy opuszcza
system. Istnieje także prawdopodobieństwo, że wróci z powrotem do kolejki lub ta
zostanie zablokowana. Klienci obsłużeni zarówno przez gniazdo pierwsze (o ile nie
wrócą do k1), jak i drugie wędrują do kolejki trzeciej (FIFO). Po odczekaniu na
swoją kolej są obsługiwani przez gniazdo numer trzy. Podczas czekania w FIFO
klient również może się zniecierpliwić, wtedy jak wiadomo opuszcza system. Po
obłużeniu przez gniazdo trzecie klient może opuścić system lub wrócić do kolejki
numer dwa. Wszystkie operacje są monitorowane, a obliczone statystyki są
pokazywane na ekranie i zapisywane do pliku.

Program startuje pobierając potrzebne dane z pliku, którego struktura wygląda

tak jak poniżej:

Następnie pyta użytkownika o tryb pracy- z komunikatami lub bez:

Po wybraniu żądanej opcji następuje generowanie klientów przez dwa generatory i
umieszczenie ich w odpowiednich kolejkach. Każda operacja symulacji jest
monitorowana i na koniec obliczane są statystyki, które wyglądają następująco:

Gdy wybierzemy tryb z wypisywaniem komunikatów wynik symulacji będzie
wyglądał następująco:

Komunikaty, niezależnie od trybu, nie są zapisywane do pliku. Plik wynikowy
zawsze zawiera tylko dane statystyczne.

4. Użyte obiekty.

Aby stworzyć system masowej obsługi oraz zasymulować jego działanie użyłem
następujących modułów oraz ich metod:

•

IOMod – dostarczenie programowi potrzebnych danych oraz zapisanie wyniku
symulacji.

•

RandMod – możliwość generowania liczb losowych.

•

StatMod - dostarczenie statystyk dla poszczególnych obiektów

•

GrpMod – użyty do kolejkowania klientów

•

SimMod – dostarczenie interfejsu dla przeprowadzenia symulacji i innych
funkcjonalości z nią powiązanych.

Kolejnym krokiem było zdefiniowenia typów obiektów potrzebnych do stworzenia
symulacji oraz ich metod.
NesObj -gniazdo
MonObj -monitor
KliObj -klient
GenObj -generator klientów
Que1Obj -pierwsza kolejka (LIFO)
Que2Obj -druga kolejka (priorytetowa)
Que3Obj -trzecia kolejka (FIFO).

Do generowania rozkładów wykładniczego oraz Weibulla określających czas między
napływaniem zgłoszeń do systemu a także rozkładów Erlanga i normalnego
używanych do określenia wielkości paczki zgłoszeń, wykorzystałem dostarczone
przez RandomObj funkcje Weibull, Erlang, Normal oraz Exponential. Po odczekaniu
wyliczonego czasu tworzeni są klienci, losowany jest dla nich priorytet z przedzialu 0
do 10 i inicjowany monitor. Klient wstawiany jest do odpowiedniej kolejki, zależnie
od numeru generatora. Que1Obj jest typu LIFO i ma nieograniczoną długość.
Uwzględnia w monitorze liczbę klientów w całym systemie oraz w swojej instancji.
Wywołuje, także w gnieździe obsługę danego klienta, jeżeli tylko jest jakieś wolne
stanowisko obsługi. Posiada również metody do usunięcia pierwszego w kolejce
obiektu. Que2Obj jest priorytetowa i ma ograniczoną długość. Od kolejki nr 1 różni
się tym, że klienci są cierpliwi.
Que3Obj jest typu FIFO i ma nieograniczoną długość. Podobnie jak w kolejce
pierwszej, także w trzeciej klienci mogą być niecierpliwi, jednak czas niecierpliwości
wyznaczany jest za pomocą rozkładu wykładniczego. NesObj służy do
obsługiwania klientów. Ma ilość stanowisk obsługi
podawaną jako parametr. Dla poszczególnych gniazd wynosi kolejno 2, 3 i 4. Klient
w zależności od wyznaczonego prawdopodobieństwa porusza się po danym łuku.
MonObj przechowuje statystyki dla całego systemu. Należą do niego
metody inicjalizujące monitorowane obiekty na wartości zerowe, liczące ilość
klientów wchodzących i wychodzących do systemu i poszczególnych kolejek
oraz kanałów, a także prawdopodobieństw i czasów obsługi zdarzeń.

5. Kod programu.

MAIN MODULE Main4;

{Zaimportowanie modułów niezbędnych do przeprowadzenia symulacji}

FROM IOMod IMPORT ReadKey, StreamObj, FileUseType(Input),
FileUseType(Output);

FROM SimMod IMPORT StartSimulation, StopSimulation, ResetSimTime,
Interrupt, SimTime, TriggerObj;

FROM GrpMod IMPORT BasicGroupObj, QueueObj, RankedObj, StackObj;
FROM StatMod IMPORT IStatObj, ITimedStatObj, RStatObj, SINTEGER,

TSINTEGER, SREAL, TSREAL;

FROM RandMod IMPORT RandomObj;

TYPE

NesObj = OBJECT; FORWARD;

{Typ Gniazdo}

MonObj = OBJECT; FORWARD;

{Typ Monitor}

KliObj = OBJECT; FORWARD;

{Typ Klient}

GenObj = OBJECT; FORWARD;

{Typ Generator}

Que1Obj = OBJECT; FORWARD;

{Typ Kolejka LIFO}

Que2Obj = OBJECT; FORWARD;

{Typ Kolejka Priorytetowa}

Que3Obj = OBJECT; FORWARD;

{Typ Kolejka FIFO}

VAR
ArrayGen: ARRAY INTEGER OF GenObj;

Que1: Que1Obj;

{Kolejki}

Que2: Que2Obj;

Que3: Que3Obj;
ArrayNes: ARRAY INTEGER OF NesObj;

{Lista gniazd, lista ulatwia dostep}

Mon: MonObj;

{Monitor}

TYPE

GenObj = OBJECT(RandomObj);
Klient: KliObj;

GenNum: INTEGER;
Monitor: MonObj;

GenRoz1Param: REAL;

{1 parametr rozkladu generatora 1}

GenRoz2Param: REAL;

{Drugi}

PackRoz1Param: REAL;

{1 parametr rozkladu paczki}

PackRoz2Param: REAL;

{Drugi}

MaxKli: INTEGER;

{Liczba klientow do wygenerowania}

Czas:REAL;

{inicjalizacja}

ASK METHOD Init(IN NesRozParam1, NesRozParam2: REAL; IN KliMaxGen:
INTEGER; IN PackParam1, PackParam2:REAL; IN Mon: MonObj; IN NrGen:

INTEGER);
TELL METHOD Generuj();

END OBJECT;

KliObj = OBJECT

idklienta, idgen, NRSMO, Priorytet: INTEGER;

InTime, InTime1, InTime2, InTime3: REAL;

Monitor: MonObj;

ASK METHOD Setid(IN idk: INTEGER);

ASK METHOD Setgen(IN gen: INTEGER);

ASK METHOD Init(IN Mon: MonObj);

ASK METHOD SetPrio(IN Prio: INTEGER);

ASK METHOD WTime(IN nrSMO: INTEGER; IN taj: REAL);

{Ustawianie czasu niecierpliwosci}

TELL METHOD SetNC(IN nrSMO: INTEGER; IN czas: REAL; IN kolejka:

BasicGroupObj);

END OBJECT;

Que1Obj = OBJECT(StackObj);

NrKolejki, Pojemnosc: INTEGER;
KliNum: TSINTEGER;

Random: RandomObj;
Trigger: TriggerObj;

Monitor: MonObj;
InTime:REAL;

InTimeSt:SREAL;
W: INTEGER;

ASK METHOD Init(IN Rndm: RandomObj; IN PojemnoscKolejki: INTEGER; IN
Trigr: TriggerObj; IN Mon: MonObj; IN NrKol: INTEGER; IN WYP: INTEGER);

ASK METHOD Dodaj(INOUT KolejnyKlient: KliObj);
OVERRIDE

ASK METHOD ObjTerminate();
ASK METHOD Remove():ANYOBJ;

ASK METHOD RemoveThis(IN kto: ANYOBJ);
END OBJECT;

Que2Obj = OBJECT(RankedObj);

NrKolejki, Pojemnosc: INTEGER;
KliNum: TSINTEGER;

Random: RandomObj;
Trigger: TriggerObj;

Monitor: MonObj;
InTime:REAL;

InTimeSt:SREAL;
W: INTEGER;

ASK METHOD Init(IN Rndm: RandomObj; IN PojemnoscKolejki: INTEGER; IN
Trigr: TriggerObj; IN Mon: MonObj; IN NrKol: INTEGER; IN WYP: INTEGER);

ASK METHOD Dodaj(INOUT KolejnyKlient: KliObj);
OVERRIDE

ASK METHOD Rank(IN a:ANYOBJ;IN b:ANYOBJ):INTEGER;
ASK METHOD ObjTerminate();

ASK METHOD Remove():ANYOBJ;
ASK METHOD RemoveThis(IN kto: ANYOBJ);

END OBJECT;

Que3Obj = OBJECT(QueueObj);
NrKolejki, Pojemnosc: INTEGER;

KliNum: TSINTEGER;
Random: RandomObj;

Trigger: TriggerObj;
Monitor: MonObj;

InTime:REAL;
InTimeSt:SREAL;

W: INTEGER;
ASK METHOD Init(IN Rndm: RandomObj; IN PojemnoscKolejki: INTEGER; IN

Trigr: TriggerObj; IN Mon: MonObj; IN NrKol: INTEGER);

ASK METHOD Dodaj(INOUT KolejnyKlient: KliObj);

OVERRIDE
ASK METHOD ObjTerminate();

ASK METHOD Remove():ANYOBJ;
ASK METHOD RemoveThis(IN kto: ANYOBJ);

END OBJECT;

NesObj = OBJECT(RandomObj);
NrGniazda, StanowiskaObslugi, Aktywne: INTEGER;

PierwszyParametrRozkladuGniazda, DrugiParametrRozkladuGniazda,
TrzeciParametrRozkladuGniazda: REAL;

MomentWyjscia: REAL;
MomentWyjsciaST: SREAL;

Prawdopodobienstwo: REAL;
Trigger: TriggerObj;

Monitor: MonObj;
W: INTEGER;

ASK METHOD Init(IN NesRozParam1, NesRozParam2, TrzeciParRzokladuG:
REAL; IN StObsl, akt: INTEGER; IN Prawdopdob: REAL; IN Trigr: TriggerObj;

IN Mon: MonObj; IN NrGenerat: INTEGER; IN WYP: INTEGER);
TELL METHOD Obsluga(IN kolejka: BasicGroupObj);

END OBJECT;

MonObj = OBJECT

nrMonitora: INTEGER;

SredniCzas, SredniCzas1, SredniCzas2, SredniCzas3: SREAL;
KliNum, KliNum1, KliNum2, KliNum3, liczKli: TSINTEGER;

SrednioKanaly, SrednioKanaly1, SrednioKanaly2, SrednioKanaly3:
TSINTEGER;

KliinQue, KliinQue1, KliinQue2, KliinQue3: TSINTEGER;
Prawdopdob, Prawdopdob1, Prawdopdob2, Prawdopdob3: REAL;

KlienciWchodzacy, KlienciWchodzacy1, KlienciWchodzacy2,
KlienciWchodzacy3: INTEGER;

KlienciWychodzacy, KlienciWychodzacy1, KlienciWychodzacy2,
KlienciWychodzacy3: INTEGER;

SrCzasPrzeby, SrCzasPrzeby1, SrCzasPrzeby2, SrCzasPrzeby3: SREAL;
SrCzasPrzebyOdch, SrCzasPrzebyOdch1, SrCzasPrzebyOdch2,

SrCzasPrzebyOdch3: SREAL;
SrLiczbZglsz, SrLiczbZglsz1, SrLiczbZglsz2, SrLiczbZglsz3: SREAL;

SrLiczbZglszOdch, SrLiczbZglszOdch1, SrLiczbZglszOdch2,
SrLiczbZglszOdch3: SREAL;

SrLiczbZajKan, SrLiczbZajKan1, SrLiczbZajKan2, SrLiczbZajKan3: SREAL;
SrLiczbZajKanOdch, SrLiczbZajKanOdch1, SrLiczbZajKanOdch2,

SrLiczbZajKanOdch3: SREAL;
SrLiczbZglwKol, SrLiczbZglwKol1, SrLiczbZglwKol2, SrLiczbZglwKol3:

SREAL;
SrLiczbZglwKolOdch, SrLiczbZglwKolOdch1, SrLiczbZglwKolOdch2,

SrLiczbZglwKolOdch3: SREAL;
SrPrawdpObslZgl, SrPrawdpObslZgl1, SrPrawdpObslZgl2, SrPrawdpObslZgl3:

SREAL;

ASK METHOD InitMon();
ASK METHOD InicjalizujLiczbeKlientow(IN nrSmo:INTEGER);

ASK METHOD InitSrT(IN nrSmo:INTEGER);
ASK METHOD InitKanBusy(IN nrSmo:INTEGER);

ASK METHOD InitKliInQue(IN nrSmo: INTEGER);

ASK METHOD ZacznijLiczyc(IN nrSmo: INTEGER);

ASK METHOD ZakonczLiczyc(IN nrSmo:INTEGER);
ASK METHOD KlientWychodzi(IN nrSmo: INTEGER);

ASK METHOD KlientWchodzi(IN nrSmo: INTEGER);
ASK METHOD ZmniejszKanaly(IN nrSmo: INTEGER);

ASK METHOD ZwiekszKanaly(IN nrSmo: INTEGER);
ASK METHOD CzasPrzebywaniaKlienta(IN numer:INTEGER; IN czas:REAL);

ASK METHOD ZwiekszLiczbKlientWKolejce(IN nrSmo: INTEGER);
ASK METHOD ZmniejszLiczbKlientWKolejce(IN nrSmo: INTEGER);

ASK METHOD SrKliNum(IN nrSmo: INTEGER; IN KliNum: REAL);
ASK METHOD SrKliNumOdch(IN nrSmo: INTEGER; IN KliNum: REAL);

ASK METHOD SrCzasKlientow(IN nrSmo: INTEGER; IN KliNum: REAL);
ASK METHOD SrCzasKlientowOdch(IN nrSmo: INTEGER; IN KliNum: REAL);

ASK METHOD SrZajetKanal(IN nrSmo: INTEGER; IN KliNum: REAL);
ASK METHOD SrZajetKanalOdch(IN nrSmo: INTEGER; IN KliNum: REAL);

ASK METHOD SrLiczKlientWKolejce(IN nrSmo: INTEGER; IN KliNum: REAL);
ASK METHOD SrLiczKlientWKolejceOdch(IN nrSmo: INTEGER; IN KliNum:

REAL);
ASK METHOD CouPos(IN nrSmo: INTEGER);

ASK METHOD PrwdObs(IN nrSmo:INTEGER;IN KliNum:REAL);

END OBJECT;

OBJECT GenObj;

ASK METHOD Init(IN NesRozParam1, NesRozParam2: REAL; IN KliMaxGen:
INTEGER; IN PackParam1, PackParam2:REAL; IN Mon: MonObj; IN NrGen:

INTEGER);

BEGIN

GenNum:=NrGen;
GenRoz1Param:= NesRozParam1;

GenRoz2Param:= NesRozParam2;
PackRoz1Param:= PackParam1;

PackRoz2Param:=PackParam2;
MaxKli:= KliMaxGen;

Monitor:=Mon;

END METHOD;

TELL METHOD Generuj;
VAR

nrklienta: INTEGER;
Klient: KliObj;

CzasMiedzyZgloszeniami, PackRoz: REAL;
PackRozInt, Licznik, KlienciWygenerowani, PozostaloKlientow: INTEGER;

BEGIN

KlienciWygenerowani:=0;
WHILE (KlienciWygenerowani<MaxKli)

CASE GenNum

WHEN 1:

PackRoz:=Erlang(PackRoz1Param, TRUNC(PackRoz2Param));

PackRoz:=ABS(PackRoz);

WHEN 2:

PackRoz:=Normal(PackRoz1Param, PackRoz2Param);

PackRoz:=ABS(PackRoz);
END CASE;

PackRozInt:=TRUNC(PackRoz);

KlienciWygenerowani:=KlienciWygenerowani+PackRozInt;
PozostaloKlientow:=MaxKli-KlienciWygenerowani;

IF PozostaloKlientow<0

PackRozInt:=PackRozInt+PozostaloKlientow;
END IF;

{Generowanie czasu miedzy zgloszeniami do systemu}

CASE GenNum

WHEN 1:

CzasMiedzyZgloszeniami:=Weibull(GenRoz1Param,GenRoz2Param);

CzasMiedzyZgloszeniami:=ABS(CzasMiedzyZgloszeniami);

WHEN 2:

CzasMiedzyZgloszeniami:=Exponential(PackRoz1Param);

CzasMiedzyZgloszeniami:=ABS(CzasMiedzyZgloszeniami);

END CASE;

{czekanie}

WAIT DURATION CzasMiedzyZgloszeniami ON INTERRUPT END WAIT;

{Tworzenie klientow}

FOR Licznik:=1 TO PackRozInt

NEW (Klient);
ASK Monitor TO ZacznijLiczyc(0);

ASK Klient TO Setid(nrklienta);
ASK Klient TO Setgen(GenNum);

{Losowanie priorytetu z przedzialu 0 - 10}

ASK Klient TO SetPrio(UniformInt(0,10));

ASK Klient TO Init(Mon);
nrklienta:=nrklienta+1;

Czas:=SimTime;

ASK Klient TO WTime(0,Czas);

{dodanie do odpowiedniej kolejki zaleznie od numeru generatora}

CASE GenNum

WHEN 1:

ASK Que1 TO Dodaj(Klient);

WHEN 2:

ASK Que2 TO Dodaj(Klient);

END CASE;

END FOR;

END WHILE;

END METHOD;

END OBJECT;

{Obiekt klient}

OBJECT KliObj;

ASK METHOD Setid(IN idk: INTEGER);
BEGIN

idklienta:=idk;
END METHOD;

ASK METHOD Setgen(IN gen: INTEGER);

BEGIN
idgen:=gen;

END METHOD;

ASK METHOD Init(IN Mon: MonObj);

BEGIN
Monitor:= Mon;

END METHOD;

ASK METHOD SetPrio(IN Prio: INTEGER);
BEGIN

Priorytet:=Prio;
END METHOD;

ASK METHOD WTime(IN nrSMO: INTEGER; IN czas: REAL);

BEGIN

NRSMO:=nrSMO;

CASE NRSMO

WHEN 0:
InTime:=czas;

WHEN 1:
InTime1:=czas;

WHEN 2:
InTime2:=czas;

WHEN 3:
InTime3:=czas;

END CASE;
END METHOD;

TELL METHOD SetNC(IN nrSMO: INTEGER; IN czas: REAL; IN kolejka:

BasicGroupObj);
BEGIN

NRSMO:=nrSMO;

WAIT DURATION czas;

ON INTERRUPT;

END WAIT;
ASK kolejka TO RemoveThis(SELF);

ASK Monitor TO KlientWychodzi(nrSMO);
ASK Monitor TO ZmniejszLiczbKlientWKolejce(nrSMO);

ASK Monitor TO KlientWychodzi(0);
ASK Monitor TO ZmniejszLiczbKlientWKolejce(0);

DISPOSE(SELF);

END METHOD;

END OBJECT;

{Kolejka 1 LIFO}

OBJECT Que1Obj;

ASK METHOD Init(IN Rndm: RandomObj; IN PojemnoscKolejki: INTEGER; IN

Trigr: TriggerObj; IN Mon: MonObj; IN NrKol: INTEGER; IN WYP: INTEGER);
BEGIN

Pojemnosc:=PojemnoscKolejki;
Random := Rndm;

Monitor:=Mon;
KliNum:= 0;

Trigger:=Trigr;
NrKolejki:=NrKol;

W:=WYP;
END METHOD;

{Dodawanie do kolejki}

ASK METHOD Dodaj(INOUT KolejnyKlient: KliObj);
VAR

czasNiecierpliwosci:REAL;
BEGIN

Add(KolejnyKlient);

{wypisywanie komunikatu}

IF W=1

OUTPUT("Klient ",KolejnyKlient.idklienta,"/",KolejnyKlient.idgen," i
priorytecie ",KolejnyKlient.Priorytet, " dodany do kolejki 1. ",SimTime);

END IF;
ASK Monitor TO ZacznijLiczyc(1);

ASK Monitor TO ZwiekszLiczbKlientWKolejce(0);
ASK Monitor TO ZwiekszLiczbKlientWKolejce(1);

ASK KolejnyKlient TO WTime(1,SimTime);
ASK Monitor TO KlientWchodzi(0);

ASK Monitor TO KlientWchodzi(1);
KliNum:=KliNum+1;

{niecierpliwosc o rozkladzie normalnym}

czasNiecierpliwosci:= ASK Random TO Normal(1.0,50.5);

IF ASK ArrayNes[NrKolejki] TO Aktywne < ASK ArrayNes[NrKolejki] TO

StanowiskaObslugi
TELL ArrayNes[NrKolejki] TO Obsluga(SELF);

END IF;
END METHOD;

ASK METHOD ObjTerminate();

VAR
KolejnyKlient:ANYOBJ;

BEGIN
FOREACH KolejnyKlient IN SELF

RemoveThis(KolejnyKlient);
DISPOSE(KolejnyKlient);

END FOREACH;
INHERITED ObjTerminate();

END METHOD;

ASK METHOD RemoveThis(IN kto: ANYOBJ);

BEGIN

INHERITED RemoveThis(kto);
END METHOD;

{Usuwanie klienta z poczatku kolejki}

ASK METHOD Remove():ANYOBJ;
BEGIN

ASK Trigger TO Release;
RETURN INHERITED Remove();

END METHOD;

END OBJECT;

{druga kolejka- priorytetowa}

OBJECT Que2Obj;

ASK METHOD Init(IN Rndm: RandomObj; IN PojemnoscKolejki: INTEGER; IN

Trigr: TriggerObj; IN Mon: MonObj; IN NrKol: INTEGER; IN WYP: INTEGER);
BEGIN

Pojemnosc:=PojemnoscKolejki;
Random := Rndm;

Monitor:=Mon;
Trigger:=Trigr;

KliNum:= 0;
NrKolejki:=NrKol;

W:=WYP;
END METHOD;

{Dodawanie klienta do kolejki}

ASK METHOD Dodaj(INOUT KolejnyKlient: KliObj);

VAR

czasNiecierpliwosci:REAL;

BEGIN

IF numberIn < Pojemnosc

{komunikat}

IF W=1

OUTPUT("Klient ",KolejnyKlient.idklienta,"/",KolejnyKlient.idgen," i
priorytecie ",KolejnyKlient.Priorytet," dodany do kolejki 2. ", SimTime);

END IF;
Add(KolejnyKlient);

ASK Monitor TO ZacznijLiczyc(2);
ASK Monitor TO ZwiekszLiczbKlientWKolejce(0);

ASK Monitor TO ZwiekszLiczbKlientWKolejce(2);
ASK KolejnyKlient TO WTime(2,SimTime);

ASK Monitor TO KlientWchodzi(0);
ASK Monitor TO KlientWchodzi(2);

KliNum:=KliNum+1;
IF ASK ArrayNes[NrKolejki] TO Aktywne < ASK ArrayNes[NrKolejki] TO

StanowiskaObslugi
TELL ArrayNes[NrKolejki] TO Obsluga(SELF);

END IF;
ELSE

DISPOSE(KolejnyKlient);
END IF;

END METHOD;

ASK METHOD Rank(IN a:ANYOBJ;IN b:ANYOBJ):INTEGER;

VAR

KlientA:KliObj;

KlientB:KliObj;
BEGIN

KlientA:=a;
KlientB:=b;

IF ASK KlientA TO Priorytet < ASK KlientB TO Priorytet
RETURN -1;

END IF;
IF ASK KlientA TO Priorytet > ASK KlientB TO Priorytet

RETURN 1;
END IF;

RETURN 0;
END METHOD;

ASK METHOD ObjTerminate();

VAR
KolejnyKlient:ANYOBJ;

BEGIN
FOREACH KolejnyKlient IN SELF

RemoveThis(KolejnyKlient);
DISPOSE(KolejnyKlient);

END FOREACH;
INHERITED ObjTerminate();

END METHOD;

ASK METHOD RemoveThis(IN kto: ANYOBJ);
BEGIN

INHERITED RemoveThis(kto);
END METHOD;

ASK METHOD Remove():ANYOBJ;

BEGIN
ASK Trigger TO Release;

RETURN INHERITED Remove();
END METHOD;

END OBJECT;

{Kolejka FIFO}

OBJECT Que3Obj;

ASK METHOD Init(IN Rndm: RandomObj; IN PojemnoscKolejki: INTEGER; IN

Trigr: TriggerObj; IN Mon: MonObj; IN NrKol: INTEGER);
BEGIN

Pojemnosc:=PojemnoscKolejki;
Random := Rndm;

Trigger:=Trigr;
Monitor:=Mon;

KliNum:= 0;
NrKolejki:=NrKol;

END METHOD;

ASK METHOD Dodaj(INOUT KolejnyKlient: KliObj);
VAR

czasNiecierpliwosci:REAL;
BEGIN

Add(KolejnyKlient);
ASK Monitor TO ZacznijLiczyc(3);

ASK Monitor TO ZwiekszLiczbKlientWKolejce(0);

ASK Monitor TO ZwiekszLiczbKlientWKolejce(3);

ASK KolejnyKlient TO WTime(3,SimTime);
ASK Monitor TO KlientWchodzi(0);

ASK Monitor TO KlientWchodzi(3);
KliNum:=KliNum+1;

czasNiecierpliwosci:= ASK Random TO Exponential(1.0/50.5);
czasNiecierpliwosci:=ABS(czasNiecierpliwosci);

IF ASK ArrayNes[NrKolejki] TO Aktywne < ASK ArrayNes[NrKolejki] TO

StanowiskaObslugi

TELL ArrayNes[NrKolejki] TO Obsluga(SELF);
END IF;

END METHOD;

ASK METHOD ObjTerminate();

VAR
KolejnyKlient:ANYOBJ;

BEGIN
FOREACH KolejnyKlient IN SELF

RemoveThis(KolejnyKlient);
DISPOSE(KolejnyKlient);

END FOREACH;
INHERITED ObjTerminate();

END METHOD;

ASK METHOD RemoveThis(IN kto: ANYOBJ);
BEGIN

INHERITED RemoveThis(kto);
END METHOD;

ASK METHOD Remove():ANYOBJ;

BEGIN
ASK Trigger TO Release;

RETURN INHERITED Remove();
END METHOD;

END OBJECT;

{Gniazdo}

OBJECT NesObj;

ASK METHOD Init(IN NesRozParam1, NesRozParam2, TrzeciParRzokladuG: REAL;
IN StObsl: INTEGER; IN akt: INTEGER; IN Prawdopdob: REAL; IN Trigr:

TriggerObj; IN Mon: MonObj;IN NrGenerat: INTEGER; IN WYP: INTEGER);
BEGIN

PierwszyParametrRozkladuGniazda:=NesRozParam1;
DrugiParametrRozkladuGniazda:=NesRozParam2;

TrzeciParametrRozkladuGniazda:=TrzeciParRzokladuG;
StanowiskaObslugi:= StObsl;

Aktywne:= akt;
Trigger := Trigr;

Monitor:=Mon;
Prawdopodobienstwo:=Prawdopdob;

NrGniazda:=NrGenerat;
W:=WYP;

END METHOD;

TELL METHOD Obsluga(IN kolejka: BasicGroupObj);
VAR

Rozklad: REAL;

Klient: KliObj;

pom1: INTEGER;
pom2: INTEGER;

BEGIN
WHILE ASK kolejka TO numberIn > 0

Klient:= ASK kolejka TO Remove;
ASK Monitor TO ZmniejszLiczbKlientWKolejce(0);

ASK Monitor TO ZmniejszLiczbKlientWKolejce(NrGniazda);
Aktywne:=Aktywne+1;

ASK Monitor TO ZwiekszKanaly(NrGniazda);
ASK Monitor TO ZwiekszKanaly(0);

IF NrGniazda=1

Interrupt(Klient,"SetNC");

Rozklad:=Exponential(PierwszyParametrRozkladuGniazda);

Rozklad:=ABS(Rozklad);
WAIT DURATION Rozklad;

ON INTERRUPT
END WAIT;

pom1:=UniformInt(0,3);
pom2:=UniformInt(0,3);

IF Rozklad>Normal(1.5,2.5)

IF W=1
OUTPUT("Klient ",Klient.idklienta,"/",Klient.idgen," odchodzi bo stracil

cierpliwosc. ", SimTime);
END IF;

ASK Monitor TO ZakonczLiczyc(1);
ASK Monitor TO CzasPrzebywaniaKlienta(1,SimTime-ASK Klient TO

InTime1);
ASK Monitor TO KlientWychodzi(1);

Aktywne:=Aktywne-1;
ASK Monitor TO ZmniejszKanaly(1);

ASK Monitor TO ZmniejszKanaly(0);
DISPOSE(Klient);

ELSIF pom1=pom2
ASK Monitor TO ZakonczLiczyc(1);

ASK Monitor TO CzasPrzebywaniaKlienta(1,SimTime-ASK Klient TO
InTime1);

ASK Monitor TO KlientWychodzi(1);
Aktywne:=Aktywne-1;

ASK Monitor TO ZmniejszKanaly(1);
ASK Monitor TO ZmniejszKanaly(0);

IF W=1
OUTPUT("Klient ",Klient.idklienta,"/",Klient.idgen," obsluzony przez G1.

", SimTime);
OUTPUT("Klient ",Klient.idklienta,"/", Klient.idgen," wraca do kolejki 1.

", SimTime);
END IF;

ASK Que1 TO Dodaj(Klient);

ELSIF pom1<>pom2

ASK Monitor TO ZakonczLiczyc(1);
ASK Monitor TO CzasPrzebywaniaKlienta(2,SimTime-ASK Klient TO

InTime1);

ASK Monitor TO KlientWychodzi(1);

Aktywne:=Aktywne-1;
ASK Monitor TO ZmniejszKanaly(1);

ASK Monitor TO ZmniejszKanaly(0);
ASK Que3 TO Dodaj(Klient);

IF W=1
OUTPUT("Klient ",Klient.idklienta,"/",Klient.idgen," obsluzony przez

Gniazdo",Klient.idgen," i idzie do K3. ", SimTime);

END IF;

END IF;

ELSIF NrGniazda=2

Rozklad:=Erlang(PierwszyParametrRozkladuGniazda,

TRUNC(DrugiParametrRozkladuGniazda));

Rozklad:=ABS(Rozklad);

WAIT DURATION Rozklad;

ON INTERRUPT
END WAIT;

ASK Monitor TO ZakonczLiczyc(2);

ASK Monitor TO CzasPrzebywaniaKlienta(2,SimTime-ASK Klient TO
InTime1);

ASK Monitor TO KlientWychodzi(2);
Aktywne:=Aktywne-1;

ASK Monitor TO ZmniejszKanaly(2);
ASK Monitor TO ZmniejszKanaly(0);

IF W=1
OUTPUT("Klient ",Klient.idklienta,"/",Klient.idgen," obsluzony przez

Gniazdo",Klient.idgen," i idzie do K3. ", SimTime);
END IF;

ASK Que3 TO Dodaj(Klient);

ELSIF NrGniazda=3
Interrupt(Klient,"SetNC");

Rozklad:=Normal(PierwszyParametrRozkladuGniazda,
DrugiParametrRozkladuGniazda);

Rozklad:=ABS(Rozklad);

WAIT DURATION Rozklad;
ON INTERRUPT

END WAIT;
pom1:=UniformInt(0,5);

pom2:=UniformInt(0,5);
IF pom1=pom2

ASK Monitor TO ZakonczLiczyc(3);
ASK Monitor TO CzasPrzebywaniaKlienta(3,SimTime-ASK Klient TO

InTime1);
ASK Monitor TO KlientWychodzi(3);

Aktywne:=Aktywne-1;
ASK Monitor TO ZmniejszKanaly(3);

ASK Monitor TO ZmniejszKanaly(0);
IF W=1

OUTPUT("Klient ",Klient.idklienta,"/", Klient.idgen," obsluzony przez G3.
", SimTime);

OUTPUT("Klient ",Klient.idklienta,"/", Klient.idgen," wraca do kolejki 2.

", SimTime);

END IF;
ASK Que2 TO Dodaj(Klient);

ELSIF pom1<>pom2

ASK Monitor TO ZakonczLiczyc(3);

ASK Monitor TO ZakonczLiczyc(0);

ASK Monitor TO CzasPrzebywaniaKlienta(3,SimTime-ASK Klient TO

InTime1);

ASK Monitor TO CzasPrzebywaniaKlienta(0,SimTime-ASK Klient TO

InTime);
IF W=1

OUTPUT("Klient ",Klient.idklienta,"/",Klient.idgen, " zostal obsluzony
przez G3 i wychodzi z systemu. ", SimTime);

END IF;
DISPOSE(Klient);

ASK Monitor TO KlientWychodzi(3);
Aktywne:=Aktywne-1;

ASK Monitor TO ZmniejszKanaly(3);
ASK Monitor TO ZmniejszKanaly(0);

END IF;

END IF;
END WHILE;

END METHOD;
END OBJECT;

OBJECT MonObj;

ASK METHOD InitMon();
BEGIN

KliNum:=0;
KliNum1:=0;

KliNum2:=0;
KliNum3:=0;

END METHOD;

ASK METHOD InicjalizujLiczbeKlientow(IN nrSmo:INTEGER); {zerowanie
licza}

BEGIN
nrMonitora:=nrSmo;

CASE nrMonitora
WHEN 0:

KliNum:=0;
WHEN 1:

KliNum1:=0;
WHEN 2:

KliNum2:=0;
WHEN 3:

KliNum3:=0;
END CASE;

END METHOD;

ASK METHOD InitSrT(IN nrSmo:INTEGER); {zerowanie czasu przebywania w}
BEGIN

nrMonitora:=nrSmo;
CASE nrMonitora

WHEN 0:

SredniCzas:=0.0;

WHEN 1:
SredniCzas1:=0.0;

WHEN 2:
SredniCzas2:=0.0;

WHEN 3:
SredniCzas3:=0.0;

END CASE;
END METHOD;

ASK METHOD InitKanBusy(IN nrSmo:INTEGER); {zerowanie licznika zajetych

kanalow}
BEGIN

nrMonitora:=nrSmo;
CASE nrMonitora

WHEN 0:
SrednioKanaly:=0;

WHEN 1:
SrednioKanaly1:=0;

WHEN 2:
SrednioKanaly2:=0;

WHEN 3:
SrednioKanaly3:=0;

END CASE;
END METHOD;

ASK METHOD InitKliInQue(IN nrSmo: INTEGER); {zerowanie licznika klienta w

kolejkach}
BEGIN

nrMonitora:=nrSmo;
CASE nrMonitora

WHEN 0:
KliinQue:=0;

WHEN 1:
KliinQue1:=0;

WHEN 2:
KliinQue2:=0;

WHEN 3:
KliinQue3:=0;

END CASE;
END METHOD;

ASK METHOD ZacznijLiczyc(IN nrSmo: INTEGER); {do zliczania Klientow
wchodzacych do systemu}

BEGIN
nrMonitora:=nrSmo;

CASE nrMonitora
WHEN 0:

KlienciWchodzacy:=KlienciWchodzacy+1;
WHEN 1:

KlienciWchodzacy1:=KlienciWchodzacy1+1;
WHEN 2:

KlienciWchodzacy2:=KlienciWchodzacy2+1;
WHEN 3:

KlienciWchodzacy3:=KlienciWchodzacy3+1;
END CASE;

END METHOD;

ASK METHOD ZakonczLiczyc(IN nrSmo: INTEGER); {do zliczania Klientow

wychodzacych z systemu}

BEGIN
nrMonitora:=nrSmo;

CASE nrMonitora
WHEN 0:

KlienciWychodzacy:=KlienciWychodzacy+1;
WHEN 1:

KlienciWychodzacy1:=KlienciWychodzacy1+1;
WHEN 2:

KlienciWychodzacy2:=KlienciWychodzacy2+1;
WHEN 3:

KlienciWychodzacy3:=KlienciWychodzacy3+1;
END CASE;

END METHOD;

ASK METHOD CouPos(IN nrSmo: INTEGER);
BEGIN

nrMonitora:=nrSmo;
CASE nrMonitora

WHEN 0:
Prawdopdob:=1.0;

WHEN 1:
Prawdopdob1:=0.2;

WHEN 2:
Prawdopdob2:=FLOAT(KlienciWychodzacy2)/FLOAT(KlienciWchodzacy2);

WHEN 3:
Prawdopdob3:=0.3;

END CASE;
END METHOD;

ASK METHOD KlientWychodzi(IN nrSmo: INTEGER);{zmniejsza licznikow

Klientow}
BEGIN

nrMonitora:=nrSmo;
CASE nrMonitora

WHEN 0:
KliNum:=KliNum-1;

WHEN 1:
KliNum1:=KliNum1-1;

WHEN 2:
KliNum2:=KliNum2-1;

WHEN 3:
KliNum3:=KliNum3-1;

END CASE;
END METHOD;

ASK METHOD KlientWchodzi(IN nrSmo: INTEGER); {zwieksza KliNum Klientow}

BEGIN
nrMonitora:=nrSmo;

CASE nrMonitora
WHEN 0:

KliNum:=KliNum+1;
WHEN 1:

KliNum1:=KliNum1+1;
WHEN 2:

KliNum2:=KliNum2+1;
WHEN 3:

KliNum3:=KliNum3+1;

END CASE;

END METHOD;

ASK METHOD ZwiekszLiczbKlientWKolejce(IN nrSmo: INTEGER); {zwiekszenie
licza Klientow z kolejki}

BEGIN
nrMonitora:=nrSmo;

CASE nrMonitora
WHEN 0:

KliinQue:=KliinQue+1;
WHEN 1:

KliinQue1:=KliinQue1+1;
WHEN 2:

KliinQue2:=KliinQue2+1;
WHEN 3:

KliinQue3:=KliinQue3+1;
END CASE;

END METHOD;

ASK METHOD ZmniejszLiczbKlientWKolejce(IN nrSmo: INTEGER); {zmniejszenie

licznika Klientow z kolejki}
BEGIN

nrMonitora:=nrSmo;
CASE nrMonitora

WHEN 0:
KliinQue:=KliinQue-1;

WHEN 1:
KliinQue1:=KliinQue1-1;

WHEN 2:
KliinQue2:=KliinQue2-1;

WHEN 3:
KliinQue3:=KliinQue3-1;

END CASE;
END METHOD;

ASK METHOD ZmniejszKanaly(IN nrSmo: INTEGER); {zmniejszenie licznika
zajetych Kanalow}

BEGIN
nrMonitora:=nrSmo;

CASE nrMonitora
WHEN 0:

SrednioKanaly:=SrednioKanaly-1;
WHEN 1:

SrednioKanaly1:=SrednioKanaly1-1;
WHEN 2:

SrednioKanaly2:=SrednioKanaly2-1;
WHEN 3:

SrednioKanaly3:=SrednioKanaly3-1;
END CASE;

END METHOD;

ASK METHOD ZwiekszKanaly(IN nrSmo: INTEGER); {zwiekszenie licznika
zajetych Kanalow}

BEGIN
nrMonitora:=nrSmo;

CASE nrMonitora

WHEN 0:

SrednioKanaly:=SrednioKanaly+1;
WHEN 1:

SrednioKanaly1:=SrednioKanaly1+1;
WHEN 2:

SrednioKanaly2:=SrednioKanaly2+1;
WHEN 3:

SrednioKanaly3:=SrednioKanaly3+1;
END CASE;

END METHOD;

ASK METHOD CzasPrzebywaniaKlienta(IN nrSmo: INTEGER; IN czas:REAL);
{zliczanie czasu przebywania kienta w semo}

BEGIN
nrMonitora := nrSmo;

CASE nrMonitora
WHEN 0:

SredniCzas:= czas;
WHEN 1:

SredniCzas1:= czas;
WHEN 2:

SredniCzas2:= czas;
WHEN 3:

SredniCzas3:= czas;
END CASE;

END METHOD;

ASK METHOD SrKliNum(IN nrSmo: INTEGER; IN KliNum: REAL);
BEGIN

nrMonitora:=nrSmo;
CASE nrMonitora

WHEN 0:
SrLiczbZglsz:=KliNum;

WHEN 1:
SrLiczbZglsz1:=KliNum;

WHEN 2:
SrLiczbZglsz2:=KliNum;

WHEN 3:
SrLiczbZglsz3:=KliNum;

END CASE;
END METHOD;

ASK METHOD SrKliNumOdch(IN nrSmo: INTEGER; IN KliNum: REAL);

BEGIN
nrMonitora:=nrSmo;

CASE nrMonitora
WHEN 0:

SrLiczbZglszOdch:=KliNum;
WHEN 1:

SrLiczbZglszOdch1:=KliNum;
WHEN 2:

SrLiczbZglszOdch2:=KliNum;
WHEN 3:

SrLiczbZglszOdch3:=KliNum;
END CASE;

END METHOD;

ASK METHOD SrCzasKlientow(IN nrSmo: INTEGER; IN KliNum: REAL);

BEGIN

nrMonitora:=nrSmo;
CASE nrMonitora

WHEN 0:
SrCzasPrzeby:=KliNum;

WHEN 1:
SrCzasPrzeby1:=KliNum;

WHEN 2:
SrCzasPrzeby2:=KliNum;

WHEN 3:
SrCzasPrzeby3:=KliNum;

END CASE;
END METHOD;

ASK METHOD SrCzasKlientowOdch(IN nrSmo: INTEGER; IN KliNum: REAL);

BEGIN
nrMonitora:=nrSmo;

CASE nrMonitora
WHEN 0:

SrCzasPrzebyOdch:=KliNum;
WHEN 1:

SrCzasPrzebyOdch1:=KliNum;
WHEN 2:

SrCzasPrzebyOdch2:=KliNum;
WHEN 3:

SrCzasPrzebyOdch3:=KliNum;
END CASE;

END METHOD;

ASK METHOD SrZajetKanal(IN nrSmo: INTEGER; IN KliNum: REAL);
BEGIN

nrMonitora:=nrSmo;
CASE nrMonitora

WHEN 0:
SrLiczbZajKan:=KliNum;

WHEN 1:
SrLiczbZajKan1:=KliNum;

WHEN 2:
SrLiczbZajKan2:=KliNum;

WHEN 3:
SrLiczbZajKan3:=KliNum;

END CASE;
END METHOD;

ASK METHOD SrZajetKanalOdch(IN nrSmo: INTEGER; IN KliNum: REAL);
BEGIN

nrMonitora:=nrSmo;
CASE nrMonitora

WHEN 0:
SrLiczbZajKanOdch:=KliNum;

WHEN 1:
SrLiczbZajKanOdch1:=KliNum;

WHEN 2:
SrLiczbZajKanOdch2:=KliNum;

WHEN 3:
SrLiczbZajKanOdch3:=KliNum;

END CASE;
END METHOD;

ASK METHOD SrLiczKlientWKolejce(IN nrSmo: INTEGER; IN KliNum: REAL);

BEGIN
nrMonitora:=nrSmo;

CASE nrMonitora
WHEN 0:

SrLiczbZglwKol:=KliNum;
WHEN 1:

SrLiczbZglwKol1:=KliNum;
WHEN 2:

SrLiczbZglwKol2:=KliNum;
WHEN 3:

SrLiczbZglwKol3:=KliNum;
END CASE;

END METHOD;

ASK METHOD SrLiczKlientWKolejceOdch(IN nrSmo: INTEGER; IN KliNum: REAL);
BEGIN

nrMonitora:=nrSmo;
CASE nrMonitora

WHEN 0:
SrLiczbZglwKolOdch:=KliNum;

WHEN 1:
SrLiczbZglwKolOdch1:=KliNum;

WHEN 2:
SrLiczbZglwKolOdch2:=KliNum;

WHEN 3:
SrLiczbZglwKolOdch3:=KliNum;

END CASE;
END METHOD;

ASK METHOD PrwdObs(IN nrSmo:INTEGER;IN KliNum:REAL);

BEGIN
nrMonitora:=nrSmo;

CASE nrMonitora
WHEN 0:

SrPrawdpObslZgl:=KliNum;
WHEN 1:

SrPrawdpObslZgl1:=KliNum;
WHEN 2:

SrPrawdpObslZgl2:=KliNum;
WHEN 3:

SrPrawdpObslZgl3:=KliNum;
END CASE;

END METHOD;
END OBJECT;

{Symulacja}

VAR

Plik1: StreamObj;

Wyp: INTEGER;
IO: StreamObj;

TuWczytuje:STRING;
czekaj: INTEGER;

i: INTEGER;
{Zmienne do inicjalizacji generatora1}

PAr1RozkGen1, PAr2RozkGen1:REAL;
LIczbKLienGen1:INTEGER;

Par1RozKPacz1, Par2RozKPacz1:REAL;

{Zmienne do inicjalizacji generatora2}

PAr1RozkGen2, PAr2RozkGen2:REAL;
LIczbKLienGen2:INTEGER;

Par1RozKPacz2, Par2RozKPacz2:REAL;
{Zmienne do inicjalizacji gniazda1}

Par1RozKGNI1, Par2RozKGNI1, Par3RozKGNI1: REAL;
{Zmienne do inicjalizacji gniazda2}

Par1RozKGNI2, Par2RozKGNI2, Par3RozKGNI2: REAL;
{Zmienne do inicjalizacji gniazda3}

Par1RozKGNI3, Par2RozKGNI3, Par3RozKGNI3: REAL;
ran: RandomObj;

trigg:TriggerObj;
Kolejka2Pojemnosc:INTEGER;

ii: INTEGER;
BEGIN

NEW(ArrayGen, 1..2);

FOR i:=1 TO 2
NEW(ArrayGen[i]);

END FOR;
NEW(ArrayNes, 1..3);

FOR i:=1 TO 3
NEW(ArrayNes[i]);

END FOR;
NEW(Que1);

NEW(Que2);
NEW(Que3);

NEW(trigg);
NEW(Mon);

NEW(ran);

NEW(IO);
ASK IO TO Open("Input.txt",Input);

NEW(Plik1);
ASK Plik1 TO Open("Wynik.txt",Output);

{inicjalizacji generatora1}

ASK IO TO ReadLine(TuWczytuje);

ASK IO TO ReadLine(TuWczytuje);

PAr1RozkGen1:=STRTOREAL(TuWczytuje);

ASK IO TO ReadLine(TuWczytuje);
ASK IO TO ReadLine(TuWczytuje);

PAr2RozkGen1:=STRTOREAL(TuWczytuje);

ASK IO TO ReadLine(TuWczytuje);

ASK IO TO ReadLine(TuWczytuje);

Par1RozKPacz1:=STRTOREAL(TuWczytuje);

ASK IO TO ReadLine(TuWczytuje);
ASK IO TO ReadLine(TuWczytuje);

Par2RozKPacz1:=STRTOREAL(TuWczytuje);

ASK IO TO ReadLine(TuWczytuje);

ASK IO TO ReadLine(TuWczytuje);

LIczbKLienGen1:=STRTOINT(TuWczytuje);

{inicjalizacji generatora2}
ASK IO TO ReadLine(TuWczytuje);

ASK IO TO ReadLine(TuWczytuje);

PAr1RozkGen2:=STRTOREAL(TuWczytuje);

PAr2RozkGen2 := 0.5;

ASK IO TO ReadLine(TuWczytuje);

ASK IO TO ReadLine(TuWczytuje);

Par1RozKPacz2:=STRTOREAL(TuWczytuje);

ASK IO TO ReadLine(TuWczytuje);
ASK IO TO ReadLine(TuWczytuje);

Par2RozKPacz2:=STRTOREAL(TuWczytuje);

ASK IO TO ReadLine(TuWczytuje);

ASK IO TO ReadLine(TuWczytuje);

LIczbKLienGen2:=STRTOINT(TuWczytuje);

{Inicjalizacja gniazda1}
ASK IO TO ReadLine(TuWczytuje);

ASK IO TO ReadLine(TuWczytuje);

Par1RozKGNI1:=STRTOREAL(TuWczytuje);

Par2RozKGNI1:=1.0;

Par3RozKGNI1:=0.0;

{Inicjalizacja gniazda2}
ASK IO TO ReadLine(TuWczytuje);

ASK IO TO ReadLine(TuWczytuje);

Par1RozKGNI2:=STRTOREAL(TuWczytuje);

ASK IO TO ReadLine(TuWczytuje);
ASK IO TO ReadLine(TuWczytuje);

Par2RozKGNI2:=STRTOREAL(TuWczytuje);
Par3RozKGNI2:=0.0;

{Inicjalizacja gniazda3}
ASK IO TO ReadLine(TuWczytuje);

ASK IO TO ReadLine(TuWczytuje);

Par1RozKGNI3:=STRTOREAL(TuWczytuje);

ASK IO TO ReadLine(TuWczytuje);
ASK IO TO ReadLine(TuWczytuje);

Par2RozKGNI3:=STRTOREAL(TuWczytuje);

Par3RozKGNI3:=0.0;

ASK IO TO ReadLine(TuWczytuje);
ASK IO TO ReadLine(TuWczytuje);

Kolejka2Pojemnosc:=STRTOINT(TuWczytuje);

ASK IO TO Close;
OUTPUT("1- Wypisywanie komunikatow.");

OUTPUT("Inny znak- bez komunikatow.");
INPUT(Wyp);

ASK Mon TO InitMon();

ASK ArrayGen[1] TO Init(PAr1RozkGen1, PAr2RozkGen1, LIczbKLienGen1,

Par1RozKPacz1, Par2RozKPacz1, Mon,1);
ASK ArrayGen[2] TO Init(PAr1RozkGen2, PAr2RozkGen2, LIczbKLienGen2,

Par1RozKPacz2, Par2RozKPacz2, Mon,2);
ASK ArrayNes[1] TO

Init(Par1RozKGNI1,Par2RozKGNI1,Par3RozKGNI1,2,0,0.5,trigg, Mon,1,Wyp);
ASK ArrayNes[2] TO

Init(Par1RozKGNI2,Par2RozKGNI2,Par3RozKGNI2,3,0,1.0,trigg, Mon,2,Wyp);
ASK ArrayNes[3] TO

Init(Par1RozKGNI3,Par2RozKGNI3,Par3RozKGNI3,4,0,0.5,trigg, Mon,3,Wyp);
ASK Que1 TO Init(ran, 0, trigg, Mon,1,Wyp);

ASK Que2 TO Init(ran, Kolejka2Pojemnosc, trigg, Mon,2,Wyp);
ASK Que3 TO Init(ran, 0, trigg, Mon,3);

TELL ArrayGen[1] TO Generuj();

TELL ArrayGen[2] TO Generuj();
StartSimulation();

ResetSimTime(0.0);

ASK Mon TO SrKliNum(0,ASK GETMONITOR(ASK Mon TO KliNum,ITimedStatObj) TO
Mean());

ASK Mon TO SrKliNumOdch(0,ASK GETMONITOR(ASK Mon TO KliNum,ITimedStatObj)
TO StdDev());

ASK Mon TO SrKliNum(1,ASK GETMONITOR(ASK Mon TO KliNum1,ITimedStatObj) TO
Mean());

ASK Mon TO SrKliNumOdch(1,ASK GETMONITOR(ASK Mon TO
KliNum1,ITimedStatObj) TO StdDev());

ASK Mon TO SrKliNum(2,ASK GETMONITOR(ASK Mon TO KliNum2,ITimedStatObj) TO
Mean());

ASK Mon TO SrKliNumOdch(2,ASK GETMONITOR(ASK Mon TO
KliNum2,ITimedStatObj) TO StdDev());

ASK Mon TO SrKliNum(3,ASK GETMONITOR(ASK Mon TO KliNum3,ITimedStatObj) TO
Mean());

ASK Mon TO SrKliNumOdch(3,ASK GETMONITOR(ASK Mon TO
KliNum3,ITimedStatObj) TO StdDev());

ASK Mon TO SrCzasKlientow(0,ASK GETMONITOR(ASK Mon TO
SredniCzas,RStatObj) TO Mean());

ASK Mon TO SrCzasKlientowOdch(0,ASK GETMONITOR(ASK Mon TO
SredniCzas,RStatObj) TO StdDev());

ASK Mon TO SrCzasKlientow(1,ASK GETMONITOR(ASK Mon TO
SredniCzas1,RStatObj) TO Mean());

ASK Mon TO SrCzasKlientowOdch(1,ASK GETMONITOR(ASK Mon TO
SredniCzas1,RStatObj) TO StdDev());

ASK Mon TO SrCzasKlientow(2,ASK GETMONITOR(ASK Mon TO
SredniCzas2,RStatObj) TO Mean());

ASK Mon TO SrCzasKlientowOdch(2,ASK GETMONITOR(ASK Mon TO
SredniCzas2,RStatObj) TO StdDev());

ASK Mon TO SrCzasKlientow(3,ASK GETMONITOR(ASK Mon TO
SredniCzas3,RStatObj) TO Mean());

ASK Mon TO SrCzasKlientowOdch(3,ASK GETMONITOR(ASK Mon TO
SredniCzas3,RStatObj) TO StdDev());

ASK Mon TO SrZajetKanal(0,ASK GETMONITOR(ASK Mon TO
SrednioKanaly,ITimedStatObj) TO Mean());

ASK Mon TO SrZajetKanalOdch(0,ASK GETMONITOR(ASK Mon TO
SrednioKanaly,ITimedStatObj) TO StdDev());

ASK Mon TO SrZajetKanal(1,ASK GETMONITOR(ASK Mon TO
SrednioKanaly1,ITimedStatObj) TO Mean());

ASK Mon TO SrZajetKanalOdch(1,ASK GETMONITOR(ASK Mon TO
SrednioKanaly1,ITimedStatObj) TO StdDev());

ASK Mon TO SrZajetKanal(2,ASK GETMONITOR(ASK Mon TO
SrednioKanaly2,ITimedStatObj) TO Mean());

ASK Mon TO SrZajetKanalOdch(2,ASK GETMONITOR(ASK Mon TO
SrednioKanaly2,ITimedStatObj) TO StdDev());

ASK Mon TO SrZajetKanal(3,ASK GETMONITOR(ASK Mon TO
SrednioKanaly3,ITimedStatObj) TO Mean());

ASK Mon TO SrZajetKanalOdch(3,ASK GETMONITOR(ASK Mon TO
SrednioKanaly3,ITimedStatObj) TO StdDev());

ASK Mon TO SrLiczKlientWKolejce(0,ASK GETMONITOR(ASK Mon TO
KliinQue,ITimedStatObj) TO Mean());

ASK Mon TO SrLiczKlientWKolejceOdch(0,ASK GETMONITOR(ASK Mon TO
KliinQue,ITimedStatObj) TO StdDev());

ASK Mon TO SrLiczKlientWKolejce(1,ASK GETMONITOR(ASK Mon TO
KliinQue1,ITimedStatObj) TO Mean());

ASK Mon TO SrLiczKlientWKolejceOdch(1,ASK GETMONITOR(ASK Mon TO

KliinQue1,ITimedStatObj) TO StdDev());

ASK Mon TO SrLiczKlientWKolejce(2,ASK GETMONITOR(ASK Mon TO
KliinQue2,ITimedStatObj) TO Mean());

ASK Mon TO SrLiczKlientWKolejceOdch(2,ASK GETMONITOR(ASK Mon TO
KliinQue2,ITimedStatObj) TO StdDev());

ASK Mon TO SrLiczKlientWKolejce(3,ASK GETMONITOR(ASK Mon TO
KliinQue3,ITimedStatObj) TO Mean());

ASK Mon TO SrLiczKlientWKolejceOdch(3,ASK GETMONITOR(ASK Mon TO
KliinQue3,ITimedStatObj) TO StdDev());

ASK Mon TO CouPos(1);
ASK Mon TO PrwdObs(1,ASK Mon TO Prawdopdob1);

ASK Mon TO CouPos(2);
ASK Mon TO PrwdObs(2,ASK Mon TO Prawdopdob2);

ASK Mon TO CouPos(0);
ASK Mon TO CouPos(3);

ASK Mon TO PrwdObs(0,ASK Mon TO Prawdopdob);
ASK Mon TO PrwdObs(3,ASK Mon TO Prawdopdob3);

ASK (GETMONITOR(ASK Mon TO KliNum,ITimedStatObj)) TO Reset();
ASK Mon TO InicjalizujLiczbeKlientow(0);

ASK (GETMONITOR(ASK Mon TO KliNum1,ITimedStatObj)) TO Reset();
ASK Mon TO InicjalizujLiczbeKlientow(1);

ASK (GETMONITOR(ASK Mon TO KliNum2,ITimedStatObj)) TO Reset();
ASK Mon TO InicjalizujLiczbeKlientow(2);

ASK (GETMONITOR(ASK Mon TO KliNum3,ITimedStatObj)) TO Reset();
ASK Mon TO InicjalizujLiczbeKlientow(3);

ASK (GETMONITOR(ASK Mon TO SredniCzas,RStatObj)) TO Reset();
ASK Mon TO InitSrT(0);

ASK (GETMONITOR(ASK Mon TO SredniCzas1,RStatObj)) TO Reset();
ASK Mon TO InitSrT(1);

ASK (GETMONITOR(ASK Mon TO SredniCzas2,RStatObj)) TO Reset();
ASK Mon TO InitSrT(2);

ASK (GETMONITOR(ASK Mon TO SredniCzas3,RStatObj)) TO Reset();
ASK Mon TO InitSrT(3);

ASK (GETMONITOR(ASK Mon TO SrednioKanaly,ITimedStatObj)) TO Reset();
ASK Mon TO InitKanBusy(0);

ASK (GETMONITOR(ASK Mon TO SrednioKanaly1,ITimedStatObj)) TO Reset();
ASK Mon TO InitKanBusy(1);

ASK (GETMONITOR(ASK Mon TO SrednioKanaly2,ITimedStatObj)) TO Reset();
ASK Mon TO InitKanBusy(2);

ASK (GETMONITOR(ASK Mon TO SrednioKanaly3,ITimedStatObj)) TO Reset();
ASK Mon TO InitKanBusy(3);

ASK (GETMONITOR(ASK Mon TO KliinQue,ITimedStatObj)) TO Reset();
ASK Mon TO InitKliInQue(0);

ASK (GETMONITOR(ASK Mon TO KliinQue1,ITimedStatObj)) TO Reset();
ASK Mon TO InitKliInQue(1);

ASK (GETMONITOR(ASK Mon TO KliinQue2,ITimedStatObj)) TO Reset();
ASK Mon TO InitKliInQue(2);

ASK (GETMONITOR(ASK Mon TO KliinQue3,ITimedStatObj)) TO Reset();
ASK Mon TO InitKliInQue(3);

ASK Plik1 TO WriteString("Czas przebywania zgloszenia:");

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Srednio w 1: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO SrCzasPrzeby1,RStatObj)
TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Srednio w 2: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO SrCzasPrzeby2,RStatObj)

TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Srednio w 3: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO SrCzasPrzeby3,RStatObj)
TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Srednio w systemie: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO SrCzasPrzeby,RStatObj)
TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Odch. std. w 1: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrCzasPrzebyOdch1,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Odch. std. w 2: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrCzasPrzebyOdch2,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Odch. std. w 3: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrCzasPrzebyOdch3,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Odch. std. w systemie: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrCzasPrzebyOdch,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Liczba zgloszen:");

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Srednio w 1: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO SrLiczbZglsz1,RStatObj)
TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Srednio w 2: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO SrLiczbZglsz2,RStatObj)
TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Srednio w 3: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO SrLiczbZglsz3,RStatObj)
TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Srednio w systemie: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO SrLiczbZglsz,RStatObj)
TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Odch. std. w 1: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrLiczbZglszOdch1,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Odch. std. w 2: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrLiczbZglszOdch2,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Odch. std. w 3: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrLiczbZglszOdch3,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Odch. std. w systemie: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO

SrLiczbZglszOdch,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Liczba zajetych Kanalow:");

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Sr. w SMO1: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrLiczbZajKan1,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Sr. w SMO2: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrLiczbZajKan2,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Sr. w SMO3: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrLiczbZajKan3,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Sr. w systemie: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO SrLiczbZajKan,RStatObj)
TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Odch. std. w 1: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrLiczbZajKanOdch1,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Odch. std. w 2: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrLiczbZajKanOdch2,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Odch. std. w 3: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrLiczbZajKanOdch3,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Odch. std. w systemie:");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrLiczbZajKanOdch,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Liczba zgloszen w k.");

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Srednio w k. 1: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrLiczbZglwKol1,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Srednio w k. 2: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrLiczbZglwKol2,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Srednio w k. 3: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrLiczbZglwKol3,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Srednio w systemie: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrLiczbZglwKol,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Odch. std. w k. 1: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrLiczbZglwKolOdch1,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;

ASK Plik1 TO WriteString("Odch. std. w k. 2: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrLiczbZglwKolOdch2,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Odch. std. w k. 3: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrLiczbZglwKolOdch3,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Odch. std. w systemie: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrLiczbZglwKolOdch,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("Prawdopodobienstwo obsluzenia zgloszenia:");

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("w SMO1: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrPrawdpObslZgl1,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("w SMO2: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrPrawdpObslZgl2,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("w SMO3: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrPrawdpObslZgl3,RStatObj) TO Mean(),10,5);

ASK Plik1 TO WriteLn;
ASK Plik1 TO WriteString("W systemie: ");

ASK Plik1 TO WriteReal(ASK GETMONITOR(ASK Mon TO
SrPrawdpObslZgl,RStatObj) TO Mean(),10,5);

ASK Plik1 TO Close;
ASK IO TO Open("Wynik.txt", Input);

FOR ii:=0 TO 40 BY 1;
ASK IO TO ReadLine(TuWczytuje);

OUTPUT(TuWczytuje);
END FOR;

OUTPUT("");
OUTPUT("Wynik symulacji zapisano do pliku 'Wynik.txt'.");

INPUT(czekaj);

DISPOSE(Plik1);
DISPOSE(IO);

DISPOSE(Mon);
DISPOSE(ArrayGen[1]);

DISPOSE(ArrayGen[2]);
DISPOSE(Que1);

DISPOSE(Que2);
DISPOSE(Que3);

DISPOSE(ArrayNes[1]);
DISPOSE(ArrayNes[2]);

DISPOSE(ArrayNes[3]);
DISPOSE(ran);

DISPOSE(trigg);

END MODULE.