Requirements Management for Sparx Enterprise Architect

  Libor Buš news share

Connect requirements in ReqView with SysML models in Sparx Enterprise Architect (EA) to streamline MBSE and improve traceability through development of complex HW/SW systems.

Table of Contents

Bring Requirements and Design Together

Have you ever felt a disconnect between high-level requirements and detailed design of your HW/SW product? It's a common challenge for systems engineers.

You have a well-defined set of stakeholder requirements from your customer, but the architecture, behavior, and structure of the solution is modeled in an Model Based Systems Engineering (MBSE) tool without proper linking to requirements.

Disconnected requirements and design creates several issues:

  • Lack of Traceability: You waste enormous efforts from inconsistencies like missed requirements or solution over-engineering due to inconsistent traceability between requirements and design.

  • Manual Propagation of Requirement Changes: Every time requirements change, you have to manually update design. This is very time-consuming and prone to errors if design is not linked to requirements properly.

  • Siloed Teams: Separation of requirements and design teams and using different tools can lead to communication breakdowns and a disjointed understanding of the system.

    • The requirements team relies on Requirements Management (RM) tools to efficiently manage large sets of stakeholder requirements, derive system requirements and detailed low-level requirements (HW, SW, or mechanical), and maintain end-to-end traceability across the V-model.

    • The design team models the solution using MBSE tools supporting Systems Modeling Language (SysML), Arcadia or another systems engineering method. While these tools support requirements modeling, they are not user-friendly for handling the common RM use cases for more than dozens of requirements.

These issues can slow down your development cycle, increase the risk of defects, and make it nearly impossible to prove compliance with industry standards like ISO 26262, DO-178C, IEC 62304, or EN 50128.

But what if you could have a seamless connection between requirements and design teams?

Integrated RM and MBSE Workflow Using ReqView and EA

The seamless integration between ReqView requirements management tool and Sparx EA MBSE tool allows both requirements and design teams to work in their preferred tools and collaborate effectively, while ensuring bi-directional synchronization and end-to-end traceability between the artifacts.

Let’s demonstrate that on synchronization of system requirements and design.

Integrate ReqView requirements management and Enterprise Architect model-based systems engineering (MBSE) tools

1. Capture and Manage Requirements in ReqView

Requirements engineers use ReqView as the primary source of truth for all requirements through development.

In the requirements phase, requirements engineers import or capture stakeholder requirements and transform them into formal, controlled system requirements:

  1. Import stakeholder requirements from various external sources, such as Word, Excel files or from other RM tools via Requirements Interchange Format (ReqIF) files into centralized ReqView projects.
  2. Capture additional information for stakeholder requirements to enable requirements filtering, sorting and reporting. For instance, define custom attributes Type, Source or Priority for easier prioritization workflow.
  3. Control Versions of stakeholder requirements using Git or Subversion (SVN) version control systems. Track requirements changes including all documents, attributes, and traceability links. Compare project versions (commits) to see changes side by side. Create baselines (tags) to establish approved versions of stakeholder requirements providing the necessary evidence for contractual compliance.
  4. Derive system requirements from stakeholder requirements. Organize system requirements in structured documents and document sections grouping requirements logically (e.g. by features) to manage system complexity.
  5. Link system requirements to source stakeholder requirements. Browse requirements traceability using Requirements Traceability Matrix (RTM) views.
  6. Review system requirements to ensure they are clear, testable, and complete. Review the requirements traceability to prove that every system requirement is justified, and conversely, that every stakeholder requirement is addressed. Baseline approved version of system requirements.
  7. Analyze impact of stakeholder requirements changes to see which derived system requirements (and further design elements, low-level requirements, etc.) are affected by the change, preventing inconsistencies and wasted effort.

Example: ReqView traceability view for the document SRS in the Example Project displays in the column User Needs satisfaction traceability links from derived SW requirements to top-level stakeholder requirements (NEEDS).

Capture and manage requirements in ReqView

2. Export Requirements from ReqView to EA

When system requirements are reviewed and baselined they can be passed to the system design phase. Requirements engineers export high-level requirements to an EA model used by the design team to derive the architecture and design.

The integration enables configuration of data mapping between ReqView and EA:

  • ReqView Document → EA Package: Select the target EA model and a package where the requirements from a ReqView document will be exported.

  • ReqView Objects → EA Model Elements: Define how to export requirements from ReqView to model elements in EA. For instance, EA model elements with the stereotype «functionalRequirement» are created from ReqView objects with the attribute Type set to "Functional Requirement".

  • ReqView Description → EA Element Notes: Define how to set the rich text requirement description in EA element notes from a given ReqView attribute (such as Text) or a template column.

  • ReqView Attributes → EA Tagged Values: Map selected ReqView attributes (like Priority or Status) to Tagged Values on the corresponding model element in EA.

  • ReqView Links → EA Relationships: Map selected ReqView link types (e.g., Satisfaction links) to specific relationship stereotypes in EA (e.g., «trace»).

Example: Export of the document SRS from ReqView to the EA package ReqView Model > ReqView Requirements > SW Requirements preserves requirements hierarchy, ID, text description, attributes and links to user needs.

Export requirements from ReqView to EA

3. Design Solution in EA

The EA model serves as the primary source of truth for system design through development. With the high-level system requirements in the EA model, design engineers use the SysML modeling capabilities of EA and follow an MBSE approach.

For instance, SYSMOD – The Systems Modeling Toolbox suggests the following pragmatic MBSE methods to derive the system architecture and design from system requirements:

  • System Context: Model the system context using a SysML Block Definition diagram to identify system actors (users or external systems). Model the system information flow using a SysML Internal Block diagram to identify information flow between the system and the actors and its interaction points (activity ports).

  • System Use Cases: Model the system behavior using SysML Use Case diagrams to identify functionality provided by the system (use cases). Model use cases using SysML Activity diagrams to identify functional flows (activities) including the main scenario, exceptions and variants and activity input/output data (pins). Link derived use cases to the source system requirements using the relationship with the SysML stereotype «realize» to ensure requirements traceability.

  • System Interactions: Model the interaction between the system and its actors using SysML Sequence diagrams.

  • System Interfaces: Model the system interaction points (interfaces) using SysML Block Definition diagram. For each interface describe its services and data flows.

  • System Structure: Model the system structures (blocks) using SysML Block Definition and Internal Block diagrams. Link blocks to the system requirements using the relationship with the SysML stereotype «trace».

  • System States: Model the behavior of the relevant blocks using SysML Sequence or State Machine diagrams to show how the architectural elements interact to fulfill a specific use case scenario.

The critical activity for maintaining end-to-end traceability is linking the derived design model elements back to the system requirements. This ensures that any proposed change to a system requirement can be analyzed for its impact on the system architecture and design. EA provides three options for linking model elements: Traceability Window, Relationship Matrix and SysML Requirement Diagrams.

Example: The EA package ReqView Model > ReqView Implementation stores the design model derived from imported SW requirements. The diagram SW Package Diagram models structure of SW packages implementing SW requirements. The block CSVExport in package Data Export implements SW requirement SRS-77.

Derive design model from SW requirements imported to EA

4. Import Design Documentation from EA to ReqView

When system design is finished, requirements engineers import the design documentation from a selected package in the EA design model into a ReqView document preserving diagrams, the structure of model elements and traceability links to trace system requirements to design in ReqView.

The integration enables configuration of import:

  • EA Package → ReqView Document: Select the source EA model and its package which will be imported into the ReqView document.

  • EA Model Elements → ReqView Objects: ReqView document objects are created with Description, URL, Type, Stereotype, Author, Status and Modified attributes set from the source EA model element by default. ReqView document preserves hierarchy of imported EA model elements.

  • EA Diagrams → ReqView Attachments: EA diagrams are imported as image attachments in SVG format.

  • EA Tagged Values → ReqView Attributes: If needed, map Tagged Values of imported EA model elements to ReqView custom attributes.

  • EA Relationships → ReqView Links: Map relationship stereotypes in EA (e.g. «trace») to ReqView link types (e.g. implementation) to import links from the EA model leading from design to requirements model elements.

Example: The ReqView document EA-ARCH is created by import from the EA package ReqView Model > ReqView Implementation. It contains the SW Package Diagram followed by hierarchy of EA model elements in the imported package. The column URL displays a navigable link to the EA model.

Import design model from EA to ReqView

5. Review Traceability Between Requirements and Design in ReqView

When the design documentation is imported or updated in ReqView, requirements engineers review the traceability between requirements and design:

  • Traceability Views: Set up ReqView table views displaying Requirements Traceability Matrix (RTM) between system requirements and system design. Filter system requirements not covered by design (without any implementation link) to check design completeness easily. Quickly assess the impact of a proposed change to system requirements by seeing all derived design elements.

  • Traceability Reports: Export traceability reports for requirements and design to Word, Excel, HTML, PDF, CSV and other structured text file formats to provide external reviewers consistent and traceable view of how the EA design elements satisfy the ReqView requirements.

Example: The table view Traceability in the ReqView document NEEDS displays top-level stakeholder requirements and traceability coverage to SW requirements and the design model imported from EA.

Review traceability between requirements and design in ReqView

6. Derive Low-level Requirements in ReqView

Using the high-level requirements, the design documentation, and traceability between requirements and design, requirements and design engineers collaborate directly in ReqView to allocate system requirements to system components and derive detailed low-level requirements.

The synchronization workflow between ReqView and EA can be iteratively repeated for every new baseline of stakeholder or system requirements. Furthermore, the workflow is applicable to any lower V-model level to ensure complete and traceable derivation of low-level requirements.

7. Manage Development of Low-level Requirements in Jira

When low-level requirements are finalized for development, requirements engineers use the ReqView integration with Jira to export them as actionable work items in Jira. Development teams then manage the implementation of these items in Jira, which retains seamless traceability from work items back to the top-level requirements.

Try ReqView With EA

Try ReqView integration with EA and see how both tools can help with the development of your HW/SW product. You can evaluate the integration easily. We have configured the Example Project for exporting epics and users stories from the document NEEDS, SW requirements from the document SRS, and the document EA-ARCH to import design from the EA model.

  1. Download ReqView for your platform and install it.
  2. Request ReqView Trial to supporting all advanced ReqView features. Click Edit > Preferences > Integrate with Enterprise Architect to enable the integration with EA.
  3. Download the ReqView Example Project for EA and open it in ReqView.
  4. Download the Example EA Model into the same folder as the ReqView project and open it in EA.
  5. In ReqView, open the document NEEDS and click File > Enterprise Architect > Synchronize Document to export stakeholder requirements (user stories) to EA. In EA, browse package ReqView Model > ReqView Requirements > Needs containing exported stakeholder requirements.
  6. In ReqView, open the document SRS and click File > Enterprise Architect > Synchronize Document to export SW requirements to EA. In EA, browse the package ReqView Model > ReqView Requirements > SW Requirements containing exported SW requirements.
  7. In EA, open the diagram SW Package Diagram located in package ReqView Model > ReqView Implementation. In ReqView, open the document EA-ARCH, click File > Enterprise Architect > Synchronize Document to update it from the EA package ReqView Model > ReqView Implementation. Browse the document EA-ARCH containing imported design documentation.
  8. In ReqView, select the table view Traceability in documents NEEDS and SRS to review the traceability matrix between requirements and design.
  9. In ReqView, click File > Export > XLSX File to export the traceability matrix to Excel for external review.

Do you need an integrated MBSE solution for requirements management and design of your HW/SW product?

  DOWNLOAD  FREE TRIAL

Try ReqView integration with EA! Start with an example project easily.

Learn More


Popular Blog Posts