CN111880784A

CN111880784A - SIMSCRIPT language-oriented discrete event simulation graphical modeling method

Info

Publication number: CN111880784A
Application number: CN202010780798.1A
Authority: CN
Inventors: 方旭东; 师磊; 唐宇波; 吴高洁; 沈弼龙; 黄海燕; 王海波; 张珊; 司光亚; 吴�琳
Original assignee: National Defence University Of People's Liberation Army Joint Operation Institute
Current assignee: National Defence University Of People's Liberation Army Joint Operation Institute
Priority date: 2020-08-06
Filing date: 2020-08-06
Publication date: 2020-11-03
Anticipated expiration: 2040-08-06
Also published as: CN111880784B

Abstract

The invention provides an SIMSCRIPT language-oriented discrete event simulation graphical modeling method, which is characterized in that primitives such as entities, routines and events are added into a canvas serving as a primitive bearing container in a dragging mode according to modeling technologies such as an entity flow graph and an activity cycle graph, the interaction relation among the entities, the routines and the events is represented through connecting lines, the primitives can be drawn and managed in the canvas, the canvas can be divided into a plurality of canvases according to calling relation and hierarchical relation, all the canvases can be stored into engineering files with specific formats, and the engineering files can automatically generate SIMSCRIPT simulation codes according to mapping rules. The invention builds a discrete event simulation program based on the SIMSCRIPT simulation language and based on a graphical dragging mode, overcomes the problem that the SIMSCRIPT language modeling needs to be familiar with SIMSCRIPT grammar and manually writes codes, can make the modeling process clear and intuitive, the model multiplexing is simpler, the learning cost is lower, the user group is wider, and the communication between field experts and modeling personnel is convenient.

Description

SIMSCRIPT language-oriented discrete event simulation graphical modeling method

Technical Field

The invention belongs to the technical field of simulation modeling, and particularly relates to an SIMSCRIPT-language-oriented discrete event simulation graphical modeling method.

Background

Discrete event simulation is a method for predicting system change according to the rule that events occurring in a system change at discrete time points, and is an important system simulation technology. Currently, discrete event simulation is widely used to develop large-scale simulation systems for aerospace, machine manufacturing, communication and transportation, military combat simulation, and the like. The discrete event simulation language includes both general purpose programming languages such as C, Fortran and PASCAL, and special purpose simulation languages such as GPSS and COMNET.

SIMSCRIPT is a kind of discrete event simulation modeling language with special combination, which provides a system description mechanism of "entity-attribute-set", and is very suitable for describing entities and associations in the system. Modelers can quickly focus time and effort on the most important parts of the simulation task, namely building the inter-entity interaction logic of the simulation system, defining events and determining scheduling relationships between events. Meanwhile, SIMSCRIPT provides programming abstractions of different levels, modelers can solve the calculation problem by adopting a programming mode of a general language provided by SIMSCRIPT, and can also construct a simulation model by adopting a simulation-oriented programming mode provided by SIMSCRIPT, so that flexible modeling means are provided for the modelers, and the modeling and coding efficiency is effectively improved. In addition, code written in the SIMSCRIPT language has a natural language style that is easily understood by a domain expert unfamiliar with programming, and provides a medium for the domain expert to communicate with the programmer.

Because of these advantages SIMSCRIPT have, it is being built 10⁴The method has unique advantages when the complex system simulation model of the entity with the magnitude above is used. However, no discrete event graphical modeling method facing SIMSCRIPT simulation language exists at present. When modeling SIMSCRIPT, modelers need to be familiar with SIMSCRIPT syntax to build entities, events and scheduling relationships by manually writing SIMSCRIPT code. When the interaction between the simulation entity and the event is too much, the programming is difficult and the error is easy to occur. On the other hand, a modeling worker cannot realize integral and visual cognition on the model, and the model is inconvenient to discuss and exchange.

Although chinese patent CN101303649A discloses a method and apparatus for generating a modeling language graphic representation, it does not provide a method for generating SIMSCRIPT simulation language.

SIMSCRIPT language generally requires a domain expert to abstract model a simulated system using standard UML diagrams and then manually write simulation code by a developer. In addition, the modeling field of the SIMSCRIPT language focuses on modeling of military, industry, finance and the like, is a relatively small modeling language, and is high in learning cost for familiarizing grammatical rules, so that the modeling efficiency is low.

With the development of computer graphics technology, many discrete simulation languages have graphical modeling tools at present. For example, the SIMULINK tool oriented to MATLAB language and the OPNET tool oriented to C/C + +. SIMSCRIPT, however, do not have graphical modeling tools and cannot automatically generate simulation code.

Therefore, a graphical modeling tool needs to be provided for SIMSCRIPT simulation language, a simulation program is constructed by dragging custom primitives, mapping rules of each primitive and SIMSCRIPT simulation language are defined, and model codes are automatically generated, so that a modeling worker can construct a discrete event simulation program without being familiar with specific grammatical rules of SIMSCRIPT, and modeling efficiency is greatly improved.

Disclosure of Invention

Technical problem to be solved

The invention provides an SIMSCRIPT language-oriented discrete event simulation graphical modeling method, which aims to solve the technical problem of how to build a discrete event simulation program based on a graphical dragging mode.

(II) technical scheme

In order to solve the technical problem, the invention provides an SIMSCRIPT language-oriented discrete event simulation graphical modeling method, which comprises the following steps:

step S1, initializing a project, and constructing two resource files required by the operation of the discrete modeling system, wherein the resource files comprise a global statement file and a main routine file; wherein, the global declaration file is used for declaring all global variables, and the main routine file is used for the entrance of the whole simulation application; generating a global statement file canvas and a main routine file canvas aiming at the global statement file and the main routine file;

step S2, dragging the primitive including entity, event and process into the overall declaration document canvas to realize the declaration function of the newly added primitive; editing the attribute value of each graphic element;

step S3, dragging basic primitives, logic primitives and functional primitives required to be called in the simulation process into a main routine file canvas; constructing a logical relation between basic primitives in a canvas;

step S4, jumping to the child canvas of the basic primitive in a double-click mode based on the parent-child hierarchical relation between the canvases, dragging the logic primitive to the child canvas in a dragging mode, and finishing the drawing of the child canvas;

step S5, saving the canvas in the steps S2-S4 as a project file;

step S6, carrying out rule verification on the project file;

step S7, using the grammar mapping rules, converting the generated project file into executable SIMSCRIPT code.

Further, in step S2, the entity is a component of the system and is divided into a temporary entity and a permanent entity, the temporary entity is an active part in the system and leaves the system after staying in the system for a period of time, and the permanent entity is a fixed part in the system and stays in the system permanently; an event is an action that causes a change in the state of the system; the routine is a collection of function interfaces or services provided by the system to the outside; a process is a complete process that describes the entity's experience in a system.

Further, in step S3, the primitive primitives represent syntax elements including entities, events, processes, routines and queues in the SIMSCRIPT language, each primitive has a name and attributes, and the primitive attributes include attribute names, attribute types and attribute comments; the logic primitive represents a grammar unit comprising circulation, judgment and branching in SIMSCRIPT language; the functional primitives represent syntax elements in the SIMSCRIPT language that include printing and simulation time operations.

Further, in step S3, the logical relationships among the basic primitives include a sequential relationship, a dependency relationship, and a scheduling relationship; each relation is marked by different lines and arrows, the relation between the primitives is modified or deleted by connecting anchor points between two primitives to newly increase the primitive relation and double clicking the primitive connecting line.

Further, after step S5 is executed, each canvas is stored as JSON data, the primitives in the canvas are stored in a node array, and each node includes a node ID, a node name, a node position, and a node attribute array; the primitive relationships are stored in an array of edges, each edge including a source node ID, a destination node ID and a type of the edge.

Further, in step S6, the rule check includes an attribute check and a call relationship check.

Further, in step S6, the content of attribute check includes whether different permanent entities contain the same-name attribute, whether the same entity contains the same-name attribute, and whether the permanent entity and the system contain the same-name attribute; the content of the call relation check includes whether the call relation of the routine, the event and the process is correct.

Further, in step S6, when a check error occurs, an error list is displayed.

Further, step S7 includes generating the code of the global declaration file, the code of the main routine file, and the code of the subroutine file.

Further, in step S7, the code of the global declaration file includes temporary entity declaration code, permanent entity declaration code, process declaration code, queue declaration code, and event declaration code; the code of the main routine file comprises a frame code of a main routine, a scheduling code of an event, a process and a routine, and a branch, loop and judgment statement code; the code of the subroutine file includes framework code of events, processes, routines and functions, input and output code, scheduling relationship code, branch, loop, and judgment statement code.

(III) advantageous effects

The invention provides an SIMSCRIPT language-oriented discrete event simulation graphical modeling method, which is characterized in that primitives such as entities, routines and events are added into a canvas serving as a primitive bearing container in a dragging mode according to modeling technologies such as an entity flow graph and an activity cycle graph, the interaction relation among the entities, the routines and the events is represented through connecting lines, the primitives can be drawn and managed in the canvas, the canvas can be divided into a plurality of canvases according to calling relation and hierarchical relation, all the canvases can be stored into engineering files with specific formats, and the engineering files can automatically generate SIMSCRIPT simulation codes according to mapping rules.

The invention builds a discrete event simulation program based on the SIMSCRIPT simulation language and based on a graphical dragging mode, overcomes the problem that the SIMSCRIPT language modeling needs to be familiar with SIMSCRIPT grammar and manually writes codes, can make the modeling process clear and intuitive, the model multiplexing is simpler, the learning cost is lower, the user group is wider, and the communication between field experts and modeling personnel is convenient.

Drawings

FIG. 1 is a flow chart of a graphical modeling method implementation of an embodiment of the present invention;

FIG. 2 is a process diagram for drawing a global declaration file canvas in an embodiment of the present invention;

FIG. 3 is a diagram of a process for drawing a main routine canvas in an embodiment of the present invention;

FIG. 4 is a process diagram for drawing a subroutine canvas in accordance with an embodiment of the present invention;

FIG. 5 is an example of event primitive syntax mapping rules in an embodiment of the present invention;

FIG. 6 is an example of a temporary entity primitive syntax mapping rule in an embodiment of the present invention;

FIG. 7 is a flowchart illustrating the generation of global declaration file codes in an embodiment of the present invention.

Detailed Description

In order to make the objects, contents and advantages of the present invention clearer, the following detailed description of the embodiments of the present invention will be made in conjunction with the accompanying drawings and examples.

The embodiment provides an SIMSCRIPT-language-oriented discrete event simulation graphical modeling method, which adopts a visualization module, a rule checking module and a code generation module to perform graphical modeling. The visualization module is used for adding primitives such as entities, events, routines and processes into the canvas in a dragging mode and building calling relations and subordinate relations among the primitives by adding connecting lines. The entity is a component of the system and can be divided into a temporary entity and a permanent entity, wherein the temporary entity is a movable part in the system and leaves the system after staying in the system for a period of time, and the permanent entity is a fixed part in the system and stays in the system permanently; an event is an action that causes a change in the state of the system; the routine is a collection of function interfaces or services provided by the system to the outside, and functions like functions; a process is a complete process that describes the entity's experience in a system. The rule checking module is used for setting a checking rule according to the grammar rule of SIMSCRIPT, verifying whether the model meets the specification or not and giving a prompt for conflicts and errors existing in the model. The code generation module is used for converting the project file generated by the visualization module into executable SIMSCRIPT codes through the mapping rules.

The discrete event simulation graphical modeling method of the embodiment is specifically implemented as shown in fig. 1, and specifically includes the following steps:

step S1, initializing project, the system automatically generates two resource files including a global declaration file and a main routine file, the global declaration file is where all global variables are declared in the simulation application, and the main routine file is the entry of the whole simulation application. And automatically generating canvas of the two files in the visualization module.

Step S2, using the basic primitive function in the visualization module, dragging the primitives such as entities (including temporary entities and permanent entities), events and processes from the toolbar into the canvas of the global declaration document, so as to realize the declaration function of the newly added primitives. The attribute values of the primitives such as the entity, the event, the process and the like are edited through the attribute panel, so that the attribute declaration function of the primitives is realized, and the realization process is shown in fig. 2.

Step S3, dragging the primitives to be called in the simulation process into the canvas of the main routine file, where the primitives include basic primitives such as entities, events, processes, routines, queues, etc., as well as logic primitives such as loops, judgments, branches, etc., and functional primitives such as printing, simulation time operations, etc., and then constructing the sequence, calling and dependency relationships among the primitives in the canvas, and the implementation process is as shown in fig. 3.

And step S4, jumping to the sub canvas of the primitives such as events, routines, processes and the like in a double-click mode based on the parent-child hierarchical relationship among the canvases. And dragging the logic primitives such as circulation, judgment, branching and the like into the sub-canvas in a dragging mode to finish the drawing of the sub-canvas, wherein the implementation process is as shown in fig. 4.

Step S5, the visualization module saves the canvas in steps S2-S4 as a project file.

And S6, using a rule checking module to check the rules of the project files in the step S5. The method specifically comprises the following steps: and checking the attribute and the calling relation. The content of attribute check includes whether different permanent entities contain homonym attributes, whether the same entity contains homonym attributes, and whether the permanent entities and the system contain homonym attributes. The call relation check content includes whether the call relation of the routine, the event and the process is correct or not, and the checked conflict list is fed back to the user.

And step S7, converting the project file generated in the visualization module into executable SIMSCRIPT codes by using grammar mapping rules in the code generation module.

In this embodiment, the functions of the visualization module specifically include:

1. canvas generation function: after the project is initialized, a global declaration file and a main routine file are automatically generated, the global declaration file and the main routine file are automatically mapped to a declaration canvas and a main canvas, and a sub canvas is created as required.

2. And (3) primitive editing function: primitives can be classified into three categories, basic, logical, and functional. The base primitives represent SIMSCRIPT syntactic elements such as entities, events, processes, routines, and queues in the language. Each primitive has a name and attributes, including an attribute name, an attribute type, and an attribute annotation. The logical primitives represent syntax elements such as loops, judgments and branches in the SIMSCRIPT language. The functional primitives represent syntax elements in the SIMSCRIPT language, such as printing, simulation time operations, etc. And the primitive addition function can be realized by dragging the primitive from the toolbar to the canvas.

3. And a primitive relation editing function: the relationships among the primitives include a sequential relationship, a dependency relationship and a scheduling relationship, for example, different routines are called sequentially to form the sequential relationship, entities are subordinate to a certain queue to form the dependency relationship, and calling events in the routines belong to the scheduling relationship. Each relation is marked by different lines and arrows, and a user can newly add a primitive relation by connecting anchor points between two primitives. The relationship between the primitives can be modified or deleted by double-clicking the primitive connecting line.

4. Model canvas saving function: each canvas can be stored as JSON data, primitives in the canvas are stored in a node array, and each node comprises a node ID, a node name, a node position and a node attribute array. The primitive relationships are stored in an array of edges, each edge including a source node ID, a destination node ID and a type of the edge. After the global declaration canvas is saved, the JSON data of declarations of syntax units such as entities, events, processes, routines and queues is generated and used for generating a global declaration file. After the main routine canvas is saved, JSON data defined by the main routine is generated and used for generating a main routine file. After the subroutine canvas is saved, JSON data of definitions of syntax units such as events, processes and routines is generated and used for generating a subroutine file.

In this embodiment, the function of the rule checking module specifically includes:

1. and a primitive attribute checking function: for example, a permanent entity is not allowed to have homonymic attributes, primitives are not redefined, etc. Once a verification error occurs, an error list is displayed.

2. And (3) calling a relation checking function by the primitive: for example, two primitives cannot have two relationships at the same time; events can only be scheduled, routines can only be called, etc. And displaying an error list once the verification of the primitive relation is wrong.

In this embodiment, the functions of the code generation module specifically include:

1. code generation function of global declaration document: the code of the global declaration file includes temporary entity declaration code, permanent entity declaration code, process declaration code, queue declaration code, event declaration code, and the like. The declaration of each variable has mapping rules, the grammar mapping rules of events and temporary entities are respectively shown in fig. 5 and 6, and the generation process of the global declaration file code is shown in fig. 7.

2. Code generation function of main routine program file: the code of the main routine file includes framework code of the main routine, scheduling code of events, processes and routines, and branch, loop, and predicate statement code.

3. Code generation function of subroutine file: the code of the subroutine file includes framework code of events, processes, routines and functions, input and output code, scheduling relationship code, branch, loop, judgment statement code, and the like.

Compared with the prior art, the technical scheme provided by the invention is based on SIMSCRIPT language, the process of SIMSCRIPT language graphical modeling method is realized, a user does not need to pay more attention to simulation language, the main attention can be focused on the model, the modeling steps are simplified, the system complexity and the development cost are reduced, the intuitiveness of the model is increased, and the communication is convenient.

The above description is only a preferred embodiment of the present invention, and it should be noted that, for those skilled in the art, several modifications and variations can be made without departing from the technical principle of the present invention, and these modifications and variations should also be regarded as the protection scope of the present invention.

Claims

1. A graphical modeling method for discrete event simulation facing to SIMSCRIPT language is characterized in that the modeling method comprises the following steps:

step S1, initializing a project, and constructing two resource files required by the operation of a discrete modeling system, wherein the resource files comprise a global statement file and a main routine file; wherein the global declaration file is used for declaring all global variables, and the main routine file is used for the entry of the whole simulation application; generating a global declaration file canvas and a main routine file canvas aiming at the global declaration file and the main routine file;

step S5, saving the canvas in the steps S2-S4 as a project file;

step S6, carrying out rule verification on the project file;

2. The modeling method of claim 1, wherein in step S2, the entity is a component of the system, and is divided into a temporary entity and a permanent entity, wherein the temporary entity is an active part of the system and leaves the system after staying in the system for a period of time, and the permanent entity is a fixed part of the system and stays in the system permanently; an event is an action that causes a change in the state of the system; the routine is a collection of function interfaces or services provided by the system to the outside; a process is a complete process that describes the entity's experience in a system.

3. The modeling method of claim 1, wherein in step S3, the primitive primitives represent syntax elements including entities, events, processes, routines and queues in the SIMSCRIPT language, each primitive having a name and attributes including attribute names, attribute types and attribute comments; the logic primitive represents a grammar unit comprising circulation, judgment and branching in SIMSCRIPT language; the functional primitives represent syntax elements in SIMSCRIPT language including printing and simulation time operations.

4. The modeling method according to claim 1, wherein in step S3, the logical relationships among the primitive primitives include an order relationship, an affiliation relationship, and a scheduling relationship; each relation is marked by different lines and arrows, the relation between the primitives is modified or deleted by connecting anchor points between two primitives to newly increase the primitive relation and double clicking the primitive connecting line.

5. The modeling method of claim 1, wherein after step S5, each canvas stores as JSON data, primitives in the canvas are stored in a node array, and each node contains a node ID, a node name, a node location, and a node attribute array; the primitive relationships are stored in an array of edges, each edge including a source node ID, a destination node ID and a type of the edge.

6. The modeling method of claim 1, wherein in step S6, the rule check includes an attribute check and a call relationship check.

7. The modeling method of claim 6, wherein in step S6, the content of attribute check includes whether different permanent entities contain homonym attributes, whether the same entity contains homonym attributes, and whether the permanent entities and the system contain homonym attributes; the content of the call relation check includes whether the call relation of the routine, the event and the process is correct.

8. The modeling method of claim 6, wherein in step S6, when a check error occurs, an error list is displayed.

9. The modeling method of claim 1, wherein the step S7 includes generating a code of the global declaration file, a code of the main routine file, and a code of the subroutine file.

10. The modeling method according to claim 9, wherein in step S7, the code of the global declaration document includes temporary entity declaration code, permanent entity declaration code, process declaration code, queue declaration code, event declaration code; the code of the main routine file comprises a frame code of a main routine, a scheduling code of an event, a process and a routine, and a branch, loop and judgment statement code; the code of the subroutine file comprises frame codes of events, processes, routines and functions, input and output codes, scheduling relation codes, branches, loops and judgment statement codes.