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

m("save_in_file","Сохраняем в файл ","Save in file ");

m("file_is_saved","Файл сохранен","File is saved");

m("del_cur_model","Удалить текущую модель?", "Would you like to delete current model");

m("loading_new_model...","Загружаем новую модель...", "The new model is being loaded...");

m("loading_new_model_from_file", "Загружаем новую модель из файла ", "New model is being loaded from file");

m("new model", "Новая модель", "New model");

m("too_many_errors_in_input_file", "Слишком много ошибок во входном файле", "Too many errors in input file");

m("model_is_loaded", "Модель загружена", "The model is loaded");

m("TRDA_typed_model", "Модель типа TRDA ", "TRDA typed model ");

m("model_is_not_loaded", "Модель не загружена", "The model is not loaded");

m("unopened comment id closed", "Закрыт неоткрытый комментарий", "Unopened comment is closed");

m("about_program","О программе", "About program");

m("program_implements_trda",

@"Программа реализует систему временных конечных автоматов

"

,

@"Program implements Timed Resource Driven automata nets

"

);

m("model_description_language", "Язык описания модели","Model description language");

m("bnf",

@"Описание модели с помощью формализма

БНФ

<Описание модели> ::= model(<название модели>)

<системная сеть>

<автоматный слой>

<начальная разметка>

<системная сеть> ::=

[<определение вершины системного слоя>, … ]

[<определение дуги системного слоя>, … ]

<определение вершины системного слоя> ::= place(<название вершины>)

<определение дуги системного слоя> ::=

<определение входящей дуги> | <определение исходящей дуги>

<определение входящей дуги> ::=

arc_in(<вершина приемник>, <вершина источник>, <название порта>)

<определение исходящей дуги> ::=

arc_out(<вершина источник>, <вершина приемник>, <название порта>)

<автоматный слой> ::= [<определение типа>, … ]

<определение типа> ::= type(<имя типа>)

[<определение элемента типа>, … ]

[<обозначение состояния на графике>, … ]

[<определение перехода>, … ]

<определение элемента типа> ::= <определение состояния> | < определение порта>

| < определение константы> | < определение переменной>

<определение состояния> ::= state(<имя состояния>)

<определение переменной> ::= var(<имя переменной>)

<определение константы> ::= const(<имя константы>)

<определение порта> ::= port(<имя порта>)

<обозначение состояния на графике> ::=

state_chart_name(<имя состояния>, <имя состояния на графике>)

<определение перехода> ::=

trans(<имя исходного состояния>, <имя итогового состояния> [, <название перехода>])

[<атрибут перехода>, … ]

[<определение преобразования ресурсов>, … ]

<атрибут перехода> ::= <продолжительность перехода>

| <обозначение перехода на графике>

| <вероятность перехода>

<продолжительность перехода> ::=

duration(<минимальное время перехода>[, <максимальное время перехода>])

<вероятность перехода> ::=

priority(<приоритет перехода>)

<обозначение перехода на графике> ::=

trans_chart_name(<имя перехода на графике>)

<определение преобразования ресурсов> ::=

<определение потребления ресурсов> | <определение производства ресурсов>

<определение потребления ресурсов> ::=

term_in(<имя порта>, <имя ресурса>[, <состояние потребляемого ресурса>])

<определение производства ресурсов> ::=

term_out(<имя порта>, <имя ресурса>[, <состояние производимого ресурса>])

<имя ресурса> ::= <имя константы> | <имя переменной>

<начальная разметка> ::= place(<имя вершины>)

[<определение объекта>, … ]

<определение объекта> ::= inst(<имя константы>[, <имя состояния>])

" ,

@"Model description using BNF

<Model description> :: model (<model title>)

<system net>

<automata net>

<initial marking>

<system net> ::=

[<definition of system net node>, …]

[<definition of system net arcs>, …]

<definition of system net node> :: = place (<node name>)

<definition of system net arc> :: = <definition of incoming arc> | <definition of outcoming arc>

<definition of incoming arc> ::=

arc_in(<receiver node>, <source node>, <port name>)

<definition of outcoming arc> ::=

arc_out (<source arc>, <receiver arc>, <port name>)

<automata net> :: [<type definition>, …]

<type definition> :: = type(<type name>)

[<definition of type element>, …]

[<definition of states on graph>, …]

[<transition definition>, …]

<definition ot type element> ::= <state definition> | <port definition> | <constant definition> | <variable definition>

<state definiton> ::=state (<state name>)

<variable definition> ::=var(<variable name>)

<constant definition>::= const(<constant name>)

<port definition>:: = port (<port name>)

< definition of state on graph > :: =

state_chart_name (<state name>, <state name on graph>)

<transition definition>::= trans(<source state name>, <destination state name> [,

transition name>])

[<transition attribute>,…]

[<definition of resource transformation>,…]

<transition attribute>:: = <transition duration>

| < definition of states on graph >

| <transition probability>

<estimation of transition work> ::= wait(<minimum time of transition estimation>[, <maximum time of transition estimation>])

<transition duration>::=time (<minimum time of transition work>[,<maximum time of transition work>])

<transition probability>::= priority(<priority of transition>)

< definition of transition on graph >:: = trans_chart_name(<transition name on graph>)

< definition of resource transformation > = <definition of resource consume> | <definition of resource production>

<definition of resource consume> :: = term_in (<port name>, <resource name[,<condition of consumed resource>])

<definition of resource production>::=term_out(<port name>, <resource name>[,<condition of produced resource>])

<resource name>:: = <constant name>|<variable name>

<initial marking>::=place(<node name>)

[<object definition>,…]

<object definition>::=inst(<constant name>[,<state name>])

"

);

m("consume", " потребление", " consume");

m("production"," производство", " production");

m("end", " конец"," end");

m("Pause", ". Пауза: ", ".Pause: ");

m("show_of_rezults", "Показ итогов невозможен: t_current=","Impossible to show rezults: t_current=");

m("time_doesn't move", " - время не продвинулось.", " - time does not move.");

m("=REZULTS=", "==================== ИТОГИ =============", "================== REZULTS ===========");

m("total_po_const", "Итого по const ", "Total for const");

m("sec", "сек.", "sec.");

m("performance_time", "Время выполнения ", "Performance time ");

m("number_of_steps", ", число шагов ", ", number of steps ");

m("r_reachability", "Достижимость:", "Reachability:");

m(" Marking "," Маркировка ", " Marking ");

m("reached", " достигнута ", " reached ");

m("Boundedness:", "Ограниченность:", "Boundedness:");

m("bound", " Ограничение ", " Bound ");

m("yes", "да", "yes");

m("no","нет","no");

m("presence_od_deadlocks", "Наличие тупиковых ситуаций: ", "Presence of deadlocks: ");

m("Liveness", "Живость: ", "Liveness: ");

m(" Transition:", " Переход: "," Transition: ");

m("liveness_by_system_net_transition", "Живость по переходам системной сети: ", "Liveness by system net transitions: ");

m("Arc", " Дуга: "," Arc: ");

m("Agent", "Агент ","Agent ");

m("number_of_states", "===Количество состояний ", "===Number of states ");

m("cond", " Состояние ", " Condition ");

m("time_total", ": время общее ",": total time ");

m("average", ", среднее ", ",average ");

m("number_of_transitions", "===Количество переходов ", "===Number of transitions ");

m("Transition", " Переход ", " Transition ");

m("number", ", кол-во "," number ");

m("form1_title", "Модель типа TRDA ","Model of TRDA type ");

m("title_FormRezults", "Результаты анализа", "Analysis");

m("title_FormVisual", "Визуализация модели", "Model visualization");

m("title_SystemNet", "Системная сеть", "System Net");

m("title_AutomataNet", "Автоматная сеть", "Automata Net");

m("title_Form1", "Модель типа TRDA ", "Model of TRDA type " );

m("times", " раз", " times ");

m("save","Сохранить", "Save");

}

}

}

34 Program.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Windows.Forms;

namespace Automata {

static class Program {

/// <summary>

/// Главная точка входа для приложения.

/// </summary>

[STAThread]

static void Main() {

Application.EnableVisualStyles();

Application.SetCompatibleTextRenderingDefault(false);

Application.Run(new Form1());

}

}

}

35 State.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Collections;

namespace Automata {

class Arc {

public static int IN = 1;

public static int OUT = 2;

public Place p,p0;

public Port port;

public int in_out;

public Arc(Place i_place, Port i_port) {

p = i_place;

port = i_port;

}

}

class Res {

public Type type;

public string name;

}

class Const:Res {

public int id; //номер константы в модели

public Const(string i_name) {

name = i_name;

}

}

class Var:Res {

public Var(string i_name) {

name = i_name;

}

}

class Port {

public Type type;

public string name;

public Port(string i_name) {

name = i_name;

}

}

class Place {

public string name;

public bool is_expanded = true;

public int id; //номер места в модели

public List<Arc> list_in = new List<Arc>();

public List<Arc> list_out = new List<Arc>();

public List<Instance> list_inst = new List<Instance>();

public Place(string i_name) {

name = i_name;

}

public void set_is_expanded(bool i_is_expanded){

is_expanded = i_is_expanded;

}

}

class Type {

public int id; // номер типа в модели

public string name;

public List<Const> list_const = new List<Const>();

public List<Var> list_var = new List<Var>();

public List<Port> list_port = new List<Port>();

public List<Transition> list_trans = new List<Transition>();

public List<State> list_states = new List<State>();

public Hashtable States = new Hashtable();

public List<Register> list_regs = new List<Register>();

public Hashtable Registers = new Hashtable();

public State initial_state;

public Type(string i_name) {

name = i_name;

}

}

class Term {

public static int c = 1;

public static int v = 2;

public Port port;

public int cv;

public Res res;

public State state = null;

public Term(Port i_port, Const i_con) {

port = i_port;

res = i_con; cv = Term.c;

}

public Term(Port i_port, Var i_var) {

port = i_port;

res = i_var; cv = Term.v;

}

}

class Transition {

public static int default_priority = 100;

public static float default_duration = 0;

public static float default_wait = 0;

public char symbol = 'o';

public string name = null;

public int id; // номер перехода в данном состоянии (внутренний id)

public string chart_name = null;

public State state_from, state_to;

public int priority = Transition.default_priority;

public Double duration_min = Transition.default_duration

, duration_max = Transition.default_duration;

public Double wait_min = Transition.default_wait

, wait_max = Transition.default_wait;

// public double time_enable = -1.0;

public Transition(State i_state_from, State i_state_to) {

state_from = i_state_from;

state_to = i_state_to;

if(name == null) {

name = state_from.name + "->" + state_to.name;

chart_name = name;

}

// time_enable = -1.0;

}

public List<Register> list_reset = new List<Register>(); // only for registers of type rt_timer

public List<Constraint> list_constr = new List<Constraint>();

public List<Term> list_term_in = new List<Term>();

public List<Term> list_term_out = new List<Term>();

public double get_wait_time() {

return Lib.get_random_from_interval(wait_min,wait_max);

}

public double get_duration_time() {

return Lib.get_random_from_interval(duration_min,duration_max);

}

public bool has_timed_constraints() {

if(list_constr.Count > 0 || list_reset.Count > 0) {

return true;

}

return false;

}

}

class State {

public string name;

public string chart_name;

public Type type;

public char symbol = 'o';

public int id; //номер состояния в типе

public List<Transition> list_trans = new List<Transition>();

public State(string i_name, Type i_type) {

name = i_name;

chart_name = i_name;

type = i_type;

}

}

enum RegType { rt_int, rt_timer };

class Register {

public string name;

public RegType reg_type;

public int id; // номер регистра в типе

public Register(string i_name, RegType i_reg_type) {

name = i_name;

reg_type = i_reg_type;

}

}

enum ConstraintRelation { gt, ge, lt, le, eq };

class Constraint {

public int a=0, b=0, c=0;

public Register r1 = null, r2 = null;

public ConstraintRelation rel=ConstraintRelation.gt;

public string title() {

return title(false);

}

public string title(bool i_esc) {

string ss = r1.name;

if(r2 != null) {

ss += (b == -1) ? "-" : "+";

ss += r2.name;

}

switch (rel){

case ConstraintRelation.lt: ss += i_esc ? "&lt;" : "<";break;

case ConstraintRelation.le: ss += i_esc ? "&le;" : "<=";break;

case ConstraintRelation.gt: ss += i_esc ? "&gt;" : ">";break;

case ConstraintRelation.ge: ss += i_esc ? "&ge;" : ">=";break;

case ConstraintRelation.eq: ss += "=";break;

}

ss += ""+c;

return ss;

}

}

class Instance {

public static int flag_busy = 1;

public static int flag_free = 2;

public static int flag_consumed = 3;

public Const con;

public State current_state;

double saved_global_time = 0.0;

public bool is_visual = false;

public double[] registers = new double[0];

public double[] trans_fire_time = new double[0];

// public Transition current_trans;

public Step current_step;

public int n_last_trace = -1;

public int flag = flag_free;

public Place place;

public Model model;

public void set_place(Place i_place) {

place = i_place;

place.list_inst.Add(this);

}

public Instance(Model i_model,Const i_con, State i_state) {

con = i_con;

model = i_model;

current_state = i_state;

}

public Instance(Model i_model, Const i_con) {

con = i_con;

model = i_model;

if(con.type.initial_state != null) {

current_state = con.type.initial_state;

}

}

public void set(State i_state) {

if(this.current_state == i_state) {

return; // nothing to do

}

//Model.write_change(this,;

}

public void discharge_transition(Transition trans) {

trans_fire_time[trans.id] = -1.0;

}

public bool charge_transition(Transition trans, double i_fire_time) {

if(trans_fire_time[trans.id] == -1.0) {

trans_fire_time[trans.id] = i_fire_time;

return true;

} else {

return false; // already enabled

}

}

public bool is_ready_to_fire(Transition trans, double i_current_time

, double i_fire_time) {

if(i_fire_time <= i_current_time) {

return true; // is already ready to fire!

}

if(trans_fire_time[trans.id] > i_current_time

|| trans_fire_time[trans.id] == -1.0

) {

return false; // is not yet ready to fire

}

return true; // is ready to fire!

}

private bool check_charge_transition2(Transition trans

, double i_current_time, double i_fire_time) {

/*

Form1.log("trans.id=" + trans.id

+ " trans_fire_time[id]=" + trans_fire_time[trans.id]

+ " i_current_time=" + i_current_time

+ " i_fire_time=" + i_fire_time

);

*/

if(is_ready_to_fire(trans, i_current_time, i_fire_time)) {

// Form1.log("return true");

return true;

}

// Form1.log("charge and return false");

charge_transition(trans, i_fire_time);

return false;

}

// Timers!

public void start_timers(double i_global_time) {

registers = new double[con.type.list_regs.Count];

for(int i = 0; i < registers.Length; i++) {

registers[i] = 0.0;

}

saved_global_time = i_global_time;

}

public void move_timers(double i_global_time) {

double delta_t = Math.Round(i_global_time - saved_global_time,2);

foreach(Register reg in con.type.list_regs) {

if(reg.reg_type == RegType.rt_timer) {

registers[reg.id] += delta_t;

}

}

saved_global_time = i_global_time;

}

public void reset_timers(Transition trans, double i_global_time) {

move_timers(i_global_time);

foreach(Register reg in trans.list_reset) {

registers[reg.id] = 0.0;

}

}

public double get_satisfy_time(Transition trans) {

/*

* Возвращает:

* 0 - если выполняется сейчас

* -1 - не выполнится никогда

* >0 - когда выполнится

* Должны использоваться данные из таймеров.

*

*/

double ret_value = 0.0;

double x1=0, x2=0, c0=0;

foreach(Constraint constr in trans.list_constr){

Form1.log("<c><c><c><c><c>"+constr.title());

if(constr.r1 == null) {

x1 = 0;

} else {

x1 = this.registers[constr.r1.id];

}

if(constr.r2 == null) {

x2 = 0;

} else {

x2 = this.registers[constr.r2.id];

}

c0 = constr.a * x1 + constr.b * x2;

Form1.log("get_satisfy_time: x1=" + x1 + " x2=" + x2 + " c0=" + c0 + " c=" + constr.c);

bool constr_true = false;

switch(constr.rel) {

case ConstraintRelation.lt:

constr_true = (c0 < constr.c);

Form1.log("lt=" + constr_true);

break;

case ConstraintRelation.le:

constr_true = (c0 <= constr.c);

Form1.log("le=" + constr_true);

break;

case ConstraintRelation.gt:

constr_true = (c0 > constr.c);

Form1.log("gt=" + constr_true);

break;

case ConstraintRelation.ge:

constr_true = (c0 >= constr.c);

Form1.log("ge=" + constr_true);

break;

case ConstraintRelation.eq:

constr_true = (c0 == constr.c);

Form1.log("eq=" + constr_true);

break;

default:

break;

}

if(constr_true) {

Form1.log("get_satisfy_time: do_nothing");

// do_nothing

} else { // констрейнт не сейчас выполняется

if(constr.a + constr.b == 0) { // никогда не выполнится

ret_value = -1;

} else {

double t = 0.0;

t = (constr.c - constr.a * x1 - constr.b * x2) / (constr.a + constr.b);

Form1.log("get_satisfy_time: t="+t);

if(t < 0) { // никогда не выполнится

ret_value = -1;

}else{

double round_t = Math.Round(t,2);

if(round_t < t) {

round_t += 0.01;

}

switch(constr.rel) {

case ConstraintRelation.lt:

case ConstraintRelation.gt:

if(round_t == t){

round_t += 0.01;

}

break;

default:

break;

}

Form1.log("get_satisfy_time: round_t=" + round_t);

t = round_t;

if((ret_value == 0 || ret_value > t && ret_value > 0) && t>0) {

ret_value = t;

}

}

}

}

}

return ret_value;

}

// Timers!

public void reset_transitions() {

trans_fire_time = new double[current_state.list_trans.Count()];

for(int i=0; i<trans_fire_time.Length;i++){

trans_fire_time[i] = -1.0;

}

}

}

class Bind {

public Term term; // Входной term из проверяемого перехода

public Instance inst; // соответствующий "пассивный" ресурс

public Arc arc; // Входная дуга

public Bind(Term i_term, Instance i_inst, Arc i_arc) {

term = i_term;

inst = i_inst;

arc = i_arc;

}

}

class Outcome {

public Term term;

public Arc arc;

public Outcome(Term i_term, Arc i_arc){

term = i_term;

arc = i_arc;

}

}

class Step {

public Instance inst; // активный ресурс

public Transition trans; // его проверяемый переход

public string title;

public double start_time; //время старта

public double finish_time; //время завершения

// public int start_n_trace; //номер такта

public Hashtable Binds = new Hashtable();

public Hashtable Vars_in = new Hashtable();

public Hashtable Vars_out = new Hashtable();

public List<Outcome> Outcomes = new List<Outcome>();

public Step(Instance i_inst, Transition i_trans) {

inst = i_inst;

trans = i_trans;

title = inst.place.name + ": "

+ inst.con.name + "/" + inst.current_state.name

+ " --> " + trans.name;

foreach(Constraint constr in trans.list_constr) {

title += "[" + constr.title() + "]";

}

}

}

class Applicant {

public Instance inst;

public List<Step> steps = new List<Step>();

public Applicant(Instance i_inst) {

inst = i_inst;

}

}

class Point { // TimePoint

public Double time = 0.0;

public List<Step> steps = new List<Step>();

public int fire_count = 0;

public Point(Double i_time) {

time = i_time;

steps = new List<Step>();

}

}

class AgentStateTotal{

public State state;

public double total_time = 0.0;

public int count = 0;

}

class AgentTransTotal {

public Transition trans;

public double total_time = 0.0;

public int count = 0;

}

class AgentTotal {

public Const con;

public int state_count_total = 0, state_count_posible = 0;

public int trans_count_total = 0, trans_count_posible = 0;

public double unstate_total_time = 0.0;

public int unstate_count = 0;

//public List<AgentStateTotal> list_states = new List<AgentStateTotal>();

public Hashtable states = new Hashtable(); // (AgentStateTotal.state,AgentStateTotal)

public Hashtable transes = new Hashtable(); // (AgentTransTotal.trans,AgentTransTotal)

}

class Trace { // история изменения объектов

public Const con;

public State state;

public Place place;

public Step step;

public Transition trans;

public double time_start;

public double time_finish;

public int n_start;

public int n_finish;

public string show() {

string ss = "" + this.n_start + "\tfin=" + this.n_finish;

ss += "\ttime(" + this.time_start +" - "+ this.time_finish+")";

ss += ": \t\t"+this.con.name;

if (this.place != null){

ss += ":"+place.name;

}

if(this.state != null) {

ss += " " + this.state.name;

}

if(this.trans != null) {

ss += " " + this.trans.state_from.name+" -> "+

this.trans.state_to.name;

}

return ss;

}

}

class Marking {

public string name;

public int last_eq_n_trace; //номер последнего шага с совпадением

public int count; // кол-во попаданий

public bool like = false;

public int[] hash;

public Hashtable places = new Hashtable();

//public Place current_place;

public Marking(string i_name) {

name = i_name;

}

}

class Bound {

public string name;

public Place place = null;

public Type type = null;

public int limit = 0;

public int max_value = 0;

public int min_value = 0;

public int count = 0;

public Bound(string i_name) {

name = i_name;

}

}

}

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

...