Domain modeling language definition method oriented to specific business design verification requirements

Abstract

The invention provides a domain modeling language definition method for specific business design verification requirements, and relates to the technical field of engineering system modeling simulation. The domain modeling language definition method oriented to the specific business design verification requirement comprises the following steps: step 1, defining a digital prototype language expression form; 2, defining a digital prototype domain language host language, and cutting and expanding the digital prototype domain language host language; 3, defining field language keywords of the digital prototype; 4, defining a general instruction category and an instruction naming specification of a digital prototype field language; and 5, packaging the industry instruction set library based on the prototype model library. According to the method, construction, integration and simulation of the digital prototype of the heterogeneous model are achieved by defining the domain language of the digital prototype, a digital prototype modeling and simulation instruction set is constructed through the domain modeling language, and the instruction set calls an AP I provided by a language tool to the outside to achieve construction and simulation of the digital prototype.

Description

Technical Field

[0001] The present invention relates to the technical field of engineering system modeling and simulation, and in particular to a domain modeling language definition method oriented to specific business design verification requirements. Background Art

[0002] A digital prototype (Digital Prototype / Digital Mock-Up) refers to a digital model of a physical prototype (complete product or subsystem) expressed on a computer. It is a full expression of the static characteristics, dynamic behaviors, and other elements of a real physical product in a computer. Its purpose is to use a digital prototype to simulate, analyze, and verify the functions and performance of a physical prototype in a virtual computer simulation environment.

[0003] The description of the physical prototype is mainly from the following aspects:

[0004] Function: describes the logical functional composition of the system, the interfaces and connection relationships between functions, and the logical operation process;

[0005] Performance: According to the actual composition and mechanism of the system, digital models, mechanism algorithms and equations are constructed to achieve overall system-level simulation;

[0006] Structure: Build a three-dimensional model that is the same as the physical world to describe the appearance, structure, and constraints of the system;

[0007] Professional: Using the structural model as input, the stress field, temperature field, flow field, electromagnetic field and other information are described through finite element and other means;

[0008] In order to describe the above information of digital prototypes, different standard languages ​​are usually used to express them, resulting in different models scattered everywhere, and it is difficult to ensure the consistency of information between models. By defining the digital prototype domain language, operating the above models, and promoting the regular management of various models; and constructing prototype instructions to uniformly operate the attributes of various models, thus ensuring the consistency of the attributes of various models.

[0009] Therefore, those skilled in the art provide a method for defining a domain modeling language oriented to specific business design verification requirements to solve the problems raised in the above background technology. Summary of the invention

[0010] 1. Technical issues to be solved

[0011] In view of the shortcomings of the prior art, the present invention provides a domain modeling language definition method for specific business design verification needs, defines the domain language of digital prototypes, realizes the digital prototype construction, integration and simulation of heterogeneous models, and constructs a digital prototype modeling and simulation instruction set through the domain modeling language. The instruction set calls the API provided by the language tool to realize the construction and simulation of the digital prototype.

[0012] (II) Technical solution

[0013] To achieve the above objectives, the present invention is implemented through the following technical solutions:

[0014] A method for defining a domain modeling language for specific business design verification requirements includes the following steps:

[0015] Step 1: Define the digital prototype language expression;

[0016] Step 2: Define the digital prototype domain language host language, and tailor and expand it;

[0017] Step 3: Define the digital prototype domain language keywords;

[0018] Step 4: Define the general instruction categories and instruction naming conventions of the digital prototype domain language;

[0019] Step 5: Encapsulate the industry instruction set library based on the prototype model library.

[0020] Preferably, in step 1, the expression forms include functional models, performance models, structural models and professional models;

[0021] Among them, the functional model is expressed using the SysML standard model;

[0022] The performance model is expressed using Modelica and Julia models. Modelica expresses the physical domain model, and Julia expresses the information domain model.

[0023] The structural model is expressed using a common format (e.g., STEP standard) or a commercial CAD model;

[0024] Professional models are expressed using commercial CAE models.

[0025] Preferably, in step 2, defining the digital prototype domain language host language, and tailoring and extending it specifically include:

[0026] a. Use Julia as the host language in the digital prototype domain;

[0027] b. Use Julia's functions, control flow and loops, macros and other features;

[0028] c. Expand Julia's object-oriented features.

[0029] Preferably, the specific idea of ​​the extension is as follows:

[0030] 1) Expand the object-oriented capabilities of struct through macros;

[0031] 2) Define a new constructor that supports overloading to implement the initialization of variables under struct.

[0032] Preferably, in step 3, defining the digital prototype domain language keywords specifically includes the following keywords:

[0033] Digital prototype, mockup;

[0034] Function model class, function_model;

[0035] Performance model class, performance_model;

[0036] Three-dimensional structural model class, structural_model;

[0037] Professional simulation model class cae_model;

[0038] Using the above object-oriented implementation keyword definition, since mockup contains other classes and other classes are independent of each other, the function model class function_model and the digital prototype class mockup are taken as examples and defined as follows:

[0039] 1.function_model

[0040] □Use macro @oodef to define structfunction_model;

[0041] □Define variables: fullName, which is a string type. Define other variables as needed;

[0042] □Define the constructor function (new()) to implement its external construction;

[0043] 2.Mockup

[0044] □Use the macro @oodef to define mockup;

[0045] □Define variables: prototype name, which is a string type, and define other variables as required;

[0046] □ Define variables: functionModel, type function_model, performaceModel type performance_model, structuralModel type structural_model, caeModel type cae_model, and call their constructor function (new) to initialize;

[0047] □Define the constructor function (new()) to implement external construction;

[0048] □Define the initialization function (int()), establish the relationship between the variables of the functional model, performance model, three-dimensional structure model, and professional simulation model, and establish the linkage of parameters between models.

[0049] Preferably, the method using keywords is as follows:

[0050] a. Use the keyword function_model to construct a functional model and set the functional model name (such as "sysml.example.system")

[0051] b. Use the keyword performace_model to construct a performance model and set the performance model name (such as "modelica.example.system")

[0052] c. Use the keyword structural_model to construct a structural model, construct a structural model and set the structural model name (such as: "cad.example.system")

[0053] d. Use the keyword cea_model to build the cae model and set the name of the cae model (such as "cae.example.system")

[0054] e. Use the keyword mockup, take the above model as input parameter, construct the prototype, and generate the prototype system;

[0055] f. Call the system function init to associate the parameters of various models and realize the linkage between models;

[0056] g. Call system functions, such as showFuncModel(), showPerformanceModel(), showCAD(), and showCAE(), to display the function model, performance model, CAD model, and CAE model respectively;

[0057] h. Call system functions, such as runPerformanceModel(), to run the performance prototype model to display variable curves, 3D animations, scene view animations, etc.

[0058] Preferably, in step 4, defining the general instruction category of the digital prototype domain language and the instruction naming specification includes:

[0059] 1) The naming convention is: domain language name_behavior_general object category, model category is optional

[0060] For example: CAL_Create_Mockup

[0061] 2) Instruction category

[0062] □Build class instructions, for example:

[0063] CAL_Create_FunctionModel("sysml.example.system")

[0064] CAL_Create_PerformaceModel("modelica.example.system")

[0065] □Integration instructions, for example:

[0066] CAL_Connect_Port()

[0067] □Simulation instructions, for example:

[0068] mockup engine("mockup.engine")

[0069] CAL_Run_PerformaceModel(engine)

[0070] Preferably, in step 5, encapsulating the industry instruction set library based on the prototype model library specifically includes:

[0071] The naming convention is: domain language name_behavior_special object name_object category. The instructions are mainly used to operate the model library, such as: creating an object in the model library, calling the method of the object, etc.

[0072] The details are as follows:

[0073] CAL_Create_Engine_Mockup()

[0074] CAL_Connect_Engine_Port()

[0075] CAL_Run_Engine_Performace(engine)

[0076] (III) Beneficial effects

[0077] The present invention provides a domain modeling language definition method oriented to specific business design verification requirements.

[0078] It has the following beneficial effects:

[0079] 1. The present invention provides a method for defining a domain modeling language for specific business design verification needs. The present invention is based on the Julia language standard and only uses its language characteristics to achieve the definition of the digital prototype domain language. It can be well integrated with other Julia language libraries to achieve complementary capabilities.

[0080] 2. The present invention provides a method for defining a domain modeling language for specific business design verification needs. By defining four types of digital prototype models, the present invention encourages users to organize various models and manage them in a unified manner, thereby achieving full-factor expression of the prototype.

[0081] 3. The present invention provides a method for defining a domain modeling language for specific business design and verification needs. The present invention extends the capabilities of Julia to enable it to have object-oriented capabilities, and uses the object-oriented capabilities to define digital prototype keywords to better express prototypes and four types of models. It also defines a naming convention for operating prototype instructions, which is more convenient to read and use.

[0082] 4. The present invention provides a method for defining a domain modeling language for specific business design verification needs, defines the domain language of a digital prototype, realizes the construction, integration and simulation of digital prototypes of heterogeneous models, and constructs a digital prototype modeling and simulation instruction set through the domain modeling language. The instruction set calls the API provided by the language tool to realize the construction and simulation of the digital prototype. DETAILED DESCRIPTION

[0083] The technical solutions in the embodiments of the present invention are described clearly and completely below. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of them. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0084] Example:

[0085] The embodiment of the present invention provides a method for defining a domain modeling language for specific business design verification requirements, comprising the following steps:

[0086] Step 1: Define the digital prototype language expression

[0087] a. Functional model: SysML standard model expression;

[0088] b. Performance model: expressed using Modelica and Julia. Modelica expresses the physical domain model, while Julia expresses the information domain model.

[0089] c. Structural model: general format (such as step standard) or commercial CAD model expression;

[0090] Professional model: commercial CAE model expression;

[0091] Step 2: Define the digital prototype domain language host language, and tailor and expand it

[0092] a. Use Julia as the host language in the digital prototype domain;

[0093] b. Use Julia's functions, control flow and loops, macros and other features;

[0094] c. Expand Julia's object-oriented features;

[0095] The specific ideas for expansion are as follows:

[0096] 1) Expand the object-oriented capabilities of struct through macros;

[0097] 2) Define a new constructor that supports overloading to initialize variables under struct;

[0098] Step 3: Define Digital Prototype Domain Language Keywords

[0099] Digital prototype, mockup;

[0100] Function model class, function_model;

[0101] Performance model class, performance_model;

[0102] Three-dimensional structural model class, structural_model;

[0103] Professional simulation model class cae_model;

[0104] Using the above object-oriented implementation keyword definition, since mockup contains other classes and other classes are independent of each other, the function model class function_model and the digital prototype class mockup are taken as examples and defined as follows:

[0105] 1.function_model

[0106] □Use macro @oodef to define struct function_model;

[0107] □Define variables: fullName, which is a string type. Define other variables as needed;

[0108] □Define the constructor function (new()) to implement its external construction;

[0109] 2.Mockup

[0110] □Use the macro @oodef to define mockup;

[0111] □Define variables: prototype name, which is a string type, and define other variables as required;

[0112] □ Define variables: functionModel, type function_model, performaceModel type performance_model, structuralModel type structural_model, caeModel type cae_model, and call their constructor function (new) to initialize;

[0113] □Define the constructor function (new()) to implement external construction;

[0114] □ Define the initialization function (int()), establish the relationship between the variables of the functional model, performance model, three-dimensional structure model, and professional simulation model, and establish the linkage of parameters between models;

[0115] The method of using keywords is as follows:

[0116] a. Use the keyword function_model to construct a functional model and set the functional model name (such as "sysml.example.system")

[0117] b. Use the keyword performace_model to construct a performance model and set the performance model name (such as "modelica.example.system")

[0118] c. Use the keyword structural_model to construct a structural model, construct a structural model and set the structural model name (such as: "cad.example.system")

[0119] d. Use the keyword cea_model to build the cae model and set the name of the cae model (such as "cae.example.system")

[0120] e. Use the keyword mockup, take the above model as input parameter, construct the prototype, and generate the prototype system;

[0121] f. Call the system function init to associate the parameters of various models and realize the linkage between models;

[0122] g. Call system functions, such as showFuncModel(), showPerformanceModel(), showCAD(), and showCAE(), to display the function model, performance model, CAD model, and CAE model respectively;

[0123] h. Call system functions, such as runPerformanceModel(), to run the performance prototype model to display variable curves, 3D animations, scene view animations, etc.;

[0124] Step 4: Define the general instruction categories and instruction naming conventions for the digital prototype domain language

[0125] The naming convention is: domain language name_behavior_general object category, model category is optional

[0126] For example: CAL_Create_Mockup

[0127] 2) Instruction category

[0128] □Build class instructions, for example:

[0129] CAL_Create_FunctionModel("sysml.example.system")

[0130] CAL_Create_PerformaceModel("modelica.example.system")

[0131] □Integration instructions, for example:

[0132] CAL_Connect_Port()

[0133] □Simulation instructions, for example:

[0134] mockup engine("mockup.engine")

[0135] CAL_Run_PerformaceModel(engine)

[0136] Step 5: Encapsulate the industry instruction set library based on the prototype model library

[0137] The naming convention is: domain language name_behavior_special object name_object category. The instructions are mainly used to operate the model library, such as: creating an object in the model library, calling the method of the object, etc.

[0138] The details are as follows:

[0139] CAL_Create_Engine_Mockup()

[0140] CAL_Connect_Engine_Port()

[0141] CAL_Run_Engine_Performace(engine)

[0142] The present invention is based on the Julia language standard and only uses its language characteristics to realize the definition of the digital prototype field language. It can be well integrated with other Julia language libraries to achieve complementary capabilities.

[0143] The present invention defines four types of models of digital prototypes, prompting users to organize various models and manage them in a unified manner, thereby achieving full-factor expression of the prototype.

[0144] The present invention extends Julia's capabilities to enable it to have object-oriented capabilities, and uses the object-oriented capabilities to define digital prototype keywords, better express prototypes and four types of models, and also defines a naming specification for operating prototype instructions, which is more convenient to read and use.

[0145] The present invention realizes the construction, integration and simulation of digital prototypes of heterogeneous models by defining the domain language of digital prototypes, and constructs a digital prototype modeling and simulation instruction set through the domain modeling language. The instruction set calls the API provided by the language tool to realize the construction and simulation of the digital prototype.

[0146] Although embodiments of the present invention have been shown and described, it will be appreciated by those skilled in the art that various changes, modifications, substitutions and variations may be made to the embodiments without departing from the principles and spirit of the present invention, and that the scope of the present invention is defined by the appended claims and their equivalents.

Claims

1. A method for defining a domain modeling language for specific business design verification requirements, characterized in that: The following steps are involved: Step 1: Define the digital prototype language expression; Step 2: Define the digital prototype domain language host language, and tailor and expand it; Step 3: Define the digital prototype domain language keywords; Step 4: Define the general instruction categories and instruction naming conventions of the digital prototype domain language; Step 5: Encapsulate the industry instruction set library based on the prototype model library.

2. A method for defining a domain modeling language for specific business design verification requirements according to claim 1, characterized in that: In step 1, the expression forms include functional model, performance model, structural model and professional model; Among them, the functional model is expressed using the SysML standard model; The performance model is expressed using Modelica and Julia models. Modelica expresses the physical domain model, and Julia expresses the information domain model. The structural model is expressed using a common format or commercial CAD model; Professional models are expressed using commercial CAE models.

3. A method for defining a domain modeling language for specific business design verification requirements according to claim 1, characterized in that: In step 2, the digital prototype domain language host language is defined, and tailored and expanded, specifically including: a. Use Julia as the host language in the digital prototype domain; b. Use Julia's functions, control flow and loops, macros and other features; c. Expand Julia's object-oriented features.

4. A method for defining a domain modeling language for specific business design verification requirements according to claim 3, characterized in that: The specific ideas of the extension are as follows: 1) Expand the object-oriented capabilities of struct through macros; 2) Define a new constructor that supports overloading to implement the initialization of variables under struct.

5. A method for defining a domain modeling language for specific business design verification requirements according to claim 1, characterized in that: In step 3, the digital prototype domain language keywords are defined to specifically include the following keywords: Digital prototype, mockup; Function model class, function_model; Performance model class, performance_model; Three-dimensional structural model class, structural_model; Professional simulation model class cae_model; Using the above object-oriented implementation keyword definition, since mockup contains other classes and other classes are independent of each other, the function model class function_model and the digital prototype class mockup are taken as examples and defined as follows: 1.function_model □Use macro @oodef to define struct function_model; □Define variables: full name, string type, define other variables as required; □Define the constructor function (new()) to implement its external construction; 2.Mockup □Use the macro @oodef to define mockup; □Define variables: prototype name, which is a string type, and define other variables as required; □ Define variables: functionModel, type function_model, performaceModel type performance_model, structuralModel type structural_model, caeModel type cae_model, and call their constructor functions (new) to initialize; □Define the constructor function (new()) to implement external construction; □Define the initialization function (int()), establish the relationship between the variables of the functional model, performance model, three-dimensional structure model, and professional simulation model, and establish the linkage of parameters between models.

6. A method for defining a domain modeling language for specific business design verification requirements according to claim 5, characterized in that: The method of using keywords is as follows: a. Use the keyword function_model to construct a function model and set the function model name; b. Use the keyword performace_model to construct a performance model and set the performance model name; c. Use the keyword structural_model to construct a structural model, construct a structural model and set the structural model name; d. Use the keyword cea_model to build the cae model and set the name of the cae model; e. Use the keyword mockup, take the above model as input parameter, construct the prototype, and generate the prototype system; f. Call the system function init to associate the parameters of various models and realize the linkage between models; g. Call system functions, such as showFuncModel(), showPerformanceModel(), showCAD(), and showCAE(), to display the function model, performance model, CAD model, and CAE model respectively; h. Call system functions, such as runPerformanceModel(), to run the performance prototype model to display variable curves, 3D animations, scene view animations, etc.

7. A method for defining a domain modeling language for specific business design verification requirements according to claim 1, characterized in that: In step 4, the general instruction categories of the digital prototype domain language and the instruction naming conventions are defined, including: 1) The naming convention is: domain language name_behavior_general object category, model category is optional For example: CAL_Create_Mockup 2) Instruction category □Build class instructions, for example: CAL_Create_FunctionModel("sysml.example.system") CAL_Create_PerformaceModel("model ica.example.system") □Integration instructions, for example: CAL_Connect_Port() □Simulation instructions, for example: mockup engine("mockup.engine") CAL_Run_PerformaceModel(engine) 8. A method for defining a domain modeling language for specific business design verification requirements according to claim 1, characterized in that: In step 5, encapsulating the industry instruction set library based on the prototype model library specifically includes: The naming convention is: domain language name_behavior_special object name_object category. The instructions are mainly used to operate the model library, such as: creating an object in the model library, calling the method of the object, etc. The details are as follows: CAL_Create_Engine_Mockup() CAL_Connect_Engine_Port() CAL_Run_Engine_Performace(engine) .