Построение имитационной модели функционирования системы

Размещено на http://www.allbest.ru/

2

Содержание

Задание на курсовую работу

Законы распределения безотказной работы подсистем

Решение задачи

Имитация работы системы

Результаты

Список литературы

Приложение. Исходный код

Задание на курсовую работу

Целью проекта является разработка имитационной модели функционирования системы, отдельные подсистемы которой могут отказывать в процессе работы.

Система задана в виде логической схемы соединения подсистем (Схема 1). При этом считаем, что подсистема работоспособна, если ее выход связан с входом; если связь отсутствует (обрыв), подсистема неработоспособна. Это относится и к системе в целом.

Для каждой подсистемы задан закон распределения времени, в течение которого подсистема работоспособна.

Требуется по этим данным построить имитационную модель функционирования системы и с ее помощью определить следующие характеристики системы как целого:

1) закон распределения времени безотказной работы всей системы;

2) среднее время безотказной работы системы;

3) вероятность того, что система не откажет в течение заданного промежутка времени(значения границ выбрать самостоятельно);

4) построить графики законов распределения времени безотказной работы подсистем (для этого модель не требуется) сравнить с результатом п. 1) и провести сравнительный анализ безотказности системы и ее подсистем.

Для выполнения п. 1) следует смоделироватьреализаций случайного процесса функционирования системы для различных значенийи получить, таким образом, ряд значений.

Полученный ряд сгладить непрерывной функцией по методу наименьших квадратов. Значениевыбрать методами математической статистики, исходя из разумных требований к точности и достоверности статистических оценок.



Вариант схемы (1)

Схема 1: логическая связь подсистем

Законы распределения безотказной работы подсистем

(указаны порядковые номера подсистем)

1) Экспоненциальное распределение с параметром
;

2) Экспоненциальное распределение с параметром
;

3) Нормальное распределение с параметрами;

4) Равномерное распределение с параметрами;

5) Равномерное распределение с параметрами;

6) Симметричное треугольное распределение, заданное на отрезке; одно случайное число, распределенное по этому закону, может быть получено как сумма двух случайных чисел с равномерным законом на интервале;

7) Нормальное распределение с параметрами;

Решение задачи

Имитация есть воспроизведение событий, происходящих в системе, т.е. исправной работы либо отказа каждого элемента.

Если время работы системы, а-- время безотказной работы элемента с номером , то:

· событие означает исправную работу элемента за время ;

· событиеозначает отказ элемент к моменту.

Заметим, что-- случайная величина, распределенная по закону, который известен по условию.

Моделирование случайного события «исправная работаэлемента за время » заключается:

1) в получении случайного числа, распределенного по закону;

2) в проверке истинности логического выражения. Если оно истинного, тоэлемент исправен, если ложно -- он отказал.

Система состоит из 7 блоков (Схема 1). Блоки объединены в цепи.

Цепь - последовательность блоков соединяющие вход и выход в системы и объединенных при помощи проводников. Для нормального функционирования системы необходима исправная работа хотя бы одной цепи.

Функции распределения времени безотказной работы блоков указаны выше.

Имитация работы системы

Для моделирования работы системы понадобятся:

1) Законы распределения случайной величины для каждого блока системы;

2) Генератор случайной величины на интервале [0;1];

3) Логическая формула безотказной работы системы;

Законы распределения заданы нам в условии.

Для имитации работы системы был выбран язык Java.

Исходный код приведен в Приложении.

Результаты

Для каждого интервала безотказной работы системы было проведено по 50 испытаний. Вероятное время безотказной работы было выбрано интервалом от 1 до 12 часов. В общей сложности произведено 3000 испытаний.

1) Закон распределения времени безотказной работы всей системы



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

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

2) Среднее время безотказной работы системы: 3 часа.

3) Вероятность того что система не откажет в течение 2 часов после начала работы: 80%;

Размещено на http://www.allbest.ru/

Размещено на http://www.allbest.ru/

Рассмотрев графики законов распределения безотказности подсистем и системы в целом можно сделать вывод: при работе системы меньше 2 часов на безотказность системы наибольшее влияние оказывают подсистемы 4, 5 и 6, т.е. преобладает действие равномерного распределения вероятности безотказной работы системы. При дальнейшей эксплуатации вероятность больше подчинена нормальному и экспоненциальному распределению, которому соответствуют подсистемы 1, 2, 3 и 7.

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

Список литературы

1. Емельянов А.А. и др. Имитационное моделирование экономических процессов: Учеб. пособие / А.А. Емельянов, Е.А. Власова, Р.В. Дума; Под ред. А.А. Емельянова. - М.: Финансы и статистика, 2002. - 368 с : ил.

2. Гмурман В.Е. Руководство к решению задач по теории вероятностей и математической статистике: Учеб. пособие для студентов втузов.- 3-е изд., перераб. и доп.-М.: Высш. Школа, 2007. - 400 с., ил.

3. Гмурман В.Е. Теория вероятностей и математическая статистика Изд. 4-е, доп. Учеб. пособие для студентов втузов. М., «Высш. Школа», 2009. 368 с., илл.

4. Вентцель Е.С. Теория вероятностей, М., «Наука», 2010 г., 576 стр. с илл

Приложение. Исходный код

import java.text.DecimalFormat;

import java.util.ArrayList;

/**

* @author Sannikiv Igor Olegovich

*/

public class imep extends distribution

{

static int maxN = 3000;

static int maxT = 3000;

static DecimalFormat df = new DecimalFormat("0.0000");

static DecimalFormat prc = new DecimalFormat("0.00'%'");

static ArrayList<Double> results = new ArrayList<Double>();

static ArrayList<Boolean> successResults = new ArrayList<Boolean>();

/** так красивее) */

static int t1 = 0;

static int t2 = 1;

static int t3 = 2;

static int t4 = 3;

static int t5 = 4;

static int t6 = 5;

static int t7 = 6;

/** массив со значениями */

static double[] tArray = new double[7];

/** число реализаций случайного процесса */

static int Nt = 0;

/** время работы системы */

static int tStart = 0;

static int tEnd = 0;

/**

* @param args

*/

public static void main(String[] args)

{

// получаем число Nt

while (Nt == 0)

{

System.out.print("Enter the count of realizations of the random process Nt [1-" + maxN + "]: ");

String s = System.console().readLine();

if(isNumder(s, maxN))

Nt = Integer.parseInt(s);

}

// получаем число tStart

while (tStart == 0)

{

System.out.print("Enter the time interval \'Start\' [1-" + maxT + "]: ");

String s = System.console().readLine();

if(isNumder(s, maxT))

tStart = Integer.parseInt(s);

}

// получаем число tEnd

while (tEnd == 0)

{

System.out.print("Enter the time interval \'End\' [1-" + maxT + "]: ");

String s = System.console().readLine();

if(isNumder(s, maxT))

tEnd = Integer.parseInt(s);

}

if(tStart >= tEnd)

System.exit(2);

for(int i = tStart; i <= tEnd; i++)

{

/** счётчик числа успехов */

double success = 0;

for(int j = 0; j < Nt; j++)

{

generateBlockData();

// printBlockData(j);

boolean isSuccess = isSuccessful();

successResults.add(isSuccess);

if(isSuccess)

success++;

}

double fail = 1.0D - success / Nt; // вероятность отказа системы на i часу работы

// список с результатами вероятности отказа для каждого i часа

results.add(fail);

}

double noFailPercent = 100.D - average(results) * 100;

System.out.println("\nThe probabilities of system failure from \'" + tStart + "\' to \'" + tEnd + "\' hours:\n" + results);

System.out.println("The probability of failure-free operation: " + prc.format(noFailPercent));

}

static void generateBlockData()

{

tArray[t4] = Distribution(1.0D, 29.0D, DISTRIBUTIONS.UNIFORM); // 4 закон - Равномерное распределение (a = 1, b = 29)

tArray[t5] = Distribution(2.0D, 14.0D, DISTRIBUTIONS.UNIFORM); // 5 закон - Равномерное распределение (a = 2, b = 14)

tArray[t3] = Distribution(3.0D, 16.0D, DISTRIBUTIONS.NORMAL); // 3 закон - Нормальное распределение (sigma = 3 часа, m = 16 часов)

tArray[t7] = Distribution(2.0D, 14.0D, DISTRIBUTIONS.NORMAL); // 7 закон - Нормальное распределение (sigma = 2 часа, m = 14 часов)

tArray[t1] = Distribution(1.0D, 20.0D, DISTRIBUTIONS.EXPONENTIAL); // 1 закон - Экспоненциальное распределение (gamma = 1/20)

tArray[t2] = Distribution(1.0D, 10.0D, DISTRIBUTIONS.EXPONENTIAL); // 2 закон - Экспоненциальное распределение (gamma = 1/10)

tArray[t6] = Distribution(2.0D, 18.0D, DISTRIBUTIONS.SYMMETRIC_TRAGNGLE); // 6 закон - Симметричное треугольное распределение (c = 2, d = 18)

}

/**

* Возвращает среднее значение элемента из списка чисел <code>numbers</code>

*/

static double average(ArrayList<Double> numbers)

{

double summ = 0.0D;

for(double n : numbers)

summ += n;

return summ / numbers.size();

}

/**

* Возвращает, распределенную по равномерному закону, вероятность безотказной работы системы

*/

static double probability(ArrayList<Boolean> testResult)

{

double s = 0.0D;

for(boolean b : testResult)

if(b)

s++;

return s / testResult.size();

}

/**

* Возвращает <code>true</code> если цепь работает

*/

static boolean isSuccessful()

{

// Получаем 7 равномерно распределенных на [0,1] случайных числа

double[] yArray = new double[7];

for(int i = 0; i < 7; i++)

yArray[i] = rnd();

boolean b1 = tArray[t1] >= yArray[t1] ? true : false;

boolean b2 = tArray[t2] >= yArray[t2] ? true : false;

boolean b3 = tArray[t3] >= yArray[t3] ? true : false;

boolean b4 = tArray[t4] >= yArray[t4] ? true : false;

boolean b5 = tArray[t5] >= yArray[t5] ? true : false;

boolean b6 = tArray[t6] >= yArray[t6] ? true : false;

boolean b7 = tArray[t7] >= yArray[t7] ? true : false;

// Проверяем условия работоспособности цепи

if((b1 || b2) && b3 && (b4 || b5 || b6))

return true;

return b7;

}

static void printBlockData(int n)

{

System.out.println("Data for n = " + n);

System.out.println("-------------------\n");

for(int i = 0; i < 7; i++)

// System.out.println("t" + (i + 1) + " = " + df.format(tArray[i]));

System.out.println("t" + (i + 1) + " = " + tArray[i]);

System.out.println();

}

/**

* @return <code>true</code> если <b>text</b> число и меньше или равно maxVal

*/

static boolean isNumder(String text, int maxVal)

{

double t = 0;

try

{

t = Double.parseDouble(text);

}

catch(NumberFormatException e)

{

return false;

}

return t <= maxVal && t > 0;

}

}

import java.util.Random;

import org.apache.commons.math.MathException;

import org.apache.commons.math.distribution.ExponentialDistributionImpl;

import org.apache.commons.math.distribution.NormalDistributionImpl;

import org.apache.commons.math.random.RandomDataImpl;

public abstract class distribution

{

static Random random = new Random(System.currentTimeMillis());

static double SQRT2PI = Math.sqrt(2 * Math.PI);

static boolean AltFormuls = false;

static enum DISTRIBUTIONS

{

UNIFORM, EXPONENTIAL, NORMAL, SYMMETRIC_TRAGNGLE

}

/**

* Генерируем данные для блока

*/

static double Distribution(double arg1, double arg2, DISTRIBUTIONS uniform)

{

switch (uniform)

{

case UNIFORM:

return !AltFormuls ? uniformDistribution(arg1, arg2) : new RandomDataImpl().nextUniform(arg1, arg2);

case EXPONENTIAL:

return !AltFormuls ? exponentialDistribution(arg1 / arg2) : new RandomDataImpl().nextExponential(arg1 / arg2);

case NORMAL:

return !AltFormuls ? normalDistribution(arg1, arg2) : new RandomDataImpl().nextGaussian(arg1, arg2);

case SYMMETRIC_TRAGNGLE:

return !AltFormuls ? symmetricTragngleDistribution(arg1, arg2) : new RandomDataImpl().nextUniform(arg1 / 2, arg2 / 2) + new RandomDataImpl().nextUniform(arg1 / 2, arg2 / 2);

default:

System.out.println("distribution: error - wrong type.");

}

return 0;

}

/**

* Метод для равномерного распределении случайной величины на интервале [a;b]

*/

public static double uniformDistribution(double a, double b)

{

double x = altUniformDistribution(a, b);

if(x <= a)

return 0.0D;

if(x >= b)

return 1.0D;

return (x - a) / (b - a);

}

/**

* Альтернативный метод для равномерного распределении случайной величины на интервале [a;b]

*/

public static double altUniformDistribution(double a, double b)

{

return a + rnd((int) Math.floor((b - a)));

}

/**

* Метод для экспоненциального распределения случайной величины

*

* @param gamma

* - параметр распределения

*/

public static double exponentialDistribution(double gamma)

{

ExponentialDistributionImpl ed = new ExponentialDistributionImpl(gamma);

try

{

return ed.cumulativeProbability(rnd());

}

catch(MathException e)

{

e.printStackTrace();

}

return 0;

}

/**

* Альтернативный метод для экспоненциального распределения случайной величины

*

* @param gamma

* - параметр распределения

*/

public static double altExponentialDistribution(double gamma)

{

return 1.0D - Math.exp(-rnd() * gamma);

}

/**

* Метод для нормального (Gauss) распределения случайной величины

*

* @param sigma

* - коэффициент масштаба

* @param m

* - коэффициент сдвига

*/

public static double normalDistribution(double sigma, double m)

{

NormalDistributionImpl ed = new NormalDistributionImpl(sigma, m);

try

{

return ed.cumulativeProbability(rnd());

}

catch(MathException e)

{

e.printStackTrace();

}

return 0;

}

/**

* Альтернативный vетод для нормального (Gauss) распределения случайной величины

*

* @param sigma

* - коэффициент масштаба

* @param m

* - коэффициент сдвига

*/

public static double altNormalDistribution(double sigma, double m)

{

double t1 = 1.0D / (sigma * SQRT2PI);

double t2 = Sqr(rnd() - m) / (2.0D * Sqr(sigma));

return Math.exp(-t2) * t1;

}

/**

* Метод для симметричного треугольное распределения заданного на отрезке [c;d]

*/

public static double symmetricTragngleDistribution(double c, double d)

{

double a = c / 2.0D;

double b = d / 2.0D;

return uniformDistribution(a, b) + uniformDistribution(a, b);

}

/**

* Возведение x в степень 2

*/

static double Sqr(double x)

{

return Math.pow(x, 2);

}

/**

* Возвращает случайное число от 0 до 1 (не включая единицу)

*/

static double rnd()

{

double u;

while (true)

{

u = random.nextDouble();

// нельзя, чтобы u получилось равное 0, т.к. логарифм от нуля не существует

if(u > 0.001)

break;

}

return u;

}

/**

* Возвращает случайное число от 0 до n

*/

static int rnd(int n)

{

int u;

while (true)

{

u = random.nextInt(n);

// нельзя, чтобы u получилось равное 0, т.к. логарифм от нуля не существует

if(u > 0)

break;

}

return u;

}

}

Размещено на Allbest.ru