JP2008243042A - Simulation device, method, and program for hybrid model - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To extract necessary information without imposing any load on simulation execution, and to intuitively grasp the behavior of a hybrid model program during simulation execution. <P>SOLUTION: A simulation device is provided with a simulation part for executing simulation by using a hybrid model having the description of continuous system equation and description related with the switching of the continuous equation accompanied with state transition; a map generation means for generating a map in which the ID of the continuous system equation and the description line of the continuous system equation are associated with each other by analyzing the hybrid model; and an information generation means for generating information showing whether the continuous system equation having the ID is valid or invalid in each simulation time in executing simulation, wherein the map and the information are presented for the verification of the hybrid model. <P>COPYRIGHT: (C)2009,JPO&INPIT

Description

  The present invention relates to a hybrid model simulation apparatus, method, and program for performing hybrid model verification for visualizing operations inside the hybrid model.

  Currently, a technique called hybrid modeling is used when simulating the behavior of a machine or plant using a computer. The simulation using the hybrid model is called “hybrid simulation”. A system having such a simulation behavior is sometimes called a “hybrid system”.

  The hybrid model created for the purpose of simulation is conceptually a continuous system model that is expressed by simultaneous equations that are a combination of ordinary differential equations and algebraic equations, and a state transition model for expressing state transitions associated with event occurrences. It is a model that combines. According to the hybrid model, it is possible to express a system in which the state expressed by the continuous system model is instantaneously switched by an event from the outside.

  The source file of the hybrid model is text data composed of a character string of at least one line described with a mixture of a continuous system description and a discrete system description.

(Prior art 1)
As a DCML (Dynamics Constraint Modeling Language) compiler used in a hybrid system, for example, the one described in Patent Document 1 is known.

  The conventional DCML compiler is required to solve the following problems. That is, in the process of converting the hybrid model program into the model equation registration program and the event processing program, the correspondence relationship such as which line in the hybrid model the model equation and event processing indicate is lost. Therefore, in the process of executing the simulation, it is impossible to grasp in which order the hybrid model is executed.

Therefore, in order to confirm that the hybrid model describing the behavior of motors and sensors works correctly,
(1) Look at the simulation result log and compare the expected value with the result.
(2) The compiler determines whether the model complies with the model description rules.
(3) The hybrid model program (parallel program) is converted into a sequential program (C language program) and its operation is dynamically confirmed.

  However, with this method, it is difficult to intuitively understand the behavior of the hybrid model program during simulation execution, and it takes time to create the hybrid model program.

(Prior art 2) (HCC interpreter)
The prototype of the hybrid model language is HCC (Hybrid Concurrent Constraint Programming) language developed at the Xerox Palo Alto Research Institute. The HCC language has a debugger function that displays internal variable states and the like while sequentially interpreting with an interpreter. The debugger possessed by the HCC language is mounted inside the interpreter and can be executed while analyzing the hybrid model. Moreover, the variable information inside the interpreter can be output as standard, and the state inside the hybrid model can be visualized relatively easily.

  The conventional HCC interpreter has the following problems. That is, when the simulation is performed after the hybrid model program is converted into the model equation program and the event processing program, the correspondence between the object code and the source code of the hybrid model cannot be known in the process of being converted into the object code. There is a problem.

(Conventional technology 3) (Integrated development environment)
Integrated development environments for developing programs that can operate on personal computers and embedded processors, such as Eclipse (see, for example, Non-Patent Document 1) and Visual Studio (product of Microsoft (registered trademark)), are provided. This integrated development environment includes an editor and a compiler that display source code, and can convert the source code into object code that can be executed on a processor on a personal computer.

  The integrated development environment also includes a debugger, which allows the compiler to add additional information about debugging to the object code and perform a step execution function that executes the source code line by line by user keyboard input or mouse operation. It is.

  During step execution, the number of lines of source code corresponding to the current program valid step can be displayed as a flag. The debugger has a built-in function to emulate the operation of the processor, and manages the function corresponding to the program counter that manages the machine language instruction to be executed next by the processor and the correspondence between the machine language instruction and the source code. The number of lines of the source code being executed can be displayed using a GUI (Graphical User Interface).

  However, the conventional integrated development environment performs a debugger process for debugging a sequential program. In other words, the conventional debugger configuration that simulates the internal operation of the processor cannot be used when a plurality of lines are valid at the same time as in the continuous model of the hybrid model program. In addition, a debugger used in an integrated development environment that develops a program that can run on a conventional personal computer or embedded processor does not have a means for inputting the simulation time, and the hybrid model at that time is set by setting the simulation time. Of course, it is not possible to visualize the operating state of.

(Prior art 4)
Examples of an integrated development environment for debugging a non-sequential program (Verilog-HDL language or VHDL language) while performing simulation include ModelSim (registered trademark) and Mentor Graphics.
JP 2004-178300 A Internet URL <www.eclipse.org>

  It is an object of the present invention to extract necessary information without imposing a heavy load on simulation execution and to intuitively understand the behavior of a hybrid model program during simulation execution.

  A simulation apparatus according to an aspect of the present invention includes a simulation unit that executes a simulation using a hybrid model having a description of a continuous system equation and a description related to switching of the continuous system equation accompanying state transition, and the hybrid model By analyzing, a map generating means for generating a map for associating the ID of the continuous system equation and the description line of the continuous system equation, and the continuous system equation having the ID at each simulation time at the time of execution of the simulation. Information generating means for generating information indicating whether the map is valid or invalid, and the map and the information are used for verification of the hybrid model.

  According to the present invention, necessary information can be extracted without imposing a heavy load on the simulation execution, and the behavior of the hybrid model program during the simulation execution can be intuitively grasped.

(First embodiment)
FIG. 1 is a block diagram showing a simulation apparatus common to the first to third embodiments. The simulation apparatus 2000 includes a simulation unit 2014 and an equation switching history display unit 5000. The simulation unit 2014 includes a control information analysis unit 2002, an event processing unit 2006, an equation analysis unit 2005, a continuous system equation switching unit 2010, and a continuous simulation unit 2008. This embodiment can be configured using a general computer, and includes a CPU, a memory, an external storage device, a communication interface, a display device, a keyboard, a mouse, and the like as a hardware configuration. An operating system for controlling these hardware is provided. The simulation apparatus according to the present embodiment can be implemented as application software that operates on such an operating system.

  The control information analysis unit 2002 separates the description of the continuous system equation and the description of the control information of the state transition accompanying the event from the hybrid model program 2001. Next, from the description of the control information of the state transition accompanying the event, the conditional expression and the ID (identifier) of the continuous system equation that is established when the conditional expression is satisfied, and the ID of the continuous system equation that becomes invalid according to this are related. Create a table. Information based on this table is stored as an event processing program 2003.

  In addition, the control information analysis unit 2002 creates a table in which the ID of the continuous system equation and the file name and directory name of the hybrid model program 2001 in which the continuous system equation is described are associated with the hybrid model program line number corresponding to the continuous system equation. To do. A map file 2011 is obtained by outputting the information represented by this table as a file to an external storage device. Further, the control information analysis unit 2002 stores information indicating the relationship between the continuous system equation (object) and the ID as a continuous system equation valid / invalid information file 2012 in the external storage device.

  Next, preprocessing of the hybrid model program will be described in detail.

  The hybrid model program 2001 is first processed in the control information analysis unit 2002 to generate a model equation registration program 2004, an event processing program 2003, and a simulation execution additional processing program (not shown).

  As a software module constituting the hybrid model simulation apparatus, a function for registering model equations and a function for switching continuous system equations are provided as API functions. The model equation registration program 2004 and the event processing program 2003 are programs in which descriptions for calling the corresponding API functions are appropriately combined in accordance with the input hybrid model program 2001. From this point of view, the control information analysis unit 2002 is considered as a kind of compiler in which the input is a hybrid model program 2001 and the output is a C program (source) including, for example, a C language API function call description. You can also. The model equation registration program 2004 and the event processing program 2003 are further compiled by a compiler such as C language, and a library that can be dynamically linked at the time of execution is generated. In the hybrid model simulation apparatus, when the simulation is executed, the generated dynamic link library is linked, and a simulation program that faithfully reproduces the input hybrid model is completed and can be executed. Note that these generated libraries are not necessarily dynamic link libraries, and may be static libraries.

  Various specifications of the specific software module constituting the application interface of the hybrid model simulation apparatus can be considered. Here, for convenience of explanation, it is assumed that the following three API functions are defined at the minimum. The programming language is C language.

int XXX_AddEqnData (char * eqn, int * err)
int XXX_ActivateEqn (int eqnid)
int XXX_DeActivateEqn (int eqnid)
The first API function XXX_AddEqnData designates a character string pointer representing one continuous system equation as an argument. XXX_AddEqnData parses the continuous system equation, converts the description of the continuous system equation into a data structure (internal data representation) that can be simulated, and registers the internal data representation in the equation data storage unit 2007. A unique ID number is assigned to the continuous system equation. For example, assuming that an expression “ab / cos (a− (c + b)) − 3c” is given, an internal data representation of a tree structure is generated. This tree structure includes, for example, a parent node (clause) of a linear polynomial, a node of multiplication, a node of division, a node of an external function (meaning other than four arithmetic operations), and a node of each term constituting the linear polynomial. In this example, all the leaves corresponding to the leaves of the tree structure are variables (a, b, c), and a real number coefficient is added to these to form a linear form. The line format becomes an argument of an external function such as cos, and is subject to multiplication or division. The variable is separately provided with a flag indicating whether or not the value is fixed, and the current value of the variable is held based on such tree-structured data. If the values of all the leaves of the tree structure (ie, the values of the variables) are fixed, the value of the expression can be calculated. In the equation data storage unit 2007, the internal data structure is connected in advance so that the value of the equation can be calculated at high speed. If any error occurs in the above process, an error code is set in err. When the process is normally completed, the ID number of the registered equation is used as a return value.

  The second API function XXX_ActivateEqn validates the equation corresponding to the ID number of the equation specified as the argument. If an already valid equation is specified, nothing is done. The return value is an error code.

  In contrast to XXX_ActivateEqn, the third API function XXX_DeActivateEqn invalidates the equation corresponding to the ID number of the equation specified as the argument. Does nothing if an invalid equation is specified.

  The control information analysis unit 2002 first generates a function (InitEqnData) that sequentially calls XXX_AddEqnData for a necessary equation. This corresponds to the model equation registration program 2004 (first program).

  In addition, the control information analysis unit 2002 also generates a function (ChangeEqn) that performs condition checking and equation switching every time the time advances by Δt during simulation execution. This corresponds to the event processing program 2003 (second program).

By the processing in the control information analysis unit 2002 as described above, for example, the hybrid model program 2001 as shown in FIG. 5 uses the variable names “motor1” of L21 as prefixes of the variables a, b, and x of L07-L09 and L15-17, respectively. . ”, L22 variable name“ motor2. ”, L21's first argument 2 to a0, second argument 0.1 to“ b0 ”, L22's first argument 2 to“ a0 ” , By replacing the second argument 0.1 with “b0”,
motor1.a = 2,
motor1.b = 0.1,
motor1.x = 0,
motor1.x '= 0,
always motor1.a '= 0,
always motor1.b '= 0,
always motor1.x '' = motor1.b * (motor1.a- motor1.x '),
motor2.a = 2,
motor2.b = 0.1,
motor2.x = 0,
motor2.x '= 0,
always motor2.a '= 0,
always motor2.b '= 0,
always motor2.x '' = motor2.b * (motor2.a-motor2.x ')
Then, the text conversion is performed and the following C language source program is automatically generated.

static char eqn1 [] = "motor1.a = 2";
static char eqn2 [] = "motor1.b = 0.1";
static char eqn3 [] = "motor1.x = 0";
static char eqn4 [] = "motor1.x '= 0";
static char eqn5 [] = "motor1.a '= 0";
static char eqn6 [] = "motor1.b '= 0";
static char eqn7 [] = "motor1.x '' = motor1.b * (motor1.a- motor1.x ')";
static char eqn8 [] = "motor2.a = 2";
static char eqn9 [] = "motor2.b = 0.1";
static char eqn10 [] = "motor2.x = 0";
static char eqn11 [] = "motor2.x '= 0";
static char eqn12 [] = "motor2.a '= 0";
static char eqn13 [] = "motor2.b '= 0";
static char eqn14 [] = "motor2.x" = motor2.b * (motor2.a-motor2.x ') ";
static int eqn1id;
static int eqn2id;
static int eqn3id;
static int eqn4id;
static int eqn5id;
static int eqn6id;
static int eqn7id;
static int eqn8id;
static int eqn9id;
static int eqn10id;
static int eqn11id;
static int eqn12id;
static int eqn13id;
static int eqn14id;
int InitEqnData ()
{
int err;
eqn1id = XXX_AddEqnData (eqn1, &err);
if (err! = 0) return err;
eqn2id = XXX_AddEqnData (eqn2, &err);
if (err! = 0) return err;
eqn3id = XXX_AddEqnData (eqn3, &err);
if (err! = 0) return err;
eqn4id = XXX_AddEqnData (eqn4, &err);
if (err! = 0) return err;
eqn5id = XXX_AddEqnData (eqn5, &err);
if (err! = 0) return err;
eqn6id = XXX_AddEqnData (eqn6, &err);
if (err! = 0) return err;
eqn7id = XXX_AddEqnData (eqn7, &err);
if (err! = 0) return err;
eqn8id = XXX_AddEqnData (eqn8, &err);
if (err! = 0) return err;
eqn9id = XXX_AddEqnData (eqn9, &err);
if (err! = 0) return err;
eqn10id = XXX_AddEqnData (eqn10, &err);
if (err! = 0) return err;
eqn11id = XXX_AddEqnData (eqn11, &err);
if (err! = 0) return err;
eqn12id = XXX_AddEqnData (eqn12, &err);
if (err! = 0) return err;
eqn13id = XXX_AddEqnData (eqn13, &err);
if (err! = 0) return err;
eqn14id = XXX_AddEqnData (eqn14, &err);
if (err! = 0) return err;
}
int ChangeEqn ()
{
int err;
if (getCurrentTime () == 0) {
XXX_ActivateEqn (eqn1id);
XXX_ActivateEqn (eqn2id);
XXX_ActivateEqn (eqn3id);
XXX_ActivateEqn (eqn4id);
XXX_ActivateEqn (eqn8id);
XXX_ActivateEqn (eqn9id);
XXX_ActivateEqn (eqn10id);
XXX_ActivateEqn (eqn11id);
} else {
XXX_DeActivateEqn (eqn1id);
XXX_DeActivateEqn (eqn2id);
XXX_DeActivateEqn (eqn3id);
XXX_DeActivateEqn (eqn4id);
XXX_DeActivateEqn (eqn8id);
XXX_DeActivateEqn (eqn9id);
XXX_DeActivateEqn (eqn10id);
XXX_DeActivateEqn (eqn11id);
}
XXX_ActivateEqn (eqn5id);
XXX_ActivateEqn (eqn6id);
XXX_ActivateEqn (eqn7id);
XXX_ActivateEqn (eqn12id);
XXX_ActivateEqn (eqn13id);
XXX_ActivateEqn (eqn14id);
}
The getCurretnTime () function is an API that acquires the current simulation time.

  The above programs are compiled by a C language compiler as described above, further arranged in the form of a dynamic link library, and linked at the time of execution.

  In this embodiment, an example in which the C language is used as the programming language has been described. However, the present invention is not limited to this, and other programming languages such as a C ++ language and a SpecC language may be used. .

  When executing the simulation, the continuous system equation switching unit 2010 periodically evaluates the conditional expression in the event processing program 2003, and when the conditional expression is satisfied, enables or disables the continuous system equation for the corresponding continuous system equation ID. API (Application Program Interface) function is called. At each simulation time, an API function for determining whether the corresponding continuous system equation is validated or invalidated for all the registered continuous system equations ID is called, and the determination information is obtained to perform simulation. The continuous system equation valid / invalid information file 2012 is saved in the external storage device in combination with the time.

  FIG. 2 is a block diagram showing the equation switching history display unit 5000. The equation switching history display unit 5000 includes a display time input device 1100, a continuous system equation valid row processing device 5001, a description data display device 5002, and a continuous system equation valid row display device.

  The display time input device 1100 reads the minimum and maximum values of the simulation time from the continuous system equation valid / invalid information file 2012. The display time input device 1100 has a graphical user interface (GUI) screen, and can select an arbitrary simulation time within the minimum and maximum values of the simulation time that can be set. The input simulation time information is sent to the continuous system equation effective row processing device 5001.

  The continuous system equation valid row processing device 5001 reads the continuous system equation valid / invalid information file 2012 and the map file 2011 from the external storage device. From the continuous system equation valid / invalid information file 2012, the ID of all continuous system equations at the input simulation time and the valid / invalid determination information thereof are read. The ID of a valid continuous system equation can be obtained by using the map file 2011 to obtain the corresponding file name, directory name, and line number.

  The description data display device 5002 reads the hybrid model program 2001 and displays the data description on a graphical user interface (GUI) screen. The description data display device 5002 manages the line number of the data description and the position information of the screen on which the line is displayed. The continuous system equation valid line display device 5004 corresponds to the line number of the effective continuous system equation from the description data display device 5002 when the file name and directory name of the hybrid model program 2001 specified by the description data display device 5002 match. The position information of the screen to be acquired is acquired, and a flag is displayed at a position adjacent to the position of the screen corresponding to the line number of the continuous system equation in the GUI screen of the continuous system equation valid line display device 5004.

  FIG. 3 is a flowchart showing an operation procedure of the simulation unit 2014 common to the first to third embodiments, FIG. 4 is a flowchart showing an operation procedure of the equation history display unit 5000 according to the first embodiment, and FIG. It is a figure which shows an example of the hybrid model program 2001 called by the information analysis part 2002. FIG.

  As shown in FIG. 3, first, the control information analysis unit 2002 inputs the hybrid model program 2001 and performs syntax analysis (step 3001). The control information analysis unit 2002 generates an event processing program 2003 and a model equation registration program 2004 from the syntax analysis result of the hybrid model program 2001. As software modules constituting the simulation unit 2014, a function for registering model equations and a function for switching continuous system equations are provided as API (Application Program Interface) functions. The event processing program 2003 and the model equation registration program 2004 are programs in which descriptions for calling the corresponding API functions are appropriately combined in accordance with the input hybrid model program 2001. The event processing program 2003 and the model equation registration program 2004 are compiled by a compiler such as C language, and for example, a library that can be dynamically linked at the time of execution is generated.

  When the simulation is executed, the simulation 2014 unit links the generated dynamic link library, thereby completing and executing a simulation program that faithfully reproduces the input hybrid model. At the time of execution, an API function for starting the equation analysis unit 2005 is first called, and then a continuous system switching API function group is executed to perform a simulation.

  The event processing program 2003 generates a function (ChangeEqn) that performs a condition check and equation change (replacement) every time the time advances by Δt during simulation execution. The model equation registration program 2004 is based on the syntax analysis result of the description of the continuous system equation, converts the description into a data structure that can be simulated, and registers it in the equation data storage unit 2007 (step 3002).

  Next, the control information analysis unit 2002 generates the map file 2011 as described above (step 3003), and generates the continuous system equation valid / invalid information file 2012 (step 3004). The map file 2011 and the continuous system equation valid / invalid information file 2012 are stored in an external storage device.

  In the simulation execution stage, a control signal received from a mechanism control software simulator (not shown) is received (step 3005). Here, if necessary, a value based on the received control signal is appropriately substituted into a variable. Next, it is determined in step 3006 whether or not a state change is necessary. When the state change is necessary, the continuous system equation switching unit 2010 switches the continuous system equation by operating the valid / invalid flag for the corresponding continuous system equation (step 3007). In this case, the continuous system equation switching unit 2010 also adds information to the continuous system equation valid / invalid information file 2012 (step 3008).

  Next, the continuous system simulation unit 2008 performs numerical integration (step 3009).

  Then, after the end determination is made in step 3010, the simulation time is advanced by one step until a predetermined end condition is satisfied (step 3011), and the simulation is executed by repeating the processing procedure after step 3005.

  As shown in FIG. 4, the equation history display unit 5000 according to the first embodiment first reads the map file 2011 and the continuous system equation valid / invalid information file 2012 from the external storage device (steps 4001 and 4002). Next, the flag display time is input (step 4003). Next, the effective line number at the input flag display time is acquired (step 4004), and the corresponding effective line number and its flag are displayed (step 4005).

  As shown in FIG. 5, in L01 to L20, the description of the continuous system equation and the description of the control information of the state transition accompanying the event are declared as a type (class). L21 and L22 declare an entity of this type. L07-L09 and L15-17 are types of information corresponding to the description of the continuous system. L13 is information of a type based on the description of control information of state transition accompanying an event, and represents that the condition is valid at all simulation times. L07-L09 are valid only once when the type is instantiated, and are valid only when the simulation time is zero.

  FIG. 6 is a diagram showing an example of the continuous system equation valid / invalid information file 2012 generated by executing the simulation of the hybrid model program 2001 of FIG. L01-L14 stores information indicating the relationship between the ID of the continuous system equation and the continuous system equation. In L16-L37, information indicating validity / invalidity of the continuous system equation of each ID is stored for each simulation time. The numerical value N of L16 indicates the ID of the continuous system equation separated by a space. The third to seventh characters in each column of L17-L37 indicate the simulation time T. The letter “o” or “-” is entered in the part that matches the number of characters in the ID number of L16, and the letter “o” is invalid if the corresponding continuous equation is valid, and “-” is invalid. It shows that.

  FIG. 7 is a diagram illustrating an example of the map file 2011. The map file records the ID numbers of all continuous system equations and the file names, directory names, and line numbers of the corresponding hybrid model programs. Here, the numerical value from “id:” to the space is the ID of the continuous system equation. After "->", the parentheses are directory names and file names, and the numbers in parentheses are line numbers.

  FIG. 8 is a diagram illustrating a screen example of the display time input device 1100 according to the first embodiment. The display time input device 1100 includes a simulation time setting unit 1103 and a simulation time determination button 1105. The simulation time setting unit 1103 includes a minimum simulation time display 1101, a maximum simulation time display 1102, and a simulation time input slider 1104. The slider 1104 can no longer be moved beyond the simulation minimum time or the simulation maximum time, and the simulation time is prevented from being set erroneously outside the range in which the simulation is executed.

  When the simulation time determination button 1105 is pressed, the display time input device 1100 calculates the simulation time from the position of the simulation time input slider 1104 and the simulation time minimum value and maximum value, and displays the simulation time on the continuous system equation valid line display device 5004. Pass the time. If the simulation time calculated at this time is smaller than the simulation resolution, the simulation resolution can be calculated from the continuous system equation valid / invalid information file 2012 and the simulation time approximated to the simulation resolution can be passed.

  FIG. 9 is a diagram illustrating a screen configuration of the equation history display unit 5000 according to the first embodiment. Here, the display time input device 1200 is not shown. The screen of the equation history display unit 5000 includes a description data view 1402 that is a GUI screen of the description data display device 5002, a continuous system equation valid row view 1403 that is a GUI screen of the continuous system equation valid row display device 5004, and a continuous system equation valid. The row view 1403 includes a continuous system equation valid row flag 1404 which is a diagram showing a valid row of a continuous system equation.

  According to the first embodiment described above, necessary information can be extracted without imposing a heavy load on the simulation execution, and the behavior of the hybrid model program during the simulation execution can be intuitively grasped.

(Second Embodiment)
In the second embodiment, a flag display time determination process is added to the display processing procedure shown in FIG.

  FIG. 10 is a flowchart showing an operation procedure of the equation history display unit 5000 according to the second embodiment. First, the map file 2011 is read from the external storage device (step 4001). Next, the continuous system equation valid / invalid information file 2012 is read from the external storage device (step 4002). Next, the simulation time to be displayed is input (step 4003). The simulation start time is compared with the simulation start time acquired from the continuous system equation valid / invalid information file 2012. If the simulation time is within the start end time, the process returns to step 4005. If not, the process returns to step 4003. At this time, as shown in FIG. 13, it is possible to display a screen for warning that an illegal input has been made.

  FIG. 11 is a block diagram illustrating an equation switching history display unit 5000 according to the second embodiment. A simulation time determination device 5003 is added to the configuration shown in FIG.

  FIG. 12 is a diagram illustrating an example of a display time input device 1100 according to the second embodiment. The display time input device 1100 includes a simulation time input screen 1201 and a simulation time determination button 1105. The simulation time input screen 1201 allows a simulation time to be numerically input directly from an input device such as a keyboard. FIG. 13 shows an example of error display in the simulation time setting input.

  According to the second embodiment described above, the simulation time can be directly designated by a numerical value, so that an accurate simulation time can be set.

(Third embodiment)
In the third embodiment, flags are superimposed and displayed by a continuous system equation effective row display device.

  FIG. 14 is a diagram illustrating a screen configuration of the equation history display unit 5000 according to the third embodiment. Here, the display time input device 1200 is omitted. The screen of the equation history display unit 5000 includes a description data view 1502 that is a GUI screen of the description data display device 5002, a continuous system equation valid row view 1503 that is a GUI screen of the continuous system equation valid row display device 5004, and a continuous system equation. The effective row view 1503 includes a continuous system equation effective row flag 1504 which is a diagram showing an effective row of a continuous system equation. In the third embodiment, when a plurality of flags are enabled with the same number of lines, the display screen positions of the flags are shifted and displayed. As a result, even when a plurality of flags are enabled with the same number of lines, it is possible to display in an easy-to-understand manner.

  Note that the present invention is not limited to the above-described embodiment as it is, and can be embodied by modifying the constituent elements without departing from the scope of the invention in the implementation stage. In addition, various inventions can be formed by appropriately combining a plurality of components disclosed in the embodiment. For example, some components may be deleted from all the components shown in the embodiment. Furthermore, constituent elements over different embodiments may be appropriately combined.

The block diagram which shows the simulation apparatus common to 1st thru | or 3rd embodiment. Block diagram showing equation switching history display The flowchart which shows the operation | movement procedure of the simulation part common to 1st thru | or 3rd embodiment. The flowchart which shows the operation | movement procedure of the equation log | history display part which concerns on 1st Embodiment. Diagram showing an example of a hybrid model program called by the control information analysis unit The figure which shows an example of the continuous system equation valid / invalid information file produced | generated by performing the simulation of the hybrid model program of FIG. Figure showing an example of a map file The figure which shows the example of a screen of the display time input device which concerns on 1st Embodiment. The figure showing the screen composition of the equation history display part concerning a 1st embodiment. The flowchart which shows the operation | movement procedure of the equation log | history display part which concerns on 2nd Embodiment. The block diagram which shows the equation switching log | history display part which concerns on 2nd Embodiment. The figure which shows an example of the display time input device which concerns on 1st Embodiment. The figure which shows an example of the error display by a display time input device The figure showing the screen composition of the equation history display part concerning a 3rd embodiment.

Explanation of symbols

2000: Simulation device;
2014 ... simulation part;
5000: Equation switching history display section;
2001 ... Hybrid model program;
2002 ... control information analysis unit;
2003 ... Event processing program;
2004 ... Model equation registration program;
2005 ... Equation analysis section;
2006 ... Event processing unit;
2007 ... equation data storage unit;
2008 ... Continuous system simulation section;
2009 ... variable value time history storage unit;
2010 ... Continuous equation switching unit;
2011 ... Map file;
2012 ... Continuous system equation valid / invalid information file

Claims (7)

A simulation unit that executes a simulation using a hybrid model having a description of a continuous system equation and a description related to switching of the continuous system equation accompanying state transition;
Analyzing the hybrid model to generate a map that associates the ID of the continuous system equation with the description line of the continuous system equation;
Information generation means for generating information indicating whether the continuous system equation having the ID is valid or invalid at each simulation time at the time of execution of the simulation;
A simulation apparatus characterized in that the map and the information are used for verification of the hybrid model. The simulation unit
First program generation means for generating a model equation registration program based on the description of the continuous system equation;
Second program generation means for generating an event processing program based on a description related to switching of continuous system equations accompanying the state transition;
By executing the model equation registration program, conversion means for converting the continuous system equations into a data structure that can be simulated,
By executing the event processing program, switching means for switching the validity / invalidity of the continuous equation according to the occurrence of an event,
The simulation is executed by solving the continuous system equation by numerical integration along a time axis using the data structure corresponding to the continuous system equation validated by the switching means. Item 2. The simulation device according to Item 1. An input means for inputting a simulation time;
Means for obtaining an ID of a continuous system equation effective at the simulation time inputted by the input means from the information, and obtaining a description line of the continuous system equation corresponding to the ID of the continuous system equation from the map;
The simulation apparatus according to claim 1, further comprising: a display unit that displays a flag indicating that the continuous system equation is valid at a position corresponding to the description line.   The simulation apparatus according to claim 3, wherein the input unit includes a slide bar capable of designating an arbitrary simulation time between a minimum value and a maximum value of the simulation time in the execution of the simulation.   The simulation apparatus according to claim 3, wherein the input unit includes a unit for inputting a numerical value of a simulation time. A step of executing a simulation using a hybrid model having a description of a continuous system equation and a description related to switching of the continuous system equation accompanying a state transition;
An information analysis unit analyzing the hybrid model to generate a map that associates the ID of the continuous system equation with the description line of the continuous system equation;
A step of generating a continuous system equation switching unit that indicates whether the continuous system equation having the ID is valid or invalid at the time of simulation by the simulation unit. A simulation method characterized by the above. A simulation procedure for executing a simulation using a hybrid model having a description of a continuous system equation and a description of switching of the continuous system equation accompanying state transition;
A map generation procedure for generating a map that associates the ID of the continuous system equation and the description line of the continuous system equation by analyzing the hybrid model;
The program for making a computer perform the information generation procedure which produces | generates the information which shows whether the continuous system equation which has the said ID is effective or ineffective for every simulation time at the time of execution of the said simulation.

Images