Modular editing and executing method and system for semiconductor device modeling
By introducing the modular modeling unit Step and related tools, the problem of rigid interfaces in semiconductor device modeling tools has been solved, the modularity and reusability of the modeling process have been achieved, and modeling efficiency has been improved and costs have been reduced.
Patent Information
- Application Number
- CN202511489438.5
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2025-10-17
- Publication Date
- 2026-01-13
AI Technical Summary
Existing semiconductor device modeling tools have fixed interface configurations, rigid operating logic, and lack of modular mechanisms, resulting in long modeling cycles, low efficiency, difficulty in adapting to new process requirements, and requiring engineers to perform a lot of repetitive work and secondary development.
The modular modeling unit Step is introduced, which combines a configuration interface editor, a runtime logic editor, a script parsing engine, and a message responder. A parameter configuration page is generated through a unique identifier StepID, a schema is automatically generated, and the modeling logic is flexibly arranged and executed through the script parsing engine.
It achieves modularization of the modeling process and decoupling of parameters and logic, improving the reusability and automation of modeling, shortening the modeling cycle, and reducing repetitive operations and R&D costs.
Smart Images
Figure CN121328117A_ABST
Abstract
Description
TECHNICAL FIELD
[0001] The present application relates to the technical field of semiconductor device modeling, and particularly relates to a modularized editing and executing method and system for semiconductor device modeling. BACKGROUND
[0002] In the process of semiconductor integrated circuit design, a device model is a bridge between a process and circuit simulation. The accuracy of the device model directly determines the reliability and manufacturability of the circuit design, and has an important influence on the design cycle, research and development cost and product yield. With the continuous evolution of the process, new materials, device structures and process conditions emerge in an endless stream, which puts forward higher requirements for modeling tools and methods.
[0003] At present, in the field of model parameter extraction, the traditional modeling technology mainly relies on manual programming of model equations and parameter extraction scripts. The developers need to have rich knowledge of semiconductor physics and modeling algorithms. A large number of repetitive operations are involved in the modeling process, such as setting simulation conditions, calling fitting algorithms, adjusting boundary parameters, etc. These steps are often completed through fixed scripts or tool interfaces. On the one hand, the configuration interface of the existing tool is mostly built-in software, and users cannot flexibly extend or customize parameter items according to actual needs; on the other hand, the running logic is usually fixed in the software, lacking programmability, and engineers cannot quickly solidify and reuse the existing modeling process according to their own experience.
[0004] In addition, the existing method cannot be directly adapted, and a large amount of time and cost is consumed for re-modeling, resulting in long modeling cycle and low efficiency. Engineers also need to repeatedly process a large amount of repetitive work, that is, the existing modeling tools generally lack a modularized task unit division mechanism. Different modeling tasks such as parameter fitting, noise modeling and thermal effect modeling often need to be redeveloped or switched between multiple tools, resulting in a long modeling cycle and difficulty in accumulating and depositing expert experience. Especially under the background of rapid iteration of new process nodes, the existing tool cannot directly adapt to new modeling requirements, and engineers need to invest a lot of time for secondary development, further increasing the modeling cost and difficulty. SUMMARY
[0005] The application aims at the problems of fixed interface configuration, rigid operation logic, lack of modular mechanism, difficult reuse and adaptation of modeling process for new technology in the existing semiconductor device modeling process, and provides a modular editing and execution method and system for semiconductor device modeling. The application provides a modular editing and execution method for semiconductor device modeling, comprising the following steps: Step S1: initializing the script parsing engine embedded in the application program, and registering and loading the API interface called externally; Step S2: creating a device modeling unit Step and assigning a unique identifier StepID, which is used for calling and managing the Step in the configuration interface editing, operation logic editing and message response triggering process; Step S3: calling the configuration interface editor, generating a parameter configuration page for the Step based on the StepID, automatically generating a structured configuration description Schema according to the parameter field set in the configuration interface, and associating and binding the Schema with the StepID; Step S4: loading the Schema in the operation logic editor, calling the script parsing engine to parse and bind the Schema, and defining the operation script based on the parameter field in the Schema, so that the operation script completes the modeling task when calling the numerical value or object of the parameter field; Step S5: configuring a trigger message for the Step in the message responder, and binding the trigger message with the operation script, when the interface operation triggers the corresponding message, calling the operation script, executing the modeling task according to the parameter field provided by the Schema and outputting the result.
[0006] Further, in step S1, the script parsing engine embedded in the application program is initialized, and the API interface called externally is registered and loaded, including: Initializing the running environment of the script parsing engine, the API interface in the script parsing engine, the API interface is a unified entrance for providing access parameters, calling external tools and / or executing modeling operations; A communication channel is established between the script parsing engine and the main process of the application program, which is used to call the API interface in the configuration interface editing and operation logic editing process; The initialization process of the script parsing engine is detected, and an available state identifier is generated after determining that the API interface registration is successful, which is used for calling the script parsing engine in the running logic editor.
[0007] Further, in step S3, step S3: calling the configuration interface editor, generating a parameter configuration page for Step based on StepID, automatically generating a structured configuration description Schema according to the parameter fields set in the configuration interface, and binding the Schema with the StepID, including: In the configuration interface editor, the corresponding interface instance is established based on the StepID generated in step S2, and the corresponding parameter configuration page is generated for Step; Defining the parameter fields of Step in the parameter configuration page, the parameter fields include metadata information such as attribute name, attribute type, default value, and display priority; Automatically generating Schema according to the definition of parameter fields, and the Schema stores the metadata information of parameter fields in a structured data format; Binding the Schema with the StepID, which is used to call the Schema based on the StepID in the running logic editing and message response triggering process; at the same time, the binding relationship between the parameter configuration page and the Schema is verified, and when the verification is passed, a configuration completion identifier is output, which is used for calling the running logic editor.
[0008] Further, in step S4, loading the Schema in the running logic editor, and calling the script parsing engine to parse and bind the Schema, running the script based on the parameter field definition in the Schema, so that the running script completes the modeling task when calling the value or object of the parameter field, including: Reading the Schema associated with StepID, and importing the parameter fields in the Schema into the input variable pool in the running logic editor as the input data source of the running logic; Calling the script parsing engine to perform syntax analysis and data type verification on the parameter fields in the input variable pool to ensure that the parameter fields conform to the preset format; Generating a running script framework based on the verified input variable pool in the running logic editor, and reserving the calling position of the API interface of modeling operation in the script framework; Mapping the parameter fields in the input variable pool to the input parameters of the API interface, and constructing a complete running logic link by combining one or more API interfaces; Calling the script parsing engine to simulate execution and debugging of the running logic link, verifying whether the running script can correctly trigger modeling calculation and output expected results when calling the parameter fields.
[0009] Further, in step S4, the script parsing engine is called to perform syntax analysis and data type checking on the parameter field of the input variable pool, including syntax checking of field naming, hierarchical structure and mandatory completeness, and type checking of field value type, value range, enumeration legality and nested object consistency.
[0010] Further, in step S5, a trigger message is configured for Step in the message responder, and the trigger message is bound with the running script, when the interface operation triggers the corresponding message, the running script is called to execute the modeling task according to the parameter field provided by the Schema and output the result, including: A set of message types is preset in the message responder, including interface click, double-click, keyboard input or parameter update event; The unique identifier of Step is bound with the selected message type, and the running script is specified as the response logic in the binding relationship; When the interface operation triggers the message type, the message responder reads the parameter field in the Schema, and passes the parameter field as input to the running script; The script parsing engine is called to execute the running script, complete the modeling logic operation according to the input parameter field and generate the modeling result; the modeling result is output to the front-end interface or storage unit of the application program for display or subsequent calling.
[0011] Based on the same inventive concept, the application provides a modularized editing and execution system for semiconductor device modeling, which adopts the modularized editing and execution method as described above, comprising: An initialization module for initializing the script parsing engine embedded in the application program and registering and loading the API interface called externally; A device modeling module for creating a device modeling unit Step and assigning a unique identifier StepID, for calling and managing Step in the configuration interface editing, running logic editing and message response triggering process; A configuration interface editing module for calling the configuration interface editor, generating a parameter configuration page for Step based on StepID, and automatically generating a structured configuration description Schema according to the parameter field set in the configuration interface, and associating and binding the Schema with StepID; A running logic editing module for loading the Schema in the running logic editor, calling the script parsing engine to parse and bind the Schema, and defining the running script based on the parameter field in the Schema, so that the running script completes the modeling task when calling the value or object of the parameter field; Message response module: configure trigger message for Step in message responder, and bind trigger message with running script, when interface operation triggers corresponding message, call running script, execute modeling task according to parameter field provided by Schema and output result.
[0012] Further, the configuration interface editing module comprises: The interface instance generation unit is configured to, in the configuration interface editor, establish a corresponding interface instance based on the StepID generated in step S2, and generate a corresponding parameter configuration page for the Step. The Schema generation binding unit is configured to define the parameter field of the Step in the parameter configuration page, wherein the parameter field comprises metadata information including attribute name, attribute type, default value and display priority; automatically generate a Schema based on the definition of the parameter field, wherein the Schema stores the metadata information of the parameter field in a structured data format; and associate and bind the Schema with the StepID, so as to call the Schema based on the StepID in the running logic editing and message response triggering processes; and simultaneously, verify the binding relationship between the parameter configuration page and the Schema, and output a configuration completion identifier when the verification is passed, so as to call the running logic editor.
[0013] Further, the running logic editing module comprises: The parameter management unit is configured to read the Schema associated with the StepID, and import the parameter field in the Schema into an input variable pool in the running logic editor as an input data source of the running logic; call the script parsing engine to perform syntax parsing and data type verification on the parameter field in the input variable pool, so as to ensure that the parameter field conforms to a preset format. The script generation unit is configured to generate a running script framework in the running logic editor based on the verified input variable pool, and reserve a calling position of an API interface of modeling operation in the script framework. The simulation execution unit is configured to map the parameter field in the input variable pool to an input parameter of the API interface, and construct a complete running logic link by combining and calling one or more API interfaces; call the script parsing engine to perform simulation execution and debugging on the running logic link, so as to verify whether the running script can correctly trigger modeling calculation and output expected results when calling the parameter field.
[0014] Further, the message response module comprises, A message configuration unit is configured in the message responder to preset a set of message types, including interface click, double click, keyboard input or parameter update event; the unique identifier of Step is bound to the selected message type, and the running script is specified as the response logic in the binding relationship; when the interface operation triggers the message type, the message responder reads the parameter field in the Schema, and the parameter field is passed as input to the running script; A result output unit is configured to call the script parsing engine to execute the running script, complete the modeling logic operation according to the input parameter field, and generate a modeling result; and output the modeling result to the front-end interface of the application program or the storage unit for display or subsequent calling.
[0015] Compared with the prior art, the present application has at least one of the following technical effects: The present application introduces the concept of modular modeling unit Step, and combines configuration interface editing, running logic editing, script parsing engine and message response mechanism to realize the unification of parameter configuration, logic arrangement and message trigger execution of modeling tasks. It breaks through the limitations of fixed tool interface and non-programmable logic, can shorten the modeling cycle, reduce repetitive operations and solidify expert experience. BRIEF DESCRIPTION OF DRAWINGS
[0016] In order to more clearly illustrate the technical solutions of the embodiments of the present application, the following will briefly introduce the drawings needed in the embodiment description: Figure 1 The step flow chart of the modular editing and execution method for semiconductor device modeling of the present application. DETAILED DESCRIPTION
[0017] In order to make the purpose, technical scheme and advantages of the present application more clear, the following will further describe the present application in combination with the drawings and specific embodiments. It should be understood that the specific embodiments described herein are only used to explain the present application, and are not used to limit the present application.
[0018] First embodiment In the field of semiconductor device modeling, the existing technology generally has the following problems: (1) The configuration interface of traditional modeling software is mostly embedded in the application program, and users can only make limited choices in the preset parameter options, and it is difficult to flexibly expand new parameter items according to different device characteristics or modeling requirements. (2) The running logic of the existing modeling process is usually fixed in the software code, and lacks programmability, which makes engineers unable to quickly adjust or reuse the existing modeling process according to experience. (3) Modeling tasks often involve parameter fitting, noise analysis, thermal effect modeling and other links, and there is a lack of modular division mechanism between different tasks, and engineers need to rely on manual scripts to repeatedly implement, which is low in efficiency and prone to errors.
[0019] To address the above problems, the general solution adopted by the prior art is to preinstall built-in modules or templates in the software, and the user completes modeling by checking and combining the existing modules. This method relieves the user's operation burden to some extent, but still cannot meet the diversified and customized modeling needs. For example, when encountering a new process node or a special modeling task, the user still needs to rely on the secondary development of the R&D personnel, which has a long development cycle, high cost and insufficient flexibility.
[0020] In view of the above deficiencies, the present inventors team hopes to propose a modular, programmable and customizable solution. The core goal of this solution is to allow users to define parameter fields freely through a configuration interface editor based on the modeling unit Step as the basic operation module, and to automatically generate a structured configuration description Schema; to quickly build a running logic based on the Schema in a running logic editor, and to call a modeling operation API through a script parsing engine to implement calculation; and finally to bind the modeling logic and the interface operation event through a message response mechanism, so that users can perform complex modeling tasks in an intuitive interactive manner. Through this method, users can flexibly define and reuse modeling processes without relying on underlying R&D personnel, thereby greatly improving modeling efficiency, reducing R&D costs, and realizing the solidification and inheritance of knowledge and experience. The specific implementation is as follows: As shown in Figure 1 The present application provides a modular editing and execution method for semiconductor device modeling, comprising the following steps: Step S1: Initialize the script parsing engine embedded in the application program, and register and load the API interface called externally; the API interface is used to access / save configuration parameters, call external tools or perform modeling operations; Step S2: Create a device modeling unit Step and assign a unique identifier StepID, which is used to call and manage the Step in the configuration interface editing, running logic editing and message response triggering process; Step S3: Call the configuration interface editor, generate a parameter configuration page for the Step based on the StepID, and automatically generate a structured configuration description Schema according to the parameter fields set in the configuration interface, and bind the Schema and the StepID; Step S4: Load the Schema in the running logic editor, and call the script parsing engine to parse and bind the Schema, and define a running script based on the parameter fields in the Schema, so that the running script completes the modeling task when calling the numerical value or object of the parameter field; Step S5: configure a trigger message for Step in the message responder, and bind the trigger message with a running script, when the interface operation triggers the corresponding message, call the running script, execute the modeling task according to the parameter field provided by Schema and output the result.
[0021] Further, in step S1, the script parsing engine embedded in the application is initialized, and the API interface called externally is registered, including: Initialize the running environment of the script parsing engine, and the API interface in the script parsing engine, the API interface is a unified entrance for providing access parameters, calling external tools and / or executing modeling operations; Specifically, the API interface is used to establish a calling channel between the running logic script and the underlying modeling operation module, including an object parameter access interface for obtaining real-time numerical values of the parameter fields defined in Schema, an external tool calling interface for triggering external simulation tools or algorithm libraries, and a modeling operation interface for calling preset operation functions such as fitting, optimization, noise modeling, and thermal effect modeling.
[0022] Through the combined calling of the above interfaces, the running logic script can implement different modeling calculation tasks in a modularized manner.
[0023] A communication channel is established between the script parsing engine and the main process of the application, which is used to call the API interface during the configuration interface editing and running logic editing process; The initialization process of the script parsing engine is detected, and an available state identifier is generated after determining that the API interface is successfully registered, which is used to call the script parsing engine in the running logic editor.
[0024] Further, in step S3, step S3: call the configuration interface editor, generate a parameter configuration page for Step based on StepID, automatically generate a structured configuration description Schema according to the parameter fields set in the configuration interface, and associate and bind Schema with StepID, including: In the configuration interface editor, establish the corresponding interface instance based on the StepID generated in step S2, and generate the corresponding parameter configuration page for Step; Define the parameter fields of Step in the parameter configuration page, including metadata information such as attribute name, attribute type, default value, and display priority; Automatically generate Schema according to the definition of the parameter field, and Schema stores the metadata information of the parameter field in a structured data format; The Schema is associated with the StepID and is used to call the Schema based on the StepID during the running logic editor and message response trigger process; meanwhile, the binding relationship between the parameter configuration page and the Schema is checked, and when the check is passed, a configuration completion identifier is output, which is used to call the running logic editor.
[0025] Specifically, the Step is selected by the unique identifier StepID, which is used for interface and running script binding. The configuration interface is completed by editing and setting attribute metadata and attribute types. The structured data of the parameter configuration page is stored in association with the unique identifier, which is used for updating / loading in the running stage; when the configuration information changes, the interface data is updated to the storage database through the unique identifier. In the parameter configuration page, the parameter fields corresponding to the Step are defined, including but not limited to metadata information such as attribute name, attribute value type, default value, and display priority; wherein the attribute value type includes integer type, floating point type, list type, string type, or object type, etc.
[0026] Further, in step S4, the Schema is loaded in the running logic editor, and the script parsing engine is called to parse and bind the Schema, and the running script is defined based on the parameter fields in the Schema, so that the running script completes the modeling task when calling the numerical value or object of the parameter field, including: The Schema associated with the StepID is read, and the parameter fields in the Schema are imported into the input variable pool in the running logic editor as the input data source of the running logic; The script parsing engine is called to perform syntax parsing and data type checking on the parameter fields in the input variable pool, to ensure that the parameter fields conform to the preset format; The running script framework is generated in the running logic editor based on the checked input variable pool, and the calling position of the API interface of the modeling operation is reserved in the script framework; The parameter fields in the input variable pool are mapped to the input parameters of the API interface, and one or more API interfaces are called to build a complete running logic link; The script parsing engine is called to perform simulation execution and debugging on the running logic link, to verify whether the running script can correctly trigger the modeling calculation and output the expected result when calling the parameter field.
[0027] Specifically, the running logic editor will automatically generate a script framework according to the parameter fields in the input variable pool, which includes variable declaration area, logic operation area and result output area, and each parameter field will be declared as an input variable and occupy a place in the framework.
[0028] In the logic operation area, the editor does not directly write the logic, but inserts a call placeholder, such as API CALL (FIT FUNCTION), which is equivalent to a template interface, and in the subsequent step, a specific modeling operation API is selected and bound, so that the running logic framework can ensure that the parameter field has a position for input, and flexible replacement of different operation functions is supported.
[0029] Further, in step S4, the script parsing engine is called to perform syntax analysis and data type checking on the parameter fields of the input variable pool, including syntax checking of field naming, hierarchical structure, and mandatory completeness, and type checking of field value type, value range, enumeration legality, and consistency of nested objects.
[0030] Further, in step S5, a trigger message is configured for Step in the message responder, and the trigger message is bound with the running script. When the interface operation triggers the corresponding message, the running script is called to execute the modeling task and output the result according to the parameter fields provided by the Schema, including: A set of message types is preset in the message responder, including interface click, double-click, keyboard input, or parameter update event; The unique identifier of Step is bound with the selected message type, and the running script is specified as the response logic in the binding relationship; When the interface operation triggers the message type, the message responder reads the parameter fields in the Schema, and passes the parameter fields as input to the running script; The script parsing engine is called to execute the running script, complete the modeling logic operation according to the input parameter fields, and generate the modeling result; the modeling result is output to the front-end interface or storage unit of the application program for display or subsequent calling.
[0031] The user can edit the running code of Step and develop related configuration interfaces, and any number of running parameter information can be added on the configuration page. At the same time, according to the message responder provided by the system, the user can customize the message response script to realize the modeling function logic triggered by the message. One Step can have multiple message response scripts. In this way, the user can develop any customized modeling unit with the support of the application program. The following will combine several typical modeling task scenarios to describe the specific implementation process of the embodiment in detail: Application scenario 1: In MOSFET threshold voltage (Vth) fitting, engineers in the field often need to manually write scripts, call SPICE simulators, extract Id-Vg curves at different gate voltages, and then manually select the fitting interval and modify the code to adjust the boundary parameters. However, this solution has a problem that once the process conditions change, the script needs to be modified again, which is not reusable and the process is time-consuming. The solution of the present application is to create a new Step "Threshold voltage fitting" in the configuration interface editor, define the parameter fields such as temperature range, gate voltage step, and initial fitting interval. Automatically bind Schema and StepID. In the running logic editor, users only need to drag and combine "Curve extraction API" and "Threshold fitting API", and bind with parameter fields. Just click the "Start fitting" button to trigger the script, which will automatically call SPICE simulation and output Vth value without modifying the underlying script.
[0032] Application scenario 2: BJT thermal noise modeling, noise models are usually built-in by tools, users can only choose "on / off", cannot adjust the formula or add new noise items. For example, to add 1 / f 2 noise to the traditional thermal noise, you need to modify the source code. The problem with this solution is poor scalability, unable to quickly verify new model assumptions. In the present application, the user creates a new Step "Noise modeling" in the configuration interface, defines noise type parameters such as white noise, 1 / f 2 noise, 1 / f 2 noise. Automatically generate Schema and bind with StepID. In the running logic editor, users can combine "thermal noise API" and "1 / f noise API" to form a new noise formula. Message responder configuration click event triggers calculation, the system can generate a new noise spectral density curve and display.
[0033] Application scenario 3: fast adaptation of new process nodes, for example, when the process is upgraded from 7nm to 5nm, or when the process is transitioned from FinFET to GAAFET, the original modeling tool often cannot directly adapt to the new process characteristics. The traditional method usually needs to redevelop a complete set of parameter extraction scripts, or wait for the EDA manufacturer to update the support module, resulting in long modeling cycle and lagging adaptation. Especially for special effects in new processes, such as short channel effect, strain engineering, three-dimensional structure parasitic parameters, the existing tool requires engineers to switch between multiple scripts and tools, repeatedly configure the environment and parameters, which is time-consuming and error-prone. The present application can quickly create and reuse modeling logic related to new processes by the way of modular modeling unit Step. For example, engineers only need to add process-related parameter fields in the configuration interface editor, such as channel length, transistor stacking method, and parasitic capacitance model selection, to automatically generate the corresponding Schema; and by combining the existing modeling API through the running logic editor and binding to these new parameter fields, a modeling process adapted to the new process can be built within a few hours without the need to write complex scripts from scratch.
[0034] Second embodiment Based on the same inventive concept, the present application provides a modular editing and execution system for semiconductor device modeling, which adopts the modular editing and execution method as described above, comprising: An initialization module for initializing the script parsing engine embedded in the application program and registering and loading the API interface called externally; A device modeling module for creating a device modeling unit Step and assigning a unique identifier StepID, for calling and managing the Step in the configuration interface editing, running logic editing, and message response triggering processes; A configuration interface editing module for calling the configuration interface editor, generating a parameter configuration page for the Step based on the StepID, automatically generating a structured configuration description Schema according to the parameter fields set in the configuration interface, and associating and binding the Schema with the StepID; A running logic editing module for loading the Schema in the running logic editor, parsing and binding the Schema by calling the script parsing engine, defining a running script based on the parameter fields in the Schema, and making the running script complete the modeling task when calling the values or objects of the parameter fields; A message response module: configuring a triggering message for the Step in the message responder, and binding the triggering message with the running script, when the interface operation triggers the corresponding message, calling the running script, executing the modeling task according to the parameter fields provided by the Schema and outputting the result.
[0035] Further, the configuration interface editing module comprises: an interface instance generation unit, configured to establish a corresponding interface instance based on the StepID generated in step S2 in the configuration interface editor, and generate a corresponding parameter configuration page for the Step; a Schema generation binding unit, configured to define a parameter field of the Step in the parameter configuration page, wherein the parameter field comprises metadata information including an attribute name, an attribute type, a default value, and a display priority; automatically generate a Schema based on the definition of the parameter field, and store the metadata information of the parameter field in a structured data format; associate and bind the Schema with the StepID, so as to call the Schema based on the StepID in a running logic editing and message response triggering process; and simultaneously, verify the binding relationship between the parameter configuration page and the Schema, and output a configuration completion identifier when the verification is passed, so as to call the running logic editor.
[0036] Further, the running logic editing module comprises: a parameter management unit, configured to read the Schema associated with the StepID, and import the parameter field in the Schema into an input variable pool in the running logic editor as an input data source of the running logic; and call a script parsing engine to perform syntax parsing and data type verification on the parameter field in the input variable pool, so as to ensure that the parameter field conforms to a preset format; a script generation unit, configured to generate a running script framework based on the verified input variable pool in the running logic editor, and reserve a calling position of an API interface of modeling calculation in the script framework; a simulation execution unit, configured to map the parameter field in the input variable pool to an input parameter of the API interface, and construct a complete running logic link by calling one or more API interfaces in combination; and call the script parsing engine to perform simulation execution and debugging on the running logic link, so as to verify whether the running script can correctly trigger modeling calculation and output an expected result when the parameter field is called.
[0037] Further, the message response module comprises, a message configuration unit, configured to preset a message type set in the message responder, wherein the message type comprises an interface click, double-click, keyboard input, or parameter update event; establish a binding relationship between the unique identifier of the Step and the selected message type, and specify the running script as a response logic in the binding relationship; and when the interface operation triggers the message type, call the message responder to read the parameter field in the Schema, and pass the parameter field as an input to the running script; The result output unit is used for calling the script analysis engine to execute the running script, completing the modeling logic operation according to the input parameter field and generating a modeling result; and outputting the modeling result to the front-end interface of the application program or a storage unit for display or subsequent calling.
[0038] Although the present application has been disclosed with the preferred embodiments as above, it is not intended to limit the present application, and any person skilled in the art can make possible changes and modifications to the technical solutions of the present application by using the disclosed methods and technical contents without departing from the spirit and scope of the present application. Therefore, any simple modification, equivalent change and modification made to the above embodiments according to the technical essence of the present application without departing from the technical solutions of the present application shall fall within the protection scope of the technical solutions of the present application.
Claims
1. A modular authoring and execution method for semiconductor device modeling, characterized by, The method comprises the following steps: Step S1: initializing a script parsing engine embedded in an application program, and registering and loading an API interface called externally; Step S2: creating a device modeling unit Step and assigning a unique identifier StepID, for calling and managing the Step in the configuration interface editing, running logic editing and message response triggering processes; Step S3: calling a configuration interface editor, generating a parameter configuration page for the Step based on the StepID, automatically generating a structured configuration description Schema according to the parameter fields set in the configuration interface, and associating and binding the Schema with the StepID; Step S4: loading the Schema in the running logic editor, calling the script parsing engine to parse and bind the Schema, and defining a running script based on the parameter fields in the Schema, so that the running script completes a modeling task when calling the numerical value or object of the parameter field; Step S5: configuring a trigger message for the Step in the message responder, and binding the trigger message with the running script, so that when an interface operation triggers a corresponding message, the running script is called to execute the modeling task according to the parameter field provided by the Schema and output the result.
2. The modular editing and execution method of claim 1, wherein, In step S1, the script parsing engine embedded in the application program is initialized, and the API interface called externally is registered and loaded, including: Initializing the running environment of the script parsing engine, the API interface in the script parsing engine, the API interface being a unified entrance for providing access parameters, calling external tools and / or performing modeling operations; Establishing a communication channel between the script parsing engine and the main process of the application program, for calling the API interface during the configuration interface editing and the running logic editing processes; Detecting the initialization process of the script parsing engine, and generating an available state identifier after determining that the API interface is successfully registered, for calling the script parsing engine in the running logic editor.
3. The modular editing and execution method of claim 2, wherein, In step S3, step S3: calling a configuration interface editor, generating a parameter configuration page for the Step based on the StepID, automatically generating a structured configuration description Schema according to the parameter fields set in the configuration interface, and associating and binding the Schema with the StepID, including: In the configuration interface editor, establishing a corresponding interface instance based on the StepID generated in step S2, and generating a corresponding parameter configuration page for the Step; Defining the parameter fields of the Step in the parameter configuration page, the parameter fields including metadata information such as attribute name, attribute type, default value and display priority; Automatically generating the Schema according to the definition of the parameter fields, and the Schema storing the metadata information of the parameter fields in a structured data format; The Schema is associated with the StepID and is bound, used to call the Schema based on the StepID in the running logic editing and message response triggering process; meanwhile, the binding relationship between the parameter configuration page and the Schema is verified, and when the verification is passed, a configuration completion identifier is output, used for calling the running logic editor.
4. The modular editing and execution method of claim 3, wherein, In step S4, the Schema is loaded in the running logic editor, and the script parsing engine is called to parse and bind the Schema, and a running script is defined based on the parameter field in the Schema, so that the running script completes the modeling task when calling the numerical value or object of the parameter field, including: The StepID-associated Schema is read, and the parameter field in the Schema is imported into the input variable pool in the running logic editor as an input data source of the running logic; The script parsing engine is called to perform syntax parsing and data type verification on the parameter field of the input variable pool, to ensure that the parameter field conforms to the preset format; A running script framework is generated in the running logic editor based on the verified input variable pool, and the calling position of the API interface of the modeling operation is reserved in the script framework; The parameter field in the input variable pool is mapped to the input parameter of the API interface, and a complete running logic link is constructed by combining the calling of one or more API interfaces; The script parsing engine is called to perform simulation execution and debugging on the running logic link, to verify whether the running script can correctly trigger modeling calculation and output expected results when calling the parameter field.
5. The modular editing and execution method of claim 4, wherein, In step S4, the script parsing engine is called to perform syntax parsing and data type verification on the parameter field of the input variable pool, including syntax checking of field naming, hierarchical structure, and mandatory completeness, and type checking of field value type, value range, enumeration legality, and nested object consistency.
6. The modular editing and execution method of claim 4, wherein, In step S5, a trigger message is configured for the Step in the message responder, and the trigger message is bound with the running script, when the interface operation triggers the corresponding message, the running script is called, the modeling task is executed according to the parameter field provided by the Schema, and the result is output, including: A set of message types is preset in the message responder, including interface click, double-click, keyboard input, or parameter update event; The unique identifier of the Step is bound with the selected message type, and the running script is specified as the response logic in the binding relationship; When the interface operation triggers the message type, the message responder reads the parameter field in the Schema, and the parameter field is passed to the running script as input; The script parsing engine is called to execute the running script, complete modeling logic operation according to the input parameter field, and generate a modeling result; and the modeling result is output to a front-end interface or a storage unit of the application program for display or subsequent calling.
7. A modular editing and execution system for semiconductor device modeling, employing the modular editing and execution method according to any one of claims 1 to 6, characterized by, Comprise: An initialization module, configured to initialize a script parsing engine embedded in an application program, and register and load an API interface called by an outside; A device modeling module, configured to create a device modeling unit Step and assign a unique identification StepID, for calling and managing the Step in a configuration interface editing process, a running logic editing process, and a message response triggering process; A configuration interface editing module, configured to call a configuration interface editor, generate a parameter configuration page for the Step based on the StepID, automatically generate a structured configuration description Schema according to a parameter field set in the configuration interface, and associate and bind the Schema with the StepID; A running logic editing module, configured to load the Schema in a running logic editor, call a script parsing engine to parse and bind the Schema, define a running script based on the parameter field in the Schema, and make the running script complete a modeling task when calling a value or an object of the parameter field; A message response module, configured to configure a triggering message for the Step in a message responder, bind the triggering message with the running script, call the running script when a corresponding message is triggered by an interface operation, execute the modeling task according to the parameter field provided by the Schema, and output a result.
8. The modular editing and execution system of claim 7, wherein, The configuration interface editing module comprises: An interface instance generation unit, configured to establish a corresponding interface instance in the configuration interface editor based on the StepID generated in step S2, and generate a corresponding parameter configuration page for the Step; A Schema generation and binding unit, configured to define the parameter field of the Step in the parameter configuration page, wherein the parameter field comprises metadata information including an attribute name, an attribute type, a default value, and a display priority; automatically generate the Schema according to the definition of the parameter field, wherein the Schema stores the metadata information of the parameter field in a structured data format; associate and bind the Schema with the StepID, for calling the Schema based on the StepID in the running logic editing process and the message response triggering process; and verify the binding relationship between the parameter configuration page and the Schema, and output a configuration completion identifier when the verification is passed, for calling of the running logic editor.
9. The modular editing and execution system of claim 8, wherein, The running logic editing module comprises: The parameter management unit is configured to read the Schema associated with the StepID, and import the parameter field in the Schema into an input variable pool in the running logic editor as an input data source of the running logic; and call the script parsing engine to perform syntax parsing and data type checking on the parameter field in the input variable pool, so as to ensure that the parameter field conforms to a preset format. The script generation unit is configured to generate a running script framework based on the input variable pool after the checking in the running logic editor, and reserve a calling position of the API interface of the modeling operation in the script framework. The simulation execution unit is configured to map the parameter field in the input variable pool to an input parameter of the API interface, and construct a complete running logic link by combining and calling one or more API interfaces; and call the script parsing engine to perform simulation execution and debugging on the running logic link, so as to verify whether the running script can correctly trigger the modeling calculation and output an expected result when calling the parameter field.
10. The modular editing and execution system of claim 9, wherein, The message response module includes, The message configuration unit is configured to preset a message type set in the message responder, and the message type includes an interface click, double-click, keyboard input or parameter update event. The unique identifier of the Step is bound to the selected message type, and the running script is specified as a response logic in the binding relationship; when the interface operation triggers the message type, the message responder reads the parameter field in the Schema, and passes the parameter field as an input to the running script; The result output unit is configured to call the script parsing engine to execute the running script, complete the modeling logic operation according to the input parameter field, and generate a modeling result. The modeling result is output to a front-end interface or a storage unit of the application program, and is used for display or subsequent calling.