Имитационное моделирование технологической системы массового обслуживания с отказами

Средняя загрузка ТС (суммарное время наладки и обслуживания отнесенное ко времени моделирования) составила:

= 87,29 %

Найдем интервальные оценки для времени нахождения заявок в очереди при доверительной вероятности γ = 0,95. Интервальная оценка мат. ожидания определяется по формуле:

При γ = 0,95 значение Z-критерия = 1,96. Таким образом,

Интервальная оценка дисперсии определяется по формуле:

, где   ,

Убедимся, что время моделирования обеспечивает практически необходимую точность. Для этого используем формулу,

, где - значение z-критерия при доверительной вероятности γ. При γ = 0,95 = 1,96. Таким образом,

, что обеспечивает практически необходимую точность.

ЗАКЛЮЧЕНИЕ

В ходе выполнения данной работы были закреплены практические навыки имитационного моделирования систем массового обслуживания.

Была написана программа, моделирующая работу технологической системы массового обслуживания с отказами. Шифр данной СМО имеет следующий вид: A/B/1/m. При моделировании данной СМО использовался метод проводки (заявки обрабатываются последовательно), применяющийся для моделирования простых СМО. В данном методе для каждой заявки последовательно находятся время прихода заявки в систему (T1), время начала обслуживания заявки (T2), время окончания обслуживания (T3) и накапливается необходимая статистика. Были вычислены показатели эффективности СМО, а также получены и обработаны статистические данные по времени нахождения заявок  в очереди. 

СПИСОК ЛИТЕРАТУРЫ

1.       Краковский Ю.М. “Имитационное моделирование”, учеб. пособ. – Иркутск: Изд-во ИГЭА, 2002. – 138 с.

2.       Уолтер Савич “С++ во все полноте” – Киев: Издательская группа BHV; СПб.: Питер, 2005. – 784 с.

3.       Пахомов Б. И. “C/C++ и Borland C++ Builder для начинающих”, - СПб.: БХВ-Петербург, 2005 – 640 с.

4.       Емельянов А.А. “Имитационное моделирование экономических процессов”, - М.: Финансы и статистика, 2002. – 366 c.

ПРИЛОЖЕНИЕ 1. ПЕРЕЧЕНЬ УСЛОВНЫХ ОБОЗНАЧЕНИЙ

СВ – случайная величина

СМО – система массового обслуживания

ТС – технологическая система

W – Вейбулла

UN – усеченный на интервале (0; ∞) нормальный закон

UP -  усечённый показательный закон

B - бета-распределение

N – нормальное распределение

ПРИЛОЖЕНИЕ 2. ЛИСТИНГ ПРОГРАММЫ

//---------------------------------------------------------------------------

#include <vcl.h>

#include <cstdlib>

#include <string>

#include <cstring>

#include <cmath>

#include <iostream>

#include <math>

#include "lcgrand.c"

#pragma hdrstop

#include "Unit1.h"

using namespace std;

//---------------------------------------------------------------------------

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

int NT;           // количество заявок

int m;            // размер очереди

double Potk;         // вероятность отказа в обслуживании

double BSa,BSb;      // параметры BS-распределения

//---------------------------------------------------------------------------

__fastcall TForm1::TForm1(TComponent* Owner)

        : TForm(Owner)

{

Memo1->Lines->Clear();

Memo1->Text="";

}

//---------------------------------------------------------------------------

double Weibull (float Alpha, float Betta)

{

  return Betta * pow(-log(lcgrand(1)),1/Alpha);

}

double Normal (double m, double P)

{

  double a, b, c, z;

  do

  {

    a = 2 * lcgrand(1) - 1;

    b = 2 * lcgrand(2) - 1;

    c = pow(a, 2) + pow(b, 2);

  }

  while (c > 1);

  z = sqrt( (-2 * log (c)) / c );

  return a*z;

}

double LogNormal (double Mu, double Sigma2)

{

  return pow(M_E, Normal(Mu, Sigma2));

}

double UNormal (double m, double P)

{

  double x = Normal(m, P);

  while (x < 0)

  {

    x = Normal(m, P);

  }

  return x;

}

double Pokazat (double lambda)

{

  return log(lcgrand(1)) / lambda;

}

double UPokazat(double lambda)

{

  return abs(Pokazat(lambda));

}

double Gamma (double alpha, double betta)

{

  if (alpha > 1)

  {

    ShowMessage("Альфа в гамма функции должна быть в интервале (0,1)");

    return 0;

  }

  while(1)

  {

    double a = pow(lcgrand(1), float(1/alpha));

    double b = pow(lcgrand(2), float(1/(1-alpha)));

    double c = a + b;

    if (c<=1)

    {

      double d = a/c;

      double x = -d*log(lcgrand(3))/betta;

      return x;

    }

  }

}

double Betta(double alpha1, double alpha2)

{

  double Y1 = Gamma (alpha1, 1);

  double Y2 = Gamma (alpha2, 1);

  return Y1/(Y1 + Y2);

}

double BirnbaumSaunders (double alpha, double betta)

{

  double z = Normal(0,1);

  return alpha/betta + 1/2 * pow(z/betta, 2) + z/betta * sqrt( alpha/betta + 1/4*pow(z, 2)/betta );

}

double U_raspred (double u)

{

  //double r = lcgrand(1);

  //return u / (-log( r * pow(M_E, -u/b) + (1-r)*pow(M_E, -u/a) ));

}

void __fastcall TForm1::Button1Click(TObject *Sender)

{

int i,j,PM,oh;

float r,s;        // сгенерированное число в интервале (0;1)

float Z;           // Z -> N(0,1)

double BSa,BSb,Ua,Ub,Uu;     // параметры распределений

double x,x2;    // моделируемая СВ

double T1;   // время прихода заявки в систему

double T2;   // время начала обслуживания заявки

double T3;   // время окончания обслуживания заявки

double T4;   // время окончания восстановления ТС

double Tp;   // время освобождения канала

double TS, Tobs, Toh;

double T0[5]={0,0,0,0,0};  // время начала обслуживания заявки из накопителя

double mm,p,d,q,sq;  // для нормального закона

double nOtkaz, nOtkaz2; // число отказанных в обслуживании заявок

int MI; // количество заявок в очереди

// ввод исходных данных

NT = StrToFloat(Edit1->Text);

m = StrToFloat(Edit2->Text); // размер очереди (5 для данного варианта)

// Определение начальных значений

T1=0; T2=0; T3=0; Tp=0; MI=0; nOtkaz=0; PM=0; s=0; TS=0; Tobs=0; Toh=0; oh=0;

Memo1->Lines->Clear();

Memo1->Text="";

// Моделирование СМО A/B/1/m

for (j=1; j<=NT; j++)

{

//РАСПРЕДЕЛЕНИЕ

//-----------------------------------------------------------------111111111111111111111111

//

   x = Weibull(StrToFloat(EditAlpha->Text), StrToFloat(EditBetta->Text));

   TS=TS+x; // накапливаем время между заявками

//------------------------------------------------------------------

   T1=T1+x; // время прихода заявки в систему

      if (T1>Tp)  // ЕСЛИ КАНАЛ СВОБОДЕН

         {

         T2=T1; // время начала обслуживания заявки

         }

      else       // ЕСЛИ КАНАЛ ЗАНЯТ

         {

            if (MI!=m)  // Если в накопителе есть место

               {

          A:  MI=MI+1; // добаляем заявку в очередь

               T0[MI-1]=Tp;   // определяем время начала обслуживания

               }

            else

               {

               PM=0;

                  for (i=1;  i<=m; i++)

                  if (T0[i-1]<T1) PM=PM+1; // нужно ли удалять записи из T0

               if (PM==0)   // Если в накопителе нет места

                   {

                   nOtkaz = nOtkaz+1; // считаем число отказов

                   continue; // конец обработки заявки - возврат к начлу цикла

                   }

               else           // если в накопителе есть место

                   {

                    for (i=1;  i<=m-PM; i++) T0[i-1]=T0[i+PM-1]; // удаление ненужных записей

                    MI=MI-PM;

                    goto A;

                    }

               }

               T2=Tp; // время начала обслуживания заявки

         }

         Toh=Toh+(T2-T1);

         oh=oh+1;

         Memo1->Lines->Add(T2-T1);

         // НАЛАДКА ТС

         /////////////////////////////////////////////////////////////////////////////22222222222222222222222222222

         x = UNormal(StrToFloat(EditM -> Text), StrToFloat(EditP -> Text));

         x2 = UPokazat(StrToFloat(EditLambda->Text)) ; //////////////////////////////////////////////////////////////////// 33333333333333333333

         x = x+x2;     //(наладка + обслуживание)

         Tobs=Tobs+x;  // накапливаем время обслуживания

         T3=T2+x; // время окончания обслуживания

         x=0;

         //МОДЕЛИРОВАНИЕ ОТКАЗА ТС

          x = Betta( StrToFloat(EditAlpha2->Text), StrToFloat(EditBetta2->Text) ); ///////////////////////////////444444444444444

          T4=T3+x; // время окончания восстановления ТС

          Tp=T4;

s=0;

} // конец цикла обработки заявки

Edit15->Text=FloatToStr(T1/NT);    // среднее время м/у заявками

Edit17->Text=FloatToStr(Tobs/NT);  // среднее время обслуживания заявки

Edit18->Text=FloatToStr(nOtkaz/NT*100);  // вероятность отказа в обслуживании

Edit9->Text=FloatToStr(Toh/oh);  // среднее время нахождения заявки в очереди

Edit10->Text=FloatToStr(Tobs/Tp*100);  // средняя загрузак ТС

}

//---------------------------------------------------------------------------