Complex system demand integrity modeling and evaluation supporting method

Abstract

The invention discloses a method for supporting complex system demand integrity modeling and evaluation, and relates to the technical field of complex system design, model-based system engineering and demand management. The method comprises the following steps: 1, constructing a Chinese general demand template; 2, combining the Chinese general demand template with a demand modeling standard Req I F; step 3, constraining the attribute content of the demand item based on the Chinese general demand template; 4, constructing a demand model; 5, constructing a demand integrity evaluation criterion; step 6, evaluating the integrity of the attribute content of the demand item; 7, modifying the content which does not meet the requirements to the template which meets the requirements, the method is based on the EARS template, a universal Chinese requirement template is expanded and put forward, the method adapts to the expression mode and habits of the Chinese requirements, structural constraint on the Chinese requirement content is supported through the template, and therefore complete expression of the Chinese requirements is achieved.

Description

Technical Field

[0001] The present invention belongs to the technical fields of complex system design, model-based system engineering, and demand management, and in particular relates to a method for supporting complex system demand integrity modeling and evaluation. Background Art

[0002] In the existing demand expression methods, whether it is a demand document or a demand model, the demand content is still described in natural language. Since natural language is unstructured and ambiguous, it is easy to cause omissions in the expression of demand and it is difficult to ensure the integrity of the demand content. The patent method proposes EARS_NFR based on the EARS template. Although the EARS_NFR template standardizes the expression of demand to a certain extent, it is an English template and cannot fully adapt to the expression method and habits of Chinese demand, resulting in it being unable to be applied to the complete expression of Chinese demand. The demand template method in the patent method mainly focuses on the text description of demand, and lacks close integration with the demand modeling method (such as UML use case diagram, SysML requirement diagram, Req IF requirement entry form, etc.), which leads to the fact that the expression of demand in the model is still ambiguous and incomplete. Therefore, we propose a method to support demand integrity modeling and evaluation. Based on the EARS template extension, a Chinese general demand template is proposed, which is suitable for the complete description of Chinese demand. The proposed method for demand integrity modeling and evaluation closely integrates the demand template with the demand modeling method to ensure the integrity of the demand content in the demand model. Summary of the invention

[0003] The purpose of the present invention is to provide a method that supports modeling and evaluation of the integrity of complex system requirements. By extending the EARS template, a general Chinese requirement template is proposed to adapt to the expression and habits of Chinese requirements. This solves the problem that the EARS_NFR template is proposed based on the EARS template in the existing patent method. Although the EARS_NFR template standardizes the expression of requirements to a certain extent, it is an English template and cannot fully adapt to the expression and habits of Chinese requirements, resulting in the problem that it cannot be applied to the expression of Chinese requirement integrity.

[0004] In order to solve the above technical problems, the present invention is achieved through the following technical solutions:

[0005] The present invention is a method for supporting complex system requirement integrity modeling and evaluation, comprising the following steps:

[0006] Step 1: Build a Chinese general demand template;

[0007] Step 2: Combine the Chinese general requirement template with the requirement modeling standard Req IF;

[0008] Step 3: Constrain the content of requirement item attributes based on the Chinese general requirement template;

[0009] Step 4: Build a demand model;

[0010] Step 5: Construct requirements completeness assessment criteria;

[0011] Step 6: Evaluate the completeness of the attribute content of the requirement item;

[0012] Step 7: Modify the content that does not meet the requirements to a template that meets the requirements.

[0013] Furthermore, the method for supporting complex system requirement integrity modeling and evaluation is characterized in that, in step 1, a Chinese general requirement template is proposed based on the EARS requirement template, and the specific content is as follows:

[0014] (1) Universal requirements, describing the functions or behaviors that a system or entity should continuously perform at all times; the template structure is: <system name> should <system response>; for example, the autonomous driving system should continuously monitor the lane position;

[0015] (2) Event-driven requirements describe the response behavior of a system or entity when a specific trigger event occurs. It depends on the occurrence of a certain event or condition. The template structure is: when <optional prerequisite> <trigger>, <system name> should <system response>; for example, when a pedestrian is detected ahead, the autonomous driving system should slow down and stop.

[0016] (3) Unwanted behavior, describing the response measures that the system should take when encountering errors, failures, or deviations from expected user behavior; the template structure is: If <optional precondition> <trigger>, then <system name> should <system response>; for example, if a sensor fails, the autonomous driving system should immediately notify the driver and switch to manual driving mode;

[0017] (4) State-driven requirements describe the operations or behaviors that a system or entity should perform in a specific state. The template structure is: when <in a specific state>, <system name> should <system response>; for example, when a car is driving at high speed, the autonomous driving system should automatically maintain a safe following distance;

[0018] (5) Optional functional requirements, which describe the response that the system should perform when it has a specific feature or function. The template structure is: If has , <system name> should <system response>; for example, if the car has an automatic parking function, the autonomous driving system should prompt the driver to enable the automatic parking mode when a parking space is detected;

[0019] (6) Through the combination of the above templates, the complex requirements can be further constrained.

[0020] State-driven requirements + unwanted behaviors describe the response measures that the system should take when it encounters errors, failures, or deviations from expected user behaviors when the system is in a specific state; the template structure is: when <in a specific state>, if <optional precondition> <trigger>, then <system name> should <system response>; for example, when the car is in autonomous driving mode, if a sensor fails, the autonomous driving system should immediately notify the driver and switch to manual driving mode;

[0021] Event-driven requirements + unwanted behaviors, describing the response measures that the system should take when a specific trigger event occurs, when the system encounters an error, failure, or deviation from the expected user behavior; the template structure is: when <optional prerequisite 1><trigger>, if <optional prerequisite 2><trigger>, then <system name> should <system response>; for example, when a pedestrian is detected ahead, if the sensor fails, the autonomous driving system should slow down and notify the driver for manual intervention;

[0022] State-driven requirements + event-driven requirements describe the response behavior when a specific trigger event occurs when the system is in a specific state. The template structure is: when <in a specific state>, <optional prerequisite> <trigger>, <system name> should <system response>; for example, when a car is driving at high speed and detects an obstacle ahead, the autonomous driving system should automatically slow down and detour.

[0023] State-driven requirements + event-driven requirements + unwanted behaviors describe the response measures that should be taken when the system is in a specific state, a specific trigger event occurs, and an error, failure, or deviation from the expected user behavior is encountered; the template structure is: when <in a specific state>, <optional prerequisite 1> <trigger>, if <optional prerequisite 2> <trigger>, <system name> should <system response>; for example, when the car is driving at high speed and an obstacle is detected ahead, if the sensor fails at this time, the autonomous driving system should slow down and notify the driver for manual intervention.

[0024] Furthermore, the method for supporting modeling and evaluation of complex system requirement integrity is characterized in that, in step 2, in the requirement exchange format Req IF, the requirement item SpecObject refers to a single requirement, and the content of the requirement is described by defining attributes. Therefore, the Chinese general requirement template is combined with the attribute content definition of the requirement item SpecObject to support the construction of the requirement item attribute content under the constraints of the Chinese general requirement template.

[0025] Furthermore, the method for supporting complex system requirement integrity modeling and evaluation is characterized in that, in step three, according to the Chinese general requirement template, the requirement item attribute content in the requirement model based on the Req IF standard is constrained to ensure that it complies with the template specifications; the constraints include keyword constraints and structure constraints, wherein "TEMPLATE_STRI NG" refers to the placeholder of the template, which is a variable of string type, and is replaced according to the actual requirement content of the complex equipment. The specific content of the template constraints is shown in Table 2.

[0026] Furthermore, the method for supporting modeling and evaluation of complex system requirement integrity is characterized in that, in step four, the requirements are modeled using the Req IF standard, requirement items are defined, and a set of attributes are defined for each requirement item, such as requirement ID, requirement name, requirement description, priority, source, etc.; the attribute content of the requirement item is constructed under the constraints of the Chinese general requirement template, for example, for the requirement description attribute, the Chinese general requirement template is used to constrain the requirement description attribute content.

[0027] Furthermore, the method for supporting complex system requirement integrity modeling and evaluation is characterized in that, in step five, based on the Chinese general requirement template, natural language processing technology and regular expression matching technology are used to construct requirement integrity evaluation criteria; the criteria are as shown in Table 3: (the regular expression ".*" means that it can match a string of any length).

[0028] Furthermore, the method for supporting complex system requirement integrity modeling and evaluation is characterized in that, in step 6, evaluating whether the requirement content in the requirement model conforms to the Chinese general requirement template; specifically comprising:

[0029] 1. Extract the attribute content of the requirement items in the requirement model.

[0030] 2. Use natural language processing technology to analyze the extracted attribute content.

[0031] 3. Match the analysis results with the requirement completeness evaluation criteria. If it matches a template evaluation criterion, it is marked as conforming to the template; if it does not match any template, it is marked as not conforming to any template.

[0032] Furthermore, the method for supporting complex system requirement integrity modeling and evaluation is characterized in that, in step seven, the attribute content of the requirement item that does not meet any requirement integrity evaluation criteria is highlighted, and the evaluation result is output on the console: "This requirement does not meet any requirement template!" The user modifies the requirement content according to the error prompt until the requirement meets the Chinese general requirement template.

[0033] The present invention has the following beneficial effects:

[0034] 1. The present invention is based on the EARS (Easy Approach to Requirements Syntax, EARS) template, and extends it to propose a universal Chinese requirement template to adapt to the expression methods and habits of Chinese requirements. Through this template, it supports structured constraints on Chinese requirement content, thereby realizing the complete expression of Chinese requirements.

[0035] 2. Based on the EARS (Easy Approach to Requirements Syntax, EARS) template, the present invention extends and proposes a general Chinese requirement template, and closely combines it with the requirement modeling method based on the Req IF (Requirements Interchange Format, Req IF) standard to achieve structured constraints on the requirement content in the requirement modeling process and support the complete expression of the requirement content in the requirement model.

[0036] Of course, any product implementing the present invention does not necessarily need to achieve all of the advantages described above at the same time. BRIEF DESCRIPTION OF THE DRAWINGS

[0037] In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings required for describing the embodiments are briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without creative work.

[0038] Figure 1 A flow chart of a method for supporting complex system requirement integrity modeling and evaluation according to the present invention;

[0039] Figure 2 The template of the present invention constrains specific content;

[0040] Figure 3 Requirements completeness assessment criteria are constructed for the present invention. DETAILED DESCRIPTION

[0041] The following will be combined with the drawings in the embodiments of the present invention to clearly and completely describe the technical solutions in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. 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.

[0042] See also Figure 1-3As shown, the present invention is a method for supporting complex system requirement integrity modeling and evaluation, comprising the following steps:

[0043] Step 1: Build a Chinese general demand template;

[0044] Step 2: Combine the Chinese general requirement template with the requirement modeling standard Req IF;

[0045] Step 3: Constrain the content of requirement item attributes based on the Chinese general requirement template;

[0046] Step 4: Build a demand model;

[0047] Step 5: Construct requirements completeness assessment criteria;

[0048] Step 6: Evaluate the completeness of the attribute content of the requirement item;

[0049] Step 7: Modify the content that does not meet the requirements to a template that meets the requirements.

[0050] A method to support modeling and evaluation of complex system requirements integrity. In step 1, based on the EARS requirement template, a Chinese general requirement template is proposed. The specific contents are as follows:

[0051] (1) Universal requirements, describing the functions or behaviors that a system or entity should continuously perform at all times; the template structure is: <system name> should <system response>; for example, the autonomous driving system should continuously monitor the lane position;

[0052] (2) Event-driven requirements describe the response behavior of a system or entity when a specific trigger event occurs. It depends on the occurrence of a certain event or condition. The template structure is: when <optional prerequisite> <trigger>, <system name> should <system response>; for example, when a pedestrian is detected ahead, the autonomous driving system should slow down and stop.

[0053] (3) Unwanted behavior, describing the response measures that the system should take when encountering errors, failures, or deviations from expected user behavior; the template structure is: If <optional precondition> <trigger>, then <system name> should <system response>; for example, if a sensor fails, the autonomous driving system should immediately notify the driver and switch to manual driving mode;

[0054] (4) State-driven requirements describe the operations or behaviors that a system or entity should perform in a specific state. The template structure is: when <in a specific state>, <system name> should <system response>; for example, when a car is driving at high speed, the autonomous driving system should automatically maintain a safe following distance;

[0055] (5) Optional functional requirements, which describe the response that the system should perform when it has a specific feature or function. The template structure is: If has , <system name> should <system response>; for example, if the car has an automatic parking function, the autonomous driving system should prompt the driver to enable the automatic parking mode when a parking space is detected;

[0056] (6) Through the combination of the above templates, the complex requirements can be further constrained.

[0057] State-driven requirements + unwanted behaviors describe the response measures that the system should take when it encounters errors, failures, or deviations from expected user behaviors when the system is in a specific state; the template structure is: when <in a specific state>, if <optional precondition> <trigger>, then <system name> should <system response>; for example, when the car is in autonomous driving mode, if a sensor fails, the autonomous driving system should immediately notify the driver and switch to manual driving mode;

[0058] Event-driven requirements + unwanted behaviors, describing the response measures that the system should take when a specific trigger event occurs, when the system encounters an error, failure, or deviation from the expected user behavior; the template structure is: when <optional prerequisite 1><trigger>, if <optional prerequisite 2><trigger>, then <system name> should <system response>; for example, when a pedestrian is detected ahead, if the sensor fails, the autonomous driving system should slow down and notify the driver for manual intervention;

[0059] State-driven requirements + event-driven requirements describe the response behavior when a specific trigger event occurs when the system is in a specific state. The template structure is: when <in a specific state>, <optional prerequisite> <trigger>, <system name> should <system response>; for example, when a car is driving at high speed and detects an obstacle ahead, the autonomous driving system should automatically slow down and detour.

[0060] State-driven requirements + event-driven requirements + unwanted behaviors describe the response measures that should be taken when the system is in a specific state, a specific trigger event occurs, and an error, failure, or deviation from the expected user behavior is encountered; the template structure is: when <in a specific state>, <optional prerequisite 1> <trigger>, if <optional prerequisite 2> <trigger>, <system name> should <system response>; for example, when the car is driving at high speed and an obstacle is detected ahead, if the sensor fails at this time, the autonomous driving system should slow down and notify the driver for manual intervention.

[0061] A method for supporting modeling and evaluation of requirement integrity of complex systems. In step 2, in the requirement exchange format ReqI F, the requirement item SpecObject refers to a single requirement, and the content of the requirement is described by defining attributes. Therefore, the Chinese general requirement template is combined with the attribute content definition of the requirement item SpecObject to support the construction of the requirement item attribute content under the constraints of the Chinese general requirement template.

[0062] A method for supporting modeling and evaluation of complex system requirements integrity. In step 3, according to the Chinese general requirements template, the requirements item attribute content in the requirements model based on the Req IF standard is constrained to ensure that it complies with the template specifications; the constraints include keyword constraints and structure constraints, where "TEMPLATE_STRI NG" refers to the placeholder of the template, which is a variable of string type and is replaced according to the actual requirements of the complex equipment. The specific content of the template constraint is as follows: Figure 2 As shown in Table II.

[0063] A method for supporting modeling and evaluation of requirement integrity of complex systems. In step 4, the Req IF standard is used to model requirements, define requirement items, and define a set of attributes for each requirement item, such as requirement ID, requirement name, requirement description, priority, source, etc.; the attribute content of the requirement item is constructed under the constraint of a Chinese general requirement template. For example, for the requirement description attribute, the Chinese general requirement template is used to constrain the requirement description attribute content.

[0064] A method for supporting modeling and evaluation of complex system requirements integrity. In step 5, based on the Chinese general requirements template, natural language processing technology and regular expression matching technology are used to construct a requirement integrity evaluation criterion; the criterion is as follows: Figure 3 As shown in Table 3: (the regular expression ".*" means that it can match a string of any length).

[0065] A method for supporting modeling and evaluation of complex system requirements integrity, in step 6, evaluating whether the requirements in the requirements model conform to the Chinese general requirements template; specifically including:

[0066] 1. Extract the attribute content of the requirement items in the requirement model.

[0067] 2. Use natural language processing technology to analyze the extracted attribute content.

[0068] 3. Match the analysis results with the requirement completeness evaluation criteria. If it matches a template evaluation criterion, it is marked as conforming to the template; if it does not match any template, it is marked as not conforming to any template.

[0069] A method that supports modeling and evaluation of complex system requirement integrity. In step seven, the attribute content of the requirement item that does not meet any requirement integrity evaluation criteria is highlighted, and the evaluation result is output on the console: "This requirement does not meet any requirement template!" The user modifies the requirement content according to the error prompt until the requirement meets the Chinese general requirement template.

[0070] In the description of this specification, the description with reference to the terms "one embodiment", "example", "specific example", etc. means that the specific features, structures, materials or characteristics described in conjunction with the embodiment or example are included in at least one embodiment or example of the present invention. In this specification, the schematic representation of the above terms does not necessarily refer to the same embodiment or example. Moreover, the specific features, structures, materials or characteristics described can be combined in any one or more embodiments or examples in a suitable manner.

[0071] The preferred embodiments of the present invention disclosed above are only used to help illustrate the present invention. The preferred embodiments do not describe all the details in detail, nor do they limit the invention to the specific implementation methods described. Obviously, many modifications and changes can be made according to the content of this specification. This specification selects and specifically describes these embodiments in order to better explain the principles and practical applications of the present invention, so that those skilled in the art can understand and use the present invention well. The present invention is limited only by the claims and their full scope and equivalents.

Claims

1. A method to support modeling and assessment of requirements integrity for complex systems, Features: The steps include: Step 1: Build a Chinese general demand template; Step 2: Combine the Chinese general requirement template with the requirement modeling standard Req IF; Step 3: Constrain the content of requirement item attributes based on the Chinese general requirement template; Step 4: Build a demand model; Step 5: Construct requirements completeness assessment criteria; Step 6: Evaluate the completeness of the attribute content of the requirement item; Step 7: Modify the content that does not meet the requirements to a template that meets the requirements.

2. A method for supporting complex system requirement integrity modeling and evaluation according to claim 1, It is characterized in that In step 1, based on the EARS requirement template, a Chinese general requirement template is proposed. The specific contents are as follows: (1) Universal requirements, describing the functions or behaviors that a system or entity should continuously perform at all times; the template structure is: <system name> should <system response>; for example, the autonomous driving system should continuously monitor the lane position; (2) Event-driven requirements describe the response behavior of a system or entity when a specific trigger event occurs. It depends on the occurrence of a certain event or condition. The template structure is: when <optional prerequisite> <trigger>, <system name> should <system response>; for example, when a pedestrian is detected ahead, the autonomous driving system should slow down and stop. (3) Unwanted behavior, describing the response measures that the system should take when encountering errors, failures, or deviations from expected user behavior; the template structure is: If <optional precondition> <trigger>, then <system name> should <system response>; for example, if a sensor fails, the autonomous driving system should immediately notify the driver and switch to manual driving mode; (4) State-driven requirements describe the operations or behaviors that a system or entity should perform in a specific state. The template structure is: when <in a specific state>, <system name> should <system response>; for example, when a car is driving at high speed, the autonomous driving system should automatically maintain a safe following distance; (5) Optional functional requirements, which describe the response that the system should perform when it has a specific feature or function. The template structure is: If has , <system name> should <system response>; for example, if the car has an automatic parking function, the autonomous driving system should prompt the driver to enable the automatic parking mode when a parking space is detected; (6) Through the combination of the above templates, the complex requirements can be further constrained. State-driven requirements + unwanted behaviors describe the response measures that the system should take when it encounters errors, failures, or deviations from expected user behaviors when the system is in a specific state; the template structure is: when <in a specific state>, if <optional precondition> <trigger>, then <system name> should <system response>; for example, when the car is in autonomous driving mode, if a sensor fails, the autonomous driving system should immediately notify the driver and switch to manual driving mode; Event-driven requirements + unwanted behaviors, describing the response measures that the system should take when a specific trigger event occurs, when the system encounters an error, failure, or deviation from the expected user behavior; the template structure is: when <optional prerequisite 1><trigger>, if <optional prerequisite 2><trigger>, then <system name> should <system response>; for example, when a pedestrian is detected ahead, if the sensor fails, the autonomous driving system should slow down and notify the driver for manual intervention; State-driven requirements + event-driven requirements describe the response behavior when a specific trigger event occurs when the system is in a specific state. The template structure is: when <in a specific state>, <optional prerequisite> <trigger>, <system name> should <system response>; for example, when a car is driving at high speed and detects an obstacle ahead, the autonomous driving system should automatically slow down and detour. State-driven requirements + event-driven requirements + unwanted behaviors describe the response measures that should be taken when the system is in a specific state, a specific trigger event occurs, and an error, failure, or deviation from the expected user behavior is encountered; the template structure is: when <in a specific state>, <optional prerequisite 1> <trigger>, if <optional prerequisite 2> <trigger>, <system name> should <system response>; for example, when the car is driving at high speed and an obstacle is detected ahead, if the sensor fails at this time, the autonomous driving system should slow down and notify the driver for manual intervention.

3. A method for supporting complex system requirement integrity modeling and evaluation according to claim 1, It is characterized in that In step 2, in the requirement exchange format Req IF, the requirement item SpecObject refers to a single requirement, and the content of the requirement is described by defining attributes. Therefore, the Chinese general requirement template is combined with the attribute content definition of the requirement item SpecObject to support the construction of the requirement item attribute content under the constraints of the Chinese general requirement template.

4. A method for supporting complex system requirement integrity modeling and evaluation according to claim 1, It is characterized in that In step 3, according to the Chinese general requirement template, the requirement item attribute content in the requirement model based on the Req IF standard is constrained to ensure that it complies with the template specifications; the constraints include keyword constraints and structure constraints, among which "TEMPLATE_STRING" refers to the placeholder of the template, which is a variable of string type and is replaced according to the actual requirement content of the complex equipment. The specific content of the template constraints is shown in Table 2.

5. A method for supporting complex system requirement integrity modeling and evaluation according to claim 1, It is characterized in that In step 4, the Req IF standard is used to model the requirements, define requirement items, and define a set of attributes for each requirement item, such as requirement ID, requirement name, requirement description, priority, source, etc.; the attribute content of the requirement item is constructed under the constraints of the Chinese general requirement template. For example, for the requirement description attribute, the Chinese general requirement template is used to constrain the requirement description attribute content.

6. A method for supporting complex system requirement integrity modeling and evaluation according to claim 1, It is characterized in that In step five, based on the Chinese general requirement template, natural language processing technology and regular expression matching technology are used to construct the requirement completeness evaluation criteria; the criteria are shown in Table 3: (the regular expression ".*" means that it can match a string of any length).

7. A method for supporting complex system requirement integrity modeling and evaluation according to claim 1, It is characterized in that In step 6, evaluate whether the requirements in the requirements model conform to the Chinese general requirements template; specifically include:

1. Extract the attribute content of the requirement items in the requirement model.

2. Use natural language processing technology to analyze the extracted attribute content.

3. Match the analysis results with the requirement completeness evaluation criteria. If it matches a template evaluation criterion, it is marked as conforming to the template; if it does not match any template, it is marked as not conforming to any template.

8. A method for supporting complex system requirement integrity modeling and evaluation according to claim 1, It is characterized in that In step seven, the attribute content of the requirement items that do not meet any requirement integrity assessment criteria is highlighted, and the assessment result is output to the console: "This requirement does not meet any requirement template!" The user modifies the requirement content according to the error prompt until the requirement meets the Chinese general requirement template.

Images