Приложение1. Текст имитационной программы

SMOModel_Program.cs

using System;

 

namespaceModel_Lab

{

classProgram

{

staticvoid Main(string[] args)

   {

//Создаеммодель

varsmoModel = newSmoModel(null, "МодельСМО");

 

try

       {

//Запускаеммодель

smoModel.PERFORM();

}

catch (Exception e)

       {

//выводим сообщение об ошибке, если есть

smoModel.Tracer.TraceOut(e.Message);

       }

 

//сохраняемтрассировкувфайл

smoModel.Tracer.OutStream.Flush();

}

}

}

 

SMOModel_Class.cs

using System;

usingSystem.Collections.Generic;

usingSystem.Linq;

usingSystem.Text;

 

usingCommonModel.StatisticsCollecting;

usingCommonModel.RandomStreamProducing;

usingCommonModel.Collections;

usingCommonModel.Kernel;

usingCommonModel.Serialization;

usingSystem.Runtime.Serialization;

 

 

namespaceModel_Lab {

 

 

[DataContract]

publicpartialclassSmoModel:Model

{

 

#region Параметры модели

 

constintstreamAmount = 2; // количество каналов обслуживания

constintqueueAmount = 3; // количествоочередей

   [DataMember]

double[] Lamd = newdouble[streamAmount]; // интенсивность входных потоков каждого из устройств обслуживания

   [DataMember]

double[] Mu = newdouble[streamAmount]; // параментр экспоненциального времени обслуживания каждого из устройств

   [DataMember]

int A, B; // границы равномерного распределения

int[] M = newint[queueAmount];   // ограничение на длину каждой из очередей входных потоков устройств обслуживания

   [DataMember]

publicconstdouble P = 0.25;  // вероятность отправки заявки 2 потока на повторное обслуживание

[DataMember]

doubleTP; // времяпрогонаИМ

 

#endregion

 

#region Переменные состояния модели

 

bool[] KZ = newbool[streamAmount];     // занятость устройств обслуживания

int NZS;

 

// переменные состояния, необходимые для сбора статистики

 

TIntVar [] KVZ; // количество вошедших заявок по каждой из очередей (3)

TIntVar [] KPZ; // количество потерянных заявок по каждой из очередей (3)

TRealVar[] TSZK; // время суммарной занятости канала (2)

TRealVar[] Tobs; // время обслуживания по потокам (2)

TIntVarKZS; // количество заявок в системе (1 - глобальный)

 

#endregion

 

#region Дополнительные структуры

 

//Класс заявки

publicclassZayavka

   {

publicdoubleTvh; // время вхождения заявки в систему

publicintNZ; // номерзаявки

publicintNP; // номерпотока

   }

 

//Элементочереди

classQRec:QueueRecord

   {

publicZayavka Z;

   }

 

// Самаочередь

 

SimpleModelList<QRec>[] Queue;

 

 

#endregion

 

#region Cборщикистатистики

 

Variance<int>[] Variance_KVZ = newVariance<int>[queueAmount];

Variance<int>[] Variance_KPZ = newVariance<int>[queueAmount];

Variance<double>[] Variance_Tobs = newVariance<double>[streamAmount];

Variance<int>Variance_KZS;

 

#endregion

 

#regionГенераторыПСЧ

 

UniformStreamUniform_generator; // событиеповторногообслуживания

ExpStreamFirstStream_ReqTime_ExpGenerator; // Времямеждусоседнимизаявкамивпервомпотоке

ExpStreamSecondStream_ReqTime_ExpGenerator; // Времямеждусоседнимизаявкамивовторомпотоке

ExpStreamFirstStream_ServTime_ExpGenerator; // Времяобслуживаниязаявкипервогопотока

ExpStreamSecondStream_ServTime_ExpGenerator; // Времяобслуживаниязаявкивторогопотока

 

#endregion

 

#regionИнициализацияобъектовмодели

 

publicSmoModel(Model parent, string name): base(parent, name)

   {

       Queue = newSimpleModelList<QRec>[queueAmount]; //триочереди

 

KVZ =newTIntVar[queueAmount]; // количествовошедшихзаявок

KPZ =newTIntVar[queueAmount]; // количество потерянных заявок по каждой из очередей

       TSZK = newTRealVar[streamAmount]; // время суммарной занятости канала

Tobs = newTRealVar[streamAmount]; // времяобслуживания

KZS =InitModelObject<TIntVar>("количество заявок в системе");// количество заявок в системе

 

for (inti = 0; i<streamAmount; i++)

{

           TSZK[i] = InitModelObject<TRealVar> ("суммарное время обслуживания каждым каналом");

// KZS[i] = InitModelObject<TIntVar>("количество заявок в системе");

Tobs[i] = InitModelObject<TRealVar> ("время обслуживания для каждого канала");

 

// Variance_TSZK[i] = InitModelObject<Variance<double>>("сборщикмоидисперсиипо TSZK " + (i + 1).ToString() + " потока");

Variance_Tobs[i] = InitModelObject<Variance<double>>("сборщикмоидисперсиипоTobs " + (i + 1).ToString() + " потока");

       }

 

for (inti = 0; i<queueAmount; i++)

{

           KVZ[i] = InitModelObject<TIntVar>("количество вошедших заявок по каждой из очередей");

           KPZ[i] = InitModelObject<TIntVar>("количество потерянных заявок по каждой из очередей");

 

Variance_KVZ[i] = InitModelObject<Variance<int>>("сборщикмоидисперсиипо KVZ" + (i + 1).ToString() + " очереди");

Variance_KPZ[i] = InitModelObject<Variance<int>>("сборщикмоидисперсиипо KPZ" + (i + 1).ToString() + " очереди");

       }

 

for (inti = 0; i<queueAmount; i++)

           Queue[i] = InitModelObject<SimpleModelList<QRec>>("очередь " + (i + 1).ToString() + " потока");;

 

Variance_KZS = InitModelObject<Variance<int>>("сборщикмоидисперсиипо KZS");

 

 

// Вместо него простая вероятность из c#?

Uniform_generator = InitModelObject<UniformStream>("генератор потока 'Отправка заявки из 2-го КО на повторное обслуживание' ");

 

FirstStream_ReqTime_ExpGenerator = InitModelObject<ExpStream> ("генератор потока 'Время между соседними заявками в первом потоке'");

SecondStream_ReqTime_ExpGenerator = InitModelObject<ExpStream> ("генератор потока 'Время между соседними заявками во втором потоке'");

FirstStream_ServTime_ExpGenerator = InitModelObject<ExpStream> ("генератор потока 'Время обслуживания заявки первого потока'");

SecondStream_ServTime_ExpGenerator = InitModelObject<ExpStream>("генератор потока 'Время обслуживания заявки второго потока'");

 

for (inti = 0; i<streamAmount; i++)

       {

Variance_Tobs[i].ConnectOnSet(Tobs[i]);

       }

 

for (inti = 0; i<queueAmount; i++)

       {

Variance_KVZ[i].ConnectOnSet(KVZ[i]);

Variance_KPZ[i].ConnectOnSet(KPZ[i]);

       }

 

Variance_KZS.ConnectOnSet(KZS);

   }

 

#endregion

}

}

SMOModel_Event.cs

using CommonModel.Kernel;

 

namespace Model_Lab

{

 

public partial class SmoModel: Model

{

// Класс для события - входа заявки в систему обслуживания

public class Event1_Enter:TimeModelEvent<SmoModel>

   {

       #region Атрибутысобытия

           public Zayavka Z;

       #endregion

 

 

       // Алгоритмобработкисобытия

       protected override void HandleEvent(ModelEventArgsargs)

{

Model.KVZ[0].Value++; //увеличиваем количество вошедших заявок на 1

Model.KZS.Value++; //увеличиваем количество заявок находящихся в системе

 

Z.Tvh = Model.Time; //регистрируем время входа заявки в систему

Z.NP = 0;

 

 

Model.Tracer.EventTrace(this, Z.NZ); //вывод трассировки для свершившегося события

 

           //если канал свободен

if(!Model.KZ[0])

           {

Model.KZ[0] = true; // занять канал

 

               //запланировать событие Event2_Finish

var ev2 = new Event2_Finish(); //создаёмобъектсобытия

ev2.Z = this.Z;            // передаём в событие заявку

 

               // генерируем время обработкии события

doubledt = Model.FirstStream_ServTime_ExpGenerator.GenerateValue();

 

               //планируем событие

Model.PlanEvent(ev2, dt);

 

               //Выводим трассировку о запланированном событии

Model.Tracer.PlanEventTrace(ev2, Z.NZ);

}

 

           //если канал занят

else

           {

               //если есть места в очереди

if (Model.Queue[0].Count.Value<Model.M[0])

               {

 

varQueueRecord = new QRec();  //создаёмобъектэлементаочереди

QueueRecord.Z = this.Z;        //передаём в созданный объект объект заявки

Model.Queue[0].Add(QueueRecord); //добавляем элемент в очередь

 

               }

 

               //если нет мест в очереди

else

               {

Model.KPZ[0].Value++; //увеличиваем количество потерянных заявок

Model.KZS.Value--; //уменьшаем количество заявок в системе

               }

 

           }

 

           //Запланировать вход новой заявки в систему

Zayavkanew_Z = newZayavka();//создаём объект заявки

Model.NZS++;

           new_Z.NZ = Model.NZS;

 

var ev1 = new Event1_Enter(); //создаёмобъектсобытия

ev1.Z = new_Z; // передаём в событие заявку

 

//генерируемвремявходазаявки

           double dt1 = Model.FirstStream_ReqTime_ExpGenerator.GenerateValue();

 

//Планируем событие

Model.PlanEvent(ev1, dt1);

 

           //Выводим сообщение в трассировку о запланированном событии

Model.Tracer.PlanEventTrace(ev1, new_Z.NZ);

 

           Model.TraceModel(); // выводим строку состояния

       }

}

 

   // Классдлясобытия - окончанияобслуживания

   public class Event2_Finish:TimeModelEvent<SmoModel>

   {

       #region Атрибутысобытия

           public Zayavka Z;

       #endregion

 

       // Алгоритмобработкисобытия

       protected override void HandleEvent(ModelEventArgsargs)

{

Model.KVZ[1].Value++; //увеличиваем количество вошедших заявок на 1

Model.Tracer.EventTrace(this, Z.NZ); //вывод трассировки для свершившегося события

           //если канал свободен

if(!Model.KZ[1])

           {

Model.KZ[1] = true; // занять канал

               //запланировать событие Event2_Finish

var ev3 = new Event3_Finish2(Z); //создаёмобъектсобытия

//ev3.Z = this.Z;            // передаём в событие заявку

// генерируемвремяобработкиисобытия

               double dt = Model.SecondStream_ServTime_ExpGenerator.GenerateValue();

//планируем событие

Model.PlanEvent(ev3, dt);

               //Выводим трассировку о запланированном событии

Model.Tracer.PlanEventTrace(ev3, Z.NZ);

}

           //если канал занят

else

           {

               //если есть места в очереди

if (Model.Queue[1].Count.Value<Model.M[1])

               {

varQueueRecord = new QRec();  //создаёмобъектэлементаочереди

QueueRecord.Z = this.Z;        //передаём в созданный объект объект заявки

Model.Queue[1].Add(QueueRecord); //добавляем элемент в очередь

               }

               //если нет мест в очереди

else

               {

Model.KPZ[1].Value++; //увеличиваем количество потерянных заявок

Model.KZS.Value--; //уменьшаем количество заявок в системе

               }

           }

           // если есть заявки в первой очереди

if (Model.Queue[0].Count.Value> 0)

{

               //Запланировать вход заявки из очереди 1 (0) в систему

var ev2 = new Event2_Finish();                 //создаёмобъектсобытия

ev2.Z = Model.Queue[0].Pop().Z;                // передаём в событие заявку из очереди

               //генерируем время обслуживания заявки в первом потоке

double dt1 = Model.FirstStream_ServTime_ExpGenerator.GenerateValue();

 

// статистика по времени

Model.TSZK[0].Value += dt1;

Model.Tobs[0].Value = Model.Time - this.Z.Tvh + dt1;

 

//Планируем событие

Model.PlanEvent(ev2, dt1);

 

               //Выводим сообщение в трассировку о запланированном событии

Model.Tracer.PlanEventTrace(ev2, ev2.Z.NZ);

}

else

           {

               // освободитьКО 1

Model.KZ[0] = false;

           }

Model.TraceModel(); // выводим строку состояния

 

       }

}

 

publicclassEvent3_Finish2:TimeModelEvent<SmoModel>

   {

#regionАтрибутысобытия

publicZayavka Z;

#endregion

 

public Event3_Finish2(Zayavka z)

       {

this.Z = z;

       }

 

protectedoverridevoidHandleEvent(ModelEventArgsargs)

{

//если заявка второго потока

#region

if (Z.NP == 1)

{

//Моделированиесобытия "Повторноеобслуживание"

#region

doublenew_event = Model.Uniform_generator.GenerateValue();

if (new_event< 0.25)

               {

if (Model.Queue[2].Count!= 0)//если есть ещё заявки в очереди 3

{

//Model.Tracer.TraceOut("chanel is not free");

//выбираемзаявкуизочереди

varev = newEvent3_Finish2(this.Z);

ev.Z = Model.Queue[2].Pop().Z;

//генерируем время обслуживания заявки вo втором потоке

doubledt = Model.FirstStream_ServTime_ExpGenerator.GenerateValue();

 

Model.Tobs[1].Value = Model.Time - this.Z.Tvh+dt;

// статистика по времени занятости канала

Model.TSZK[1].Value += dt;

//Планируем событие

Model.PlanEvent(ev, dt);

//Выводим сообщение в трассировку о запланированном событии

Model.Tracer.PlanEventTrace(ev, ev.Z.NZ);

//заносим в очередь

var Q = newQRec();

Q.Z = this.Z;

Model.Queue[2].Add(Q);

Model.TraceModel(); // выводим строку состояния

                   }

else

                   {//иначе сразу идёт на обслуживание

//Model.Tracer.TraceOut("chanel is free");

Event3_Finish2ev = newEvent3_Finish2(this.Z);

doubledt = Model.SecondStream_ServTime_ExpGenerator.GenerateValue();

//Cбор статистики по времени занятости

Model.TSZK[1].Value += dt;

//

Model.Tobs[1].Value = Model.Time - this.Z.Tvh + dt;

//Планируем событие

Model.PlanEvent(ev, dt);

//выводим сообщение в трассировку

Model.Tracer.PlanEventTrace(ev, ev.Z.NZ);

Model.TraceModel(); // выводим строку состояния

                   }

               }//конец повторного обслуживания

#endregion

else

               {

Model.KZS.Value--;

//

if (Model.Queue[2].Count!= 0)//если есть ещё заявки в очереди 3

                   {

//выбираем заявку из очереди

varev = newEvent3_Finish2(this.Z);

ev.Z = Model.Queue[2].Pop().Z;

//генерируем время обслуживания заявки вo втором потоке

doubledt = Model.SecondStream_ServTime_ExpGenerator.GenerateValue();

// статистика по времени занятости канала

Model.TSZK[1].Value += dt;

Model.Tobs[1].Value = Model.Time - this.Z.Tvh + dt;

//Планируем событие

Model.PlanEvent(ev, dt);

//Выводим сообщение в трассировку о запланированном событии

Model.Tracer.PlanEventTrace(ev, ev.Z.NZ);

Model.TraceModel(); // выводим строку состояния

                   }

else

//Иначе если есть заявки в очереди 2

if (Model.Queue[1].Count!= 0)

                       {

//выбираем заявку из очереди

varev = newEvent3_Finish2(this.Z);//ладно, нам всё-таки нужен был пустой конструктор XD

ev.Z = Model.Queue[1].Pop().Z;

//генерируем время обслуживания заявки вo втором потоке

doubledt = Model.SecondStream_ServTime_ExpGenerator.GenerateValue();

// статистика по времени занятости канала

Model.TSZK[1].Value += dt;

 

Model.Tobs[1].Value = Model.Time - this.Z.Tvh + dt;

//Планируем событие

Model.PlanEvent(ev, dt);

//Выводим сообщение в трассировку о запланированном событии

Model.Tracer.PlanEventTrace(ev, ev.Z.NZ);

Model.TraceModel(); // выводим строку состояния

                       }

else//иначе освободим канал

Model.KZ[1] = false;

               }

           }

#endregion

//конец "если заявка второго потока"

else

           {

Model.KZS.Value--;

if (Model.Queue[2].Count!= 0)//если есть ещё заявки в очереди 3

               {

//выбираем заявку из очереди

varev = newEvent3_Finish2(this.Z);

ev.Z = Model.Queue[2].Pop().Z;

//генерируем время обслуживания заявки вo втором потоке

doubledt = Model.FirstStream_ServTime_ExpGenerator.GenerateValue();

// статистика по времени занятости канала

Model.TSZK[1].Value += dt;

//Планируем событие

Model.PlanEvent(ev, dt);

//Выводим сообщение в трассировку о запланированном событии

Model.Tracer.PlanEventTrace(ev, ev.Z.NZ);

Model.TraceModel(); // выводим строку состояния

               }

else

//Иначе если есть заявки в очереди 2

if (Model.Queue[1].Count!= 0)

                   {

//выбираем заявку из очереди

varev = newEvent3_Finish2(this.Z);//ладно, нам всё-таки нужен был пустой конструктор XD

ev.Z = Model.Queue[1].Pop().Z;

//генерируем время обслуживания заявки вo втором потоке

doubledt = Model.FirstStream_ServTime_ExpGenerator.GenerateValue();

// статистика по времени занятости канала

Model.TSZK[1].Value += dt;

//Планируем событие

Model.PlanEvent(ev, dt);

//Выводим сообщение в трассировку о запланированном событии

Model.Tracer.PlanEventTrace(ev, ev.Z.NZ);

Model.TraceModel(); // выводим строку состояния

                   }

else//иначе освободим канал

Model.KZ[1] = false;

}

       }

   }

 

 

   public class Event4_EnterTo2:TimeModelEvent<SmoModel>

{

       // Класс для события - входа заявки во второй канал из третьей очереди

 

       #region Атрибуты события

publicZayavkaZ;

#endregion

 

       public Event4_EnterTo2(Zayavka z)

{

this.Z = z;

           }

 

       // Алгоритм обработки события           

protected override void HandleEvent(ModelEventArgsargs)

{

Model.KVZ[2].Value++; //увеличиваем количество вошедших заявок на 1

Model.KZS.Value++; //увеличиваем количество заявок находящихся в системе

Z.Tvh = Model.Time; //регистрируем время входа заявки в систему

Z.NP = 1;

 

Model.Tracer.EventTrace(this, Z.NZ); //вывод трассировки для свершившегося события

if(!Model.KZ[1])

           {

Model.KZ[1] = true; // занять канал

 

//запланировать событие Event2_Finish

varev4 = newEvent3_Finish2(Z); //создаём объект события, передаём в событие заявку

 

// генерируемвремяобработкисобытия

               double dt = Model.SecondStream_ServTime_ExpGenerator.GenerateValue();

 

//планируем событие

Model.PlanEvent(ev4, dt);

 

               //Выводим трассировку о запланированном событии

Model.Tracer.PlanEventTrace(ev4, Z.NZ);

}//end если канал свободен

 

           //если канал занят

else

           {

               //если есть места в 3-й очереди

if (Model.Queue[2].Count<Model.M[2])

               {

 

varQueueRecord = new QRec(); //создаёмобъектэлементаочереди

QueueRecord.Z = this.Z; //передаём в созданный объект объект заявки

Model.Queue[2].Add(QueueRecord); //добавляем элемент в очередь

 

               }

 

               //если нет мест в очереди, теряем заявку

else

               {

Model.KPZ[2].Value++; //увеличиваем количество потерянных заявок

Model.KZS.Value--; //уменьшаем количество заявок в системе

               }

 

           }//end если канал занят

 

           //Запланировать вход новой заявки в систему

Zayavkanew_Z = newZayavka();//создаём объект заявки

Model.NZS++;

           //new_Z.NZ = Model.KVZ[2]; //присваиваем ей номер

new_Z.NZ = Model.NZS;

 

varev3 = newEvent4_EnterTo2(new_Z); //создаём объект события, передаём в событие заявку

//генерируемвремявходазаявки

           double dt1 = Model.SecondStream_ReqTime_ExpGenerator.GenerateValue();

 

//Планируем событие

Model.PlanEvent(ev3, dt1);

 

           //Выводим в трассировку сообщение о запланированном событии

Model.Tracer.PlanEventTrace(ev3, new_Z.NZ);

 

           Model.TraceModel(); // выводим строку состояния

       }

}

}

}

SMOModel_Experiment.cs

usingCommonModel.Kernel;

usingCommonModel.RandomStreamProducing;

 

namespaceModel_Lab

{

 

publicpartialclassSmoModel:Model

{

//Условие завершения прогона модели True - завершить прогон. Поумолчанию false. </summary>

publicoverrideboolMustStopRun(intvariantCount, intrunCount)

{

return (Time>= TP);

   }

 

//установка метода перебора вариантов модели

publicoverrideboolMustPerformNextVariant(intvariantCount)

{

//используем один вариант модели

returnvariantCount< 1;

   }

 

//Задание начального состояния модели для нового варианта модели

publicoverridevoidSetNextVariant(intvariantCount)

   {

#regionПараметрымодели

 

Lamd[0] = (double)1 / (double)300; // 1 / 300

Lamd[1] = (double)1 / (double)480; // 1 / 480

Mu[0] = (double)1 / (double)240; // 1 / 240

Mu[1] = (double)1 / (double)150; // 1 / 150

M[0] = 3;

M[1] = 4;

M[2] = 5;

       A = 0;

       B = 1;

       TP = 14400000;// 4 часа 14400000;

       NZS = 0;

//проба: 100000

 

#endregion

 

 

#region Установка параметров законов распределения

 

(Uniform_generator.BPNasGeneratedBaseRandomStream).Seed = 17981;

       (FirstStream_ReqTime_ExpGenerator.BPNasGeneratedBaseRandomStream).Seed = 17981;

       (SecondStream_ReqTime_ExpGenerator.BPNasGeneratedBaseRandomStream).Seed = 17981;

       (FirstStream_ServTime_ExpGenerator.BPNasGeneratedBaseRandomStream).Seed = 17981;

       (SecondStream_ServTime_ExpGenerator.BPNasGeneratedBaseRandomStream).Seed = 17981;

 

Uniform_generator.A = A;

Uniform_generator.B = B;

FirstStream_ReqTime_ExpGenerator.Lyambda = Lamd[0];

SecondStream_ReqTime_ExpGenerator.Lyambda = Lamd[1];

FirstStream_ServTime_ExpGenerator.Lyambda = Mu[0];

SecondStream_ServTime_ExpGenerator.Lyambda = Mu[1];

 

#endregion

   }

 

 

publicoverridevoidStartModelling(intvariantCount, intrunCount)

{

#region Задание начальных значений модельных переменных и объектов

 

KZS.Value = 0;

 

for (inti = 0; i<streamAmount; i++)

       {

           TSZK[i].Value = 0.0;

Tobs[i].Value = 0.0;

           KZ[i] = false;

       }

 

for (inti = 0; i<queueAmount; i++)

       {

           KVZ[i].Value = 0;

           KPZ[i].Value = 0;

           Queue[i].Clear();

       }

 

 

#endregion

 

#region Cброссборщиковстатистики

 

Variance_KZS.ResetCollector();

 

for (inti = 0; i<streamAmount; i++)

       {

Variance_Tobs[i].ResetCollector();

       }

 

for (inti = 0; i<queueAmount; i++)

       {

Variance_KVZ[i].ResetCollector();

Variance_KPZ[i].ResetCollector();

}

 

 

#endregion

 

//Печать заголовка строки состояния модели

TraceModelHeader();

 

#region Планирование начальных событий

 

//Forfirst

Zayavka Z1 = newZayavka();

Z1.NZ = NZS;

       NZS++;

 

varstart_event = newEvent1_Enter();

start_event.Z = Z1;

doubledt = FirstStream_ReqTime_ExpGenerator.GenerateValue();

PlanEvent(start_event, dt);

Tracer.PlanEventTrace(start_event, Z1.NZ);

 

//For second

Zayavka Z4 = newZayavka();

       Z4.NZ = NZS;

       NZS++;

 

var start_event4 = newEvent4_EnterTo2(Z4);

dt = SecondStream_ReqTime_ExpGenerator.GenerateValue();

PlanEvent(start_event4, dt);

Tracer.PlanEventTrace(start_event4, Z1.NZ);

 

TraceModel(); // выводим строку состояния

Tracer.TraceOut("");

 

#endregion

 

 

   }

 

//Действияпоокончаниюпрогона

publicoverridevoidFinishModelling(intvariantCount, intrunCount)

{

       Tracer.TraceOut("==============================================================");

Tracer.TraceOut("============Статистические результаты моделирования===========");

Tracer.TraceOut("==============================================================");

Tracer.TraceOut("\n\t\t\tВариант #" + variantCount + " Прогон #" + runCount);

Tracer.TraceOut("Время моделирования: " + Time);

 

Tracer.TraceOut("Интенсивность поступления заявок в систему первого потока: " + ((double)KVZ[0].Value / (double)Time));

Tracer.TraceOut("Интенсивность поступления заявок в систему второго потока: " + ((double)KVZ[1].Value / (double)Time));

 

Tracer.TraceOut("Оценка вероятности потери заявок очереди 1: " + ((double)KPZ[0].Value / (double)KVZ[0].Value));

Tracer.TraceOut("Оценка вероятности потери заявок очереди 2: " + ((double)KPZ[1].Value / (double)KVZ[1].Value));

Tracer.TraceOut("Оценка вероятности потери заявок очереди 3: " + ((double)KPZ[2].Value / (double)KVZ[2].Value));

 

Tracer.TraceOut("Оценка вероятности занятости первого устройства обслуживания:" + ((double)TSZK[0].Value / (double)Time));

Tracer.TraceOut("Оценка вероятности занятости второго устройства обслуживания:" + ((double)TSZK[1].Value / (double)Time));

 

Tracer.TraceOut("МО времени обслуживания первого потока: " + Variance_Tobs[0].Mx);

Tracer.TraceOut("МО времени обслуживания второго потока: " + Variance_Tobs[1].Mx);

 

Tracer.TraceOut("МО количества заявок в системе: " + Variance_KZS.Mx);

   }

//Печать заголовка

voidTraceModelHeader()

   {

Tracer.TraceOut("Запущена модель");

//вывод параметров модели

Tracer.TraceOut("Интенсивность входных потоков: ");

Tracer.TraceOut("Lamd[1] = " + Lamd[0]);

Tracer.TraceOut("Lamd[2] = " + Lamd[1]);

Tracer.TraceOut("Интенсивность выходных потоков: ");

Tracer.TraceOut("Mu[1] = " + Mu[0]);

Tracer.TraceOut("Mu[2] = " + Mu[1]);

Tracer.TraceOut("Максимальное число мест в очереди: ");

Tracer.TraceOut("M[1] = " + M[0]);

Tracer.TraceOut("M[2] = " + M[1]);

Tracer.TraceOut("M[3] = " + M[2]);

       Tracer.TraceOut("________________________________________________________________________________");

//выводзаголовкатрассировки

Tracer.AnyTrace("KZ[0]", "KZ[1]", "Queue[0]", "Queue[1]", "Queue[2]", "KVZ[0]", "KVZ[1]", "KVZ[2]", "KPZ[0]", "KPZ[1]", "KPZ[2]", "TSZK[0]", "TSZK[1]");

Tracer.TraceOut("");

//Tracer.AnyTrace("KZ[0]", "KZ[1]", "KVZ[0]", "KVZ[1]", "KVZ[2]", "KPZ[0]", "KPZ[1]", "KPZ[2]", "Queue[0]", "Queue[1]", "Queue[2]", "TSZK[0]", "TSZK[1]");

}

 

//Печать строки состояния

voidTraceModel()

   {

Tracer.AnyTrace(KZ[0], KZ[1], Queue[0].Count.Value, Queue[1].Count.Value, Queue[2].Count.Value, KVZ[0].Value, KVZ[1].Value, KVZ[2].Value, KPZ[0].Value, KPZ[1].Value, KPZ[2].Value, TSZK[0].Value, TSZK[1].Value);

//Tracer.AnyTrace(KZ[0],KZ[1], KVZ[0].Value, KVZ[1].Value, KVZ[2].Value, KPZ[0].Value, KPZ[1].Value, KPZ[2].Value, Queue[0].Count.Value, Queue[1].Count.Value, Queue[2].Count.Value,TSZK[0].Value,TSZK[1].Value);

   }

 

}

}