JP5091520B2 - Hybrid model simulation device - Google Patents

Description

  The present invention relates to a simulation apparatus for visualizing a hybrid model simulation result.

  The hybrid model used for mechanism simulations is a combination of a continuous system model expressed by simultaneous equations in which ordinary differential equations and algebraic equations are combined, and a state transition model (discrete system model) expressing the internal state of the system. It is a thing. The hybrid model data is managed as text data composed of a character string of at least one line in which the description of the continuous system model and the description of the state transition model are mixed (see “Patent Document 1” below). See).

In such a simulation apparatus using a hybrid model, in order to be able to intuitively grasp the time change of the hybrid model variable, the simulation result is displayed by a time change history graph including a time axis and a value axis. (For example, see “Patent Document 2” below.)
JP 2003-271679 A JP 2004-178300 A

  In the simulation result display using the time change history graph, there is a problem that it is difficult to intuitively grasp the behavior of the hybrid model program during the simulation execution.

  Accordingly, an object of the present invention is to provide a simulation apparatus that can visualize state transitions in a hybrid model program that is being simulated, and thereby intuitively understand the behavior of the hybrid model program.

  A hybrid model simulation apparatus according to an aspect of the present invention includes a description of a continuous system equation having variables, a description related to switching of the continuous system equation associated with a state transition, and a description of an additional process for recording the state transition. A hybrid model simulation apparatus that executes a simulation using a hybrid model program, and represents the time, the variable name of the variable, and the identification information of the state transition by executing the additional processing during the simulation A variable value time representing a time, a variable name of the variable, and a value of the variable by solving the continuous system equation by numerical integration along the time axis, and an additional processing execution unit that generates state transition history data From the continuous system simulation unit that generates history data and the variable value time history data, Generate and display a graph showing the change of the variable value of the variable along with the change of time, generate a display image that can identify the state transition of the variable from the state transition history data, and overlay the graph on the graph And a simulation result display unit for displaying.

  According to the present invention, it is possible to provide a simulation apparatus that can visualize state transitions in a hybrid model program that is being simulated, thereby intuitively grasping the behavior of the hybrid model program.

  Hereinafter, embodiments of the present invention will be described with reference to the drawings.

(First embodiment)
FIG. 1 is a block diagram showing a hybrid model simulation apparatus according to the first embodiment. The control information analysis unit 1002 reads the hybrid model program 1001 and generates a model equation registration program 1003, an event processing program 1004, and a simulation execution additional processing program 1005. The equation analysis unit 1007 reads a model equation registration program 1003 mainly described by an ordinary differential equation or the like, and stores the analysis result in the equation data storage unit 1010. The event processing unit 1008 reads an event processing program 1004 that describes the timing for executing the additional processing program and the timing for switching the continuous system equation. The additional process execution unit 1006 reads the simulation execution additional process program 1005, and the event processing unit 1008 executes the additional process program when the additional process becomes executable. When an API (Application Program Interface) related to state transition is called in the additional processing program, the call history is registered in the state transition history storage DB (database) 1013.

  The continuous system equation switching unit 1009 determines which equation among the registered equations that is registered in accordance with the setting from the event processing unit 1008 is to be validated during the simulation and performs the numerical calculation, and determines the validity / invalidity of the equation. The continuous system simulation unit 1011 executes numerical integration of effective equations along the time axis, and determines values of the variables of the equations. The variable time history is stored in the variable value time history storage DB 1012. The simulation result display unit 1014 displays the time change of the state transition and the time change of the variable value from the state transition history storage DB 1013 and the variable value time history DB 1012.

  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.

  In the above description, the constituent elements other than the contents of the simulation execution additional processing program 1005, the state transition history storage DB 1013, and the simulation result display unit 1014 are described in Japanese Patent Application Laid-Open No. 2004-178300 and Japanese Patent Application Laid-Open No. 2004-220577. Can be helpful.

  Here, referring to FIG. 2, the relationship between the state transition and the model equation will be described with an example of the hybrid model program 1001. The hybrid model program 1001 is described in text and can be created using a text editing tool such as a text editor. The hybrid model program 1001 mainly includes model equations, state descriptions, and state transition condition descriptions.

  In the list line of the hybrid model program 1001 shown in FIG. 2, the description of the model equation is L8, L11, L14, and L17, and the state description is L7-L8 do-watching syntax, L10-L11 do-watching syntax, L13-L14 do-watching syntax, L16-L17 do-watching syntax, etc. The description of the state transition condition is “up (L6)” event issuance and “const (L9)” “down (L12)” “ idle (L15) "when syntax.

  A state transition diagram of the hybrid model program 1001 is shown on the left side of FIG. Each state description has a state name, L7-L8 is “rise”, L10-L11 is “constant speed”, L13-L14 is “deceleration”, and L16-L17 are “idle”.

  Next, how the state transition recording information is generated and registered in the state transition history storage DB 1013 in the simulation process using the hybrid model program 1001 in which the state transition recording command is described in the code will be described. . The record information of the state transition is information that can identify the state transition for a certain variable.

(L1) cont y; event up; event const; event
(L2) down; event idle;
(L3) y = 1; up;
(L4) when (up) {
(L5) do {always y '= y + 1;} watching (const);}
(L6) process (up) {SetStatus ("y", "Startup");}
(L7) when (y = 10) const;
(L8) when (const) {
(L9) do {always y '= 0;} watching (down);}
(L10) process (const) {SetStatus ("y", "constant speed");}
(L11) when (t = 100) down;
(L12) when (down) {
(L13) do {always y '=-1;} watching (idle);}
(L14) process (down) {SetStatus ("y", "deceleration");}
(L15) when (y = 1) idle;
(L16) when (idle) {
(L17) do {always y '= 0;} watching (up);}
(L18) process (idle) {SetStatus ("y", "idle");}
In this hybrid model program, additional processing is executed using a process statement (L6, L10, L14, L18). The process statement executes an additional processing program (in this case, a SetStatus function) according to the events “up”, “const”, “down”, and “idle”. That is, when the state transition condition is satisfied, the SetStatus function is called by the process statement. The SetStatus function has a variable name and a state transition name as arguments. The model equation registration program 1003 and the event processing program 1004 are output as a C language program (see, for example, paragraph [0063] of Japanese Patent Application Laid-Open No. 2004-178300), and a simulation execution additional processing program 1005 (such as a SetStatus function). Is also output as a C language program (see, for example, paragraphs [0052] and [Equation 2] of Japanese Patent Laid-Open No. 2004-220577). For example, the SetStatus function is described as the following program.

void SetStatus (const char * name, cont char * status_name) {
FILE * fp = fopen ("status_change_log.txt", "a");
double time = getCurrentTime ();
fprintf (fp, "% f,% s,% s \ n", time, name, status_name);
fclose (fp);
}
Here, the getCurretnTime () function is an API for acquiring the current simulation time. The following output is output to “status_change_log.txt” by the following function.

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

  The hybrid model program 1001 is first processed in the control information analysis unit 1002 to generate a model equation registration program 1003, an event processing program 1004, and a simulation execution additional processing program 1005.

  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 1003 and the event processing program 1004 are programs that appropriately combine descriptions for calling the corresponding API functions along the input hybrid model program 1001. From this point of view, the control information analysis unit 1002 is considered as a kind of compiler in which the input is a hybrid model program 1001 and the output is a C program (source) including, for example, a C language API function call description. You can also. Such a model equation registration program 1003 and an event processing program 1004 are further 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. 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.

  There are various specifications of specific software modules that constitute the application interface of the hybrid model simulation apparatus. 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 1010. 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 1010, a tree structure is formed in advance by connecting internal data structures so that the value of an expression can be calculated at high speed. If any error occurs in the above processing, 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 1002 first generates a function (InitEqnData) that sequentially calls XXX_AddEqnData for a necessary equation. This corresponds to the model equation registration program 1003 (first program).

  In addition, the control information analysis unit 1002 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 1004 (second program).

  Here, the ChangeEqn function detects the occurrence of the “up” event, the “const” event, the “down” event, and the “idle” event by the GetEvent function. The ChangeEqn function is called from the event processing unit 1008 at each time step during simulation execution.

  In the hybrid model simulation apparatus, as can be seen from FIG. 1, the event processing unit 1008 and the continuous system simulation unit 1011 are separated. Accordingly, the event processing program 1004 does not include a time-dependent module such as time integration, and the event processing unit 1008 corresponding thereto only switches the valid / invalid flag of the continuous system equation.

  By adopting such a simulator configuration, the event related to the interface with the external device and the event related to the hybrid description can be managed by the same process (if (GetEvent (event) process)).

  Further, since the control information analysis unit 1002 once outputs the hybrid simulation model as the same language as the additional processing, it is possible to easily generate the hybrid simulation execution program. Therefore, the cooperation between the hybrid simulation and the external device is facilitated.

Further, the control information analysis unit 1002 generates a SetEvent function when an event is generated internally as in L6, L9, L12, and L15 in FIG. The SetEvent function is called from the event processing unit 1008 for each time step that can be set during simulation execution. In the control information analysis unit 1002, the “up” event of L6 in FIG.
if (getCurrentTime () == 0) SetEvent (“up”);
Into a C language source program. In addition, the “const” event of L9 in FIG. 2 uses a GetValue function that acquires the value of each variable during the simulation.
if (GetValue (“y”) == 10) SetEvent (“const”);
Into a C language source program.

  Further, the control information analysis unit 1002 extracts the content description of the additional process from the hybrid model program 1001. This extracted description corresponds to the simulation execution unit additional processing program 1005 (third program). The simulation execution unit additional processing program 1005 corresponds to the source of a program originally written in C language or the like in the hybrid model program 1001 (for example, the above-described SetStatus function). The extracted simulation execution unit additional processing program 1005 is compiled by a C language compiler to generate a dynamically linkable library. The additional processing execution unit 205 plays a role of an interface for calling this dynamically linkable library. The generated library is not necessarily a dynamic link library, and may be a static library. Further, the language for describing the contents of the additional processing is not limited to the C language.

  By the processing in the control information analysis unit 1002 as described above, for example, the following C language source program is automatically generated for the hybrid model program 1001 described above.

static char eqn1 [] = "y '= 1 * y + 1";
static char eqn2 [] = "y '= 0";
static char eqn3 [] = "y '=-1";
static char eqn4 [] = "y '= 0";
static int eqn1id;
static int eqn2id;
static int eqn3id;
static int eqn4id;
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;
}
int ChangeEqn ()
{
int err;
BOOL GetEvent (char * eventname);
if (GetEvent ("up")) {
Err = XXX_ActivateEqn (eqn1id);
if (err! = 0) return err;
XXX_DeActiveteEqn (eqn4id);
if (err! = 0) return err;
}
if (GetEvent ("const")) {
Err = XXX_ActivateEqn (eqn2id);
if (err! = 0) return err;
XXX_DeActiveteEqn (eqn1id);
if (err! = 0) return err;
}
if (GetEvent ("down")) {
Err = XXX_ActivateEqn (eqn3id);
if (err! = 0) return err;
XXX_DeActiveteEqn (eqn2id);
if (err! = 0) return err;
}
if (GetEvent ("idle")) {
Err = XXX_ActivateEqn (eqn4id);
if (err! = 0) return err;
XXX_DeActiveteEqn (eqn2id);
if (err! = 0) return err;
}
if (getCurrentTime () == 0) SetEvent ("up");
if (GetValue (“y”) == 10) SetEvent (“const”);
if (getCurrentTime () == 100) SetEvent ("down");
if (GetValue (“y”) == 1) SetEvent (“idle”);
}
Note that GetEvent is a function that checks whether an event with the name (eventname) specified in the argument has occurred.

  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. .

  Next, simulation execution will be described.

  When the simulation is started, the simulation is executed by calculating the value of the continuous system equation. At this time, the continuous system equation switching unit 1009 is called inside the event processing unit 1008 and executes switching of the continuous system equation using the valid / invalid flag. The event processing unit 1008 corresponds to the event processing program 1004 (second program; ChangeEqn) generated in the preprocessing.

  The continuous system simulation unit 1011 refers to the equation data storage unit 1010, and executes numerical integration for each time step using the internal data representation of the continuous system equation stored in the storage unit 1010 in the form of a tree structure as an operation target. . The simulation is an initial value problem for a non-linear simultaneous equation consisting of a set of ordinary differential equations and algebraic polynomials. For this reason, for example, the initial state shown in FIG. 2 is given. Specifically, for example, a solution value is calculated using a commonly used Runge-Kutta algorithm. Necessary data is output from the mechanism simulator, and the process returns to the process of the continuous system equation switching unit 1009, and the above process is repeated to execute the simulation for the necessary time. The simulation result is stored in the variable value time history storage DB 1012.

  As described above, during the period from the start to the end of the simulation, the history data indicating the temporal change of the state transition is recorded in the state transition history storage DB 1013 along with the operation of the additional processing execution unit 1006, while the continuous system simulation With the operation of the unit 1011, history data indicating temporal changes in variable values is recorded in the variable value time history storage DB 1012.

  FIG. 3 shows a display example by the simulation result display unit 1014. The simulation result display unit 1014 displays the time change history graph 2001 indicating the time change history of the variable value by two axes, for example, the time axis 2002 and the value axis 2003 as a simulation result. The state transition information 3004 and the state transition name 3005 are displayed superimposed on the history graph 2001.

The state transition information 3004 is a display image that is displayed superimposed on the time change history graph 2001 and can visually identify the state transition. In the present embodiment, in the time change history graph 2001, the start time ( An image of a rectangular area sandwiched between a straight line corresponding to the minimum value) and a straight line corresponding to the end time (maximum value). This rectangular area image is painted with a different color or hatched differently from the adjacent area in order to distinguish it from the adjacent state.
The state transition name 3005 is arranged in the state transition information 3004 or at a position partially overlapping with the state transition information 3004. The state transition name 3005 is arranged in an area that does not overlap with the time change history graph 2001.

FIG. 4 is a block diagram showing an internal configuration of the simulation result display unit 1014. The simulation result display unit 1014 analyzes the variable value time history storage DB 1013, analyzes the variable history analysis unit 4001 that creates graph display data, and the state transition history storage DB 1012, and displays the state transition name 3005 and the state transition information 3004. And a state transition history analysis unit 4002 to be created. The variable value time history storage DB 1013 is realized by, for example, the following text file. The following is a file storing a time history when variable x and variable y change from time 1.0 to 6.0.

  The beginning of the line starts with an alphabetic string variable, and a variable break is defined as a line break that does not include a space character such as a tab character or space character. When one row is composed of three columns, the first column is the time, the second column is the lower limit value, and the third column is the upper limit value. When the upper limit value and the lower limit value match, the value is determined by numerical calculation, and when the value is different, the value is not determined. The variable history analysis unit 4001 determines the x coordinate and y coordinate for plotting the graph for each variable. Here, the x-axis represents time, and data in the first column is used. The Y axis represents a value. When the values in the second and third columns match, the value in the second column is used. If the values in the second and third columns are different (indefinite), processing such as not displaying on the graph is performed.

For example, the state transition history analysis unit 4002 analyzes the following data as the state transition history storage DB 1012.

  The first column is the time, the second column is the variable, and the third column is the state transition name. The state transition history analysis unit 4002 reads the data file and determines state transition information 3004 for each variable. Each variable is in any state at all times. In this case, when the above data is analyzed, the “start-up” state is time 0.0 to 10.0, the “constant speed” state is time 10 to 100, the “deceleration” state is 100 to 150, and the “idle” state is 150. ~ Simulation end time. Since the relationship between each time and the display position on the graph is determined by the processing of the variable history analysis unit 4001, it can be acquired from the graph display unit 4003. The lower limit and the upper limit value of the state transition information 3004 are the minimum value and the maximum value of the graph display unit. The state transition name 3005 is large enough to display the third character string. The x-coordinate value between the disclosure time and end time of the state transition information 3004, and the y coordinate obtained by lowering the coordinate by a certain amount from the state transition information 3004 Place on value. The processing flow of the above processing is shown in FIG.

  According to the first embodiment described above, as can be understood from the display example of FIG. 3, it is possible to visualize the state transition in the hybrid model program during the execution of the simulation. That is, not only the time change history graph 2001 indicating the time change history of the variable value but also the state transition information 3004 and the state transition name 3005 can be displayed. Therefore, it becomes easy to intuitively grasp the behavior of the hybrid model program during simulation execution.

(Second Embodiment)
FIG. 6 is a block diagram showing a simulation result display unit according to the second embodiment. The simulation result display unit 1014 shown in FIG. 6 analyzes the variable value time history storage DB 1013 and creates a time change history graph 2001 for displaying on the graph display unit 4003, and a state transition history storage. A state transition history analysis unit 4002 that creates state transition information 3004 and a state transition name 3005 for analyzing and displaying the DB 1012 on the graph display unit 4003, and a state display switching unit for selecting a variable name for displaying the state transition 5001.

  FIG. 7 is a flowchart showing a processing procedure of the simulation result display unit according to the second embodiment. First, the file of the variable value time history storage DB 1013 is opened (13001). Next, the file of the state transition history storage DB 1012 is opened (13002).

  Based on the information recorded in these files, the display position of each variable data in the graph display area is calculated (13003). Next, the state display target variable name is acquired, the start time and end time of each state are calculated (13004), and the state transition information 3004 in the graph display area of each state is calculated (13005). Further, the label position in the graph display area of each state is calculated (13006).

  Then, according to the position information calculated above, a time change history graph 2001 (graph), state transition information 3004 (region), and state transition name 3005 (label) are displayed. Here, when the graph display end process is performed, the end process is executed, and when the graph display area, for example, the time range to be displayed or the value range to be displayed is changed, the state returns to the state of 13003.

  FIG. 8 is a diagram illustrating a display example of a screen configured to be able to specify a variable name that is a target of state transition display by the state display switching unit 5001. The graph display unit 4003 has a mouse pointer 8002. The mouse pointer 8002 can be moved in the screen in accordance with a moving operation of a mouse connected to the PC. When the mouse is clicked on the time change history graph 2001 (for example, on the line indicated by the solid line in the example of FIG. 8), the variable name associated with the clicked graph is acquired.

  By this click designation operation, the state transition history analysis unit 4002 reads the state transition history information related to the variable name from the state transition history storage DB 1012 and displays the state transition history. The area to be clicked with the mouse may be on the line of the graph, or may be clicked in the vicinity of the graph (for example, several pixels away from the flag). When a click in the vicinity of the graph is permitted, a mouse operation can be performed relatively easily compared to a click on a line of the graph, and the state transition can be switched more easily.

  FIG. 9 is a diagram illustrating a display example of another screen configured to be able to specify a variable name that is a target of state transition display by the state display switching unit 5001. The simulation result display unit 1014 has a graph display unit 4003 and a menu bar 9001, and the menu bar 9001 has a variable display menu 9002 and a display variable instruction button 9003. The variable display menu 9002 creates a list of variable names in which history is stored from the variable value time history storage DB 1013 and displays it on the menu. For example, it is assumed that the variable value time history storage DB 1013 is as shown in the above [Equation 4]. If the first character string on each line is written in alphabet, register it as a variable name in the list. In this case, the registered variables are “x” and “y”. The menu displays “display x” and “display y”. When the user clicks a display variable instruction button 9003 using a mouse pointer 8002 (not shown), a variable name associated with the variable display menu 9002 arranged next to the clicked button is acquired, and state transition history analysis is performed. The unit 4002 reads the state transition history information related to the variable name from the state transition history storage DB 1012 and displays the state transition history.

  FIG. 10 is a diagram illustrating a display example of another screen configured to be able to specify a variable name that is a target of state transition display by the state display switching unit 5001. The graph display unit 4003 has a variable name display area 10003, a first variable valid button 10001, and a second variable valid button 10002. When the user presses a button using a mouse pointer 8002 (not shown), a variable name associated with the pressed button is read, and the state related to the variable name is read from the state transition history storage DB 1012 by the state transition history analysis unit 4002. Read transition history information and display state transition history.

(Third embodiment)
FIG. 11 relates to the third embodiment and shows a display example of the graph display unit 4003 when the simulation result display unit 1014 is configured to display two variables simultaneously in one graph region. In the third embodiment, the simulation result display unit 1014 can simultaneously display a time change history graph 6001 related to the first variable and a time change history graph 6002 related to the second variable.

The following is an example of the state transition history storage DB 1012 having state transition history for a plurality of variables. Here, it is assumed that the time change history graph 6001 related to the first variable is displayed regarding the variable x, and the time change history graph 6002 related to the second variable is displayed regarding the variable y.

  If it is set in advance to display the state transition regarding the variable x, the state transition history analysis unit 4002 reads only the data regarding the variable x and displays the state transition information 3004 and the state transition name 3005.

  On the other hand, FIG. 12 is a display example in the case where it is set in advance to display the state transition regarding the variable y.

(Fourth embodiment)
FIG. 13 is a display example of the graph display unit 4003 when two variables are simultaneously displayed in two graph areas. The graph display unit 4003 has a state transition auxiliary line 11001. When there is the same state transition in the upper and lower graphs, a corresponding line is drawn. By using this display method, it is possible to avoid the graph data from being displayed in an overlapping manner, so that the visibility of the graph data is improved. In addition, the state transition information 3004 having the same state transition name is filled with the same color or the same hatching pattern, so that the state transitions of the upper and lower graphs can be easily compared. When the same color or hatching pattern is used, either one of the state transition names 3005 can be deleted.

  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 hybrid model simulation apparatus which concerns on 1st Embodiment Diagram for explaining the relationship between state transition and model equation in hybrid model program The figure which shows the example of a display by a simulation result display part Block diagram showing the internal configuration of the simulation result display section The flowchart which shows the process sequence of the simulation result display part which concerns on 1st Embodiment. The block diagram which shows the simulation result display part which concerns on 2nd Embodiment The flowchart which shows the process sequence of the simulation result display part which concerns on 2nd Embodiment. The figure which shows the example of a display of the screen comprised so that the variable name used as the object of state transition display can be specified by the state display switching part The figure which shows the example of a display of another screen comprised so that a variable name can be specified. The figure which shows the example of a display of another screen comprised so that a variable name can be specified. The figure which shows the example of a display of a graph display part when it concerns on 3rd Embodiment and the simulation result display part is comprised so that two variables may be simultaneously displayed on one graph area | region. The figure which shows the example of a display in the case of setting to display the state transition regarding the variable y beforehand The figure which shows the example of a display of a graph display part at the time of displaying two variables on two graph areas simultaneously.

Explanation of symbols

1001 ... Hybrid model program;
1002 ... Control information analysis unit;
1003 ... Model equation registration program;
1004 ... Event processing program;
1005 ... Simulation processing additional processing program;
1006 ... Additional processing execution unit;
1007 ... Equation analysis unit;
1008 ... Event processing unit;
1009 ... Continuous equation switching unit;
1010 ... equation data storage unit;
1011 ... Continuous system simulation section;
1012 ... Variable value time history storage DB;
1013 ... State transition history storage DB;
1014 ... Simulation result display section

Claims (6)

Hybrid model simulation that executes a simulation using a hybrid model program having a description of a continuous system equation having variables, a description about switching of the continuous system equation accompanying a state transition, and a description of an additional process for recording the state transition A device,
An additional processing execution unit that generates state transition history data representing the time, the variable name of the variable, and the identification information of the state transition by executing the additional processing during the simulation;
By solving the continuous system equation by numerical integration along the time axis, a continuous system simulation unit for generating variable value time history data representing the time, the variable name of the variable, and the value of the variable;
From the variable value time history data, a graph showing a change in the variable value of the variable along with a change in time is generated and displayed, and a display image that can identify the state transition of the variable from the state transition history data A hybrid model simulation apparatus comprising: a simulation result display unit that generates and displays the result superimposed on the graph. 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,
A switching means for executing the event processing program at the start of simulation, and switching between valid / invalid of the continuous system equation according to the occurrence of the event, and
The hybrid model simulation apparatus according to claim 1, wherein the continuous system simulation unit solves the continuous system equation using the data structure corresponding to the continuous system equation validated by the switching unit.   The hybrid model simulation apparatus according to claim 1, wherein the simulation result display unit displays a state transition name of the variable together with a display image that can identify the state transition of the variable.   The simulation result display unit generates and displays a plurality of graphs indicating changes in variable values for a plurality of variables, and displays a display image that can identify state transitions of the variables for the graph specified by the specifying unit. The hybrid model simulation apparatus according to any one of claims 1 to 3. Hybrid model simulation that executes a simulation using a hybrid model program having a description of a continuous system equation having variables, a description about switching of the continuous system equation accompanying a state transition, and a description of an additional process for recording the state transition A method,
An additional process executing unit generating the state transition history data representing the time, the variable name of the variable, and the identification information of the state transition by executing the additional process during the simulation;
A continuous system simulation unit generates variable value time history data representing a time, a variable name of the variable, and a value of the variable by solving the continuous system equation by numerical integration along a time axis; ,
A simulation result display unit generates and displays a graph indicating a change in the variable value of the variable along with a change in time from the variable value time history data, and displays the state transition of the variable from the state transition history data. Generating a identifiable display image and displaying it on the graph in a superimposed manner. Hybrid model simulation that executes a simulation using a hybrid model program having a description of a continuous system equation having variables, a description about switching of the continuous system equation accompanying a state transition, and a description of an additional process for recording the state transition A program,
On the computer,
A procedure for generating state transition history data representing time, a variable name of the variable, and identification information of the state transition by executing the additional processing during the simulation;
A procedure for generating variable value time history data representing a time, a variable name of the variable, and a value of the variable by solving the continuous system equation by numerical integration along a time axis;
From the variable value time history data, a graph showing a change in the variable value of the variable along with a change in time is generated and displayed, and a display image that can identify the state transition of the variable from the state transition history data A hybrid model simulation program for executing and generating and displaying the superimposed image on the graph.

Images