Documentatie proiect

Echipa​ formata din Vasu Andra, Pascal Andreea-Diana, Popescu

Aurelian si Gheorghe Alexandru, grupa 333

Descrierea problemei:

Echipa noastra s-a gandit sa abordeze problema simularii unui

restaurant de tip fast-food (Shaormeria Dristor), care sa functioneze
astfel:
1. Clientul intra in restaurant si trebuie sa mearga la casier (serverul 1):
(a) Daca nu este nimeni, acesta poate plasa comanda si plateste costul
produselor;
(b) Daca exista deja alte persoane care comanda, acesta va astepta in
coada de asteptare pana cand ii vine randul sa comande.
2. Casierul inregistreaza comanda, calculeaza totalul produselor,
incaseaza contravaloarea produselor in functie de metoda de plata
solicitata de catre client:
(a) Daca metoda de plata aleasa este cash atunci casierul incaseaza
contravalorea si ofera rest, daca este nevoie;
(b) Daca plata se face cu cardul, casierul va activa un POS si va ruga
clientul sa faca plata:
i. Daca clientul are un card cu tehnologia contactless il va apropia de
POS, iar plata se va realiza in mod automat daca suma ceruta este in
intervalul pe care acesta l-a selectat a fi sigur (spre exemplu maxim 100 de
lei), altfel acesta va introduce pinul pentru a aproba plata;
ii. Daca clientul nu are un card cu tehnologia contactless atunci il va
introduce in POS si isi va introduce pinul pentru a aproba plata.
3. Clientul se indreapta apoi spre bucatar (serverul 2), unde trebuie sa
isi ridice comanda:
(a) Daca nu se afla nimeni in coada de asteptare, acesta isi poate ridica
comanda cand este gata;
(b) Daca se afla alti client, in coada de asteptare, acesta trebuie sa
astepte pana cand ii vine
randul.
4. Dupa ce s, i-a ridicat comanda, acesta va parasi restaurantul.
Ipoteze de lucru suplimentare pentru problema abordata:
• Durata de preparare pentru cele 2 servere difera: la primul
trebuie doar plasata si platita comanda ceea ce dureaza foarte putin
considerand ca avem un casier experimentat, in timp ce al doilea server
trebuie sa prepare toate produsule, proces ce poate dura cateva minute
bune;
• Programul de functionare al restaurantului este de 8 ore, de la ora
10:00 pana la ora 18:00. Dupa ora 18:00 nu se mai primesc clienti noi, dar
cei care se afla deja in cozile de asteptare vor fi serviti;
• Numarul de clienti care se pot afla la un moment dat in cele doua cozi
de asteptare este de maximum 30 de persoane pentru ambele.
Exemplificare:
1. Daca in coada server-ului 1 se afla deja 30 de persoane, alti
clienti nu mai pot intra in magazin, pana cand unul comanda si se muta
in serverul 2;
2. Daca in coada server-ului 2 se afla deja 30 de persoane, acesta nu
va mai primi alte persoane pana cand unul dintre cei 30 de clienti este
servit si pleaca din magazin.

Obiective:

1. Durata medie de așteptare pentru fiecare dintre cele două cozi.

2. Durata maximă de așteptare pentru fiecare dintre cele două cozi.
3. Durata minimă de așteptare pentru fiecare dintre cele două cozi.
4. Durata medie de așteptare totală.
5. Numărul mediu de clienți serviți în decurs de o zi.
Datele problemei:
λ(t) = − 5 × t2 + 20 × t + 1, t ∈ [0, 4] sau
8, t > 4
G1(x) = 1 − e −x
G2(x) = 1 − e −2 × x

Ipoteze suplimentare:

- Restaurantul are un program de 8 ore, de la 10 la 18, dupa aceasta

ora neprimind clienti noi.
- Pot fi maxim 30 de persoane la un moment dat in ambele cozi de
asteptare.

Rezolvarea eventualelor probleme teoretice:

- Avand in vedere definitia functiei λ si restrictia λ(t) ≤ λ, rezulta ca
λ ≥ 8.

Comentarea codului:

lambda <- ​function​(t)

{
​if​ (t > ​4​) {
​return​(​8​)
}
​else​ ​if​ (t >= ​0​ && t <= ​4​) {
​return​(-​5​*t^​2​ + ​20​*t + ​1​)
}
}

Sosirea clientilor se face cu un proces Poisson neomogen cu functia

de intensitate λ(t) implementata mai sus.
G <- ​function​(a)
{
​return​ (-log(runif(​1​))/a/​60​)
}

G1 și G2 sunt variabile cu distribuție exponențială. Pentru G1 avem

parametrul lambda = 1 și pentru G2 lambda = 2.

https://en.wikipedia.org/wiki/Exponential_distribution

generateTs <- ​function​ (s, lam)

{
t <- s
​while​(​TRUE​){
t <- t - log(runif(​1​))/lam
​if​(runif(​1​) <= lambda(t) / lam)
​return​(t)
}
}

Am urmarit algoritmul de generare Ts, care este momentul primei

sosiri dupa momentul s.

seriessv <- ​function​(​T​, lam, l1, l2)

{
t <- ​0​;
na <- ​0​;
nd <- ​0​;
n1 <- ​0​;
n2 <- ​0​;
j <- ​0
ta <- generateTs(​0​, lam);
t1 <- ​Inf​;
t2 <- ​Inf

lgmax <- ​10000​; pmax <- ​30

A1 <- double(lgmax);
A2 <- double(lgmax);
D <- double(lgmax);
Ev <- matrix(nrow=lgmax, ncol=​3​)

​while​(ta <= ​T​)

{
​if​(ta <= min(t1, t2) && n1 < pmax) {
t <- ta;
n1 <- n1 + ​1​;
na <- na + ​1​;
ta <- generateTs(t, lam); A1[na] <- t
​if​(n1 == ​1​)
t1 <- t + G(l1)
}

​else​ i ​ f​(t1 <= t2 && n2 < pmax) {

​if​ (ta <= t1 && n1 == pmax)
ta <- t1
t <- t1;
n1 <- n1 - ​1​;
n2 <- n2 + ​1​;
A2[na - n1] <- t
​if​ (n1 > ​0​)
t1 <- t + G(l1)
​else
t1 <- ​Inf
​if​ (n2 == ​1​)
t2 <- t + G(l2)
 }
​else​ {
​if​ (t1 <= t2 && n2 == pmax)
t1 <- t2
t <- t2;
n2 <- n2 - ​1​;
nd <- nd + ​1​;
D[nd] <- t
​if​ (n2 > ​0​)
t2 <- t + G(l2)
t2 <- ​Inf
}
j <- j + ​1
Ev[[j, ​1​]] <- n1
Ev[[j, ​2​]] <- n2
Ev[[j, ​3​]] <- t
}

​while​ (n1 > ​0​) {

​if​ (t1 <= t2 && n2 < pmax) {
t <- t1;
n1 <- n1 - ​1​;
n2 <- n2 + ​1​;
​if​ (n1 > ​0​)
t1 <- t + G(l1)
​else
t1 <- ​Inf
​if​ (n2 == ​1​)
t2 <- t + G(l2)
A2[na - n1] <- t
}
​else​ {
​if​ (t1 <= t2 && n2 == pmax)
t1 <- t2
t <- t2;
n2 <- n2 - ​1​;
nd <- nd + ​1​;
D[nd] <- t
 ​if​ (n2 > ​0​)
t2 <- t + G(l2)
​else
t2 <- ​Inf
}
j <- j + ​1
Ev[[j, ​1​]] <- n1
Ev[[j, ​2​]] <- n2
Ev[[j, ​3​]] <- t
}

​while​ (n2 > ​0​) {

t <- t2;
n2 <- n2 - ​1​;
nd <- nd + ​1​;
D[nd] <- t

​if​ (n2 > ​0​)

t2 <- t + G(l2)
​else
t2 <- ​Inf
j <- j + ​1
Ev[[j, ​1​]] <- n1
Ev[[j, ​2​]] <- n2
Ev[[j, ​3​]] <- t
}
Tp = max(t - ​T​, ​0​);
​return​(list(​"A1"​ = A1[A1!=​0​], ​"A2"​ = A2[A2!=​0​], ​"D"​ = D[D!=​0​], ​"Tp"
= Tp, ​"Ev"​ = Ev[rowSums(is.na(Ev)) != ncol(Ev),]))
}

Am urmarit schema de simulare pentru sistemele de tip coada cu

doua servere legate in serie. Am initilizat variabilele de plecare si am
generat in variabila t a momentul sosirii urmatorului client, impunand o
limitare de maxim 30 de persoane.
Se disting trei cazuri in functie de valoarea variabilei t a :
● t a ≤ min(t 1 , t 2 ) : soseste un client nou si verificam daca serverul 1
este liber (altfel trebuie pus in coada de asteptare);
● t 1 < t a , t 1 ≤ t 2 : serverul 1 se elibereaza inainte de sosirea unui
client nou;
● t 2 < t a , t 2 < t 1 : serverul 2 se elibereaza inainte de a sosi un client
nou si inainte de finalizarea activitatii la serverul 2

while​ (n1 > ​0​) {

​if​ (t1 <= t2 && n2 < pmax) {
t <- t1;
n1 <- n1 - ​1​;
n2 <- n2 + ​1​;
​if​ (n1 > ​0​)
t1 <- t + G(l1)
​else
t1 <- ​Inf
​if​ (n2 == ​1​)
t2 <- t + G(l2)
A2[na - n1] <- t
}
​else​ {
​if​ (t1 <= t2 && n2 == pmax)
t1 <- t2
t <- t2;
n2 <- n2 - ​1​;
nd <- nd + ​1​;
D[nd] <- t
​if​ (n2 > ​0​)
t2 <- t + G(l2)
​else
t2 <- ​Inf
}
j <- j + ​1
Ev[[j, ​1​]] <- n1
Ev[[j, ​2​]] <- n2
Ev[[j, ​3​]] <- t
 }

while (n2 > 0) {

t <- t2;
n2 <- n2 - 1;
nd <- nd + 1;
D[nd] <- t;

if (n2 > 0)
t2 <- t + G(l2)
t2 <- Inf
j <- j + 1
Ev[[j, 1]] <- n1
Ev[[j, 2]] <- n2
Ev[[j, 3]] <- t
}

Tp = max(t - T, 0);
return(list("A1" = A1[A1!=0], "A2" = A2[A2!=0], "D" = D[D!=0], "Tp"
= Tp, "Ev" = Ev[rowSums(is.na(Ev)) != ncol(Ev),]))
}

Dupa inchiderea restaurantului, clientii care s-au asezat deja la

oricare dintre cele doua cozi vor continua sa fie serviti. In variabila T p am
retinut timpul petrecut de angajati dupa terminarea programului pana s-au
servit toti clientii.

ore = ​8​; maxLambda = ​21​; l1 = ​2​; l2 = ​1​; nrSimulari = ​10000

C1 <- double(nrSimulari); C2 <- double(nrSimulari); ​T​ <-
double(nrSimulari); NrC <- integer(nrSimulari)
for​ (i ​in​ ​1​:nrSimulari)
{
ans <- seriessv(ore, maxLambda, l1, l2)
A1 <- unlist(ans[​"A1"​], use.names=​FALSE​)
A2 <- unlist(ans[​"A2"​], use.names=​FALSE​)
D <- unlist(ans[​"D"​], use.names=​FALSE​)
 C1[i] <- mean(A2-A1)
C2[i] <- mean(D-A2)
​T​[i] <- mean(D-A1)
NrC[i] <- length(A1)
}

In variabila ore retinem numarul total de ore de functionare a

restaurantului intr-o zi. Pentru variabila maxLambda am ales valoarea 21
deoarece respescta restrictia teoretica ca λ ≥ 8. Variabilele l1 = 2 si l2 = 1
sunt folosite pentru a diferentia G1 si G2 ( cu distributia exponentiala ) .

cat(​"Durata medie de asteptare pentru coada 1: "​, mean(C1)*​3600​, ​"

secunde"​)
cat(​"Durata medie de asteptare pentru coada 2: "​, mean(C2)*​3600​, ​"
secunde"​)
cat(​"Durata maxima de asteptare pentru coada 1: "​, max(C1)*​3600​, ​"
secunde"​)
cat(​"Durata maxima de asteptare pentru coada 2: "​, max(C2)*​3600​, ​"
secunde"​)
cat(​"Durata minima de asteptare pentru coada 1: "​, min(C1)*​3600​, ​"
secunde"​)
cat(​"Durata minima de asteptare pentru coada 2: "​, min(C2)*​3600​, ​"
secunde"​)
cat(​"Durata medie de asteptare totala: "​, mean(​T​)*​3600​, ​" secunde"​)
cat(​"Numar mediu de clienti serviti in decurs de o zi: "​, mean(NrC))

Am afisat obiectivele propuse, si anume durata medie de asteptare

pentru ambele cozi, durata maxima de asteptare pentru ambele cozi,
durata minima de asteptar pentru ambele cozi, durata medie de asteptare
totala, numarul mediu de clienti serviti pe parcursul unei zile.
Rezultatele obtinute in urma simularii

Durata medie de asteptare pentru coada 1: 33.83266 secunde

Durata medie de asteptare pentru coada 2: 78.68133 secunde
Durata maxima de asteptare pentru coada 1: 61.11153 secunde
Durata maxima de asteptare pentru coada 2: 209.9233 secunde
Durata minima de asteptare pentru coada 1: 20.46939 secunde
Durata minima de asteptare pentru coada 2: 43.00193 secunde
Durata medie de asteptare totala: 112.514 secunde
Numar mediu de clienti serviti in decurs de o zi: 89.4744

Concluzie

Prin aceasta simulare am vrut sa vedem cum am putea sa imbunatatim

calitatea serviciilor puse la dispozitie de catre shaormeria Dristor. Modelul
de simulare si-a dovedit capacitatea de a investiga diferite situatii fara a
impune costuri suplimentare. Aceasta simulare poate oferi o intelegere mai
buna a perfomantelor preconizate pentru un sistem real si pentru a testa
orice schimbare cu eficacitatea acesteia asupra proiectarii sistemului.