Guideline#

Architectural Design		status: valid
status: valid tags: architecture_design is contained by: wf__cr_mt_featarch, wf__cr_mt_comparch, wf__mr_vy_arch

gd_guidl__arch__design		Process Guideline

The guideline focuses on the steps which need to be performed in order to create the architectural design. The concept behind those steps is described in the Architecture Process

General Hints#

Attributes#

For all architectural need elements following mandatory attributes are defined:

Overview of mandatory attributes#
Title	ID
Architecture attribute: fulfils	gd_req__arch__attr_fulfils
Architecture attribute: safety	gd_req__arch__attr_safety
Architecture attribute: status	gd_req__arch__attr_status
Architecture attribute: UID	gd_req__arch__attribute_uid
Architecture attribute: security	gd_req__arch_attr_security

Checks#

For architectural elements following checks are defined:

Overview of checks on architectural elements#
Title	ID
Architecture mandatory attributes	gd_req__arch__attr_mandatory
Architecture linkage requirement	gd_req__arch__linkage_requirement
Architecture linkage requirement type	gd_req__arch__linkage_requirement_type
Architecture linkage safety	gd_req__arch__linkage_safety
Architecture linkage safety	gd_req__arch__linkage_safety_trace
Architecture linkage security	gd_req__arch__linkage_security_trace

Workflow for creating an architectural design#

This chapter describes the general guideline for architectural design within the project. In general the workflow for creating an architectural design is shown in Architecture Design Workflow

Those steps are:

Table 24 Definition of the static architectural elements#
Step	Description	Responsible
	Create feature architecture (Concept)	Contributor
	Model feature architecture	Contributor
	Allocate feature requirements to architectural elements	Contributor
	Review architectural design	Committer
	Merge architectural design into score repository	Committer
	Create component architecture (Concept) Allocate component requirements to architectural elements	Contributor
	Model component architecture	Contributor
	Review component architecture	Committer
	Merge component architectural design into module	Committer

Create feature architecture (Concept)#

The feature architecture (= high level architecture) shall be created in the feature tree of the platform repository. As a starting point a template (gd_temp__arch__feature) is available.

Based on this template the feature architecture shall describe the concept of the feature including supporting figures and drawings.

For this step following guidances are available:

Model feature architecture#

Based on the concept description a model of the feature architecture should be designed. It shall consist of the logical interfaces which the user of the feature can access including also the modules which provide the interfaces. Therefore following elements shall be used:

Table 25 Architectural Elements of the Feature Architecture#
Element	Sphinx directive	VS Code Template
Feature Architecture	feat_arc_sta	feat_arc_sta_t
Logical Interface	feat_arc_int	feat_arc_int_t
Logical Interface Operation	feat_arc_int_op	feat_arc_int_op_t

The relations of those elements are described in Fig. 19.

Note

For the modeling of the architecture a sphinx extension is available: Architecture Generation for Sphinx-Needs

An example for modeling the architecture can be found here

Allocate feature requirements to architectural elements#

In the next step the already derived feature requirements shall be allocated to the architectural elements depending on the content of the requirement. Functional Requirement may either be allocated to static or dynamic architecture. Interface requirements shall only be allocated to the interface architecture.

If needed also additional feature requirements, which may arise due to architectural decisions, should be created and allocated to the feature architecture itself.

Those links shall be established from architectural elements to feature requirements via the attribute fulfils

Review architectural design#

As soon as the design is in a mature state it can be reviewed according to <TBD> and merged into the main branch of the score repository.

For the review process a checklist template is available: Architecture Inspection Che...

Following roles should be included in the review:

Create component architecture (Concept)#

Based on the feature architecture the concept for the component architecture shall be created in the SW module. It shall describe which components need to be created and how they correlate with each other in order to provide the required functionality. As a starting point a template (gd_temp__arch__comp) is provided.

For this step following guidances are available:

Allocate component requirements to architectural elements#

In this step the component requirements shall be derived (see Requirements Guideline) and allocated to the architectural elements via the attribute fulfils.

Model component architecture#

According to the architecture design description the model for the component architecture shall be created. It shall consist of components, real interfaces and real interface operations. Depending on the size of the component it can also be split into multiple (sub) components.

Table 26 Architectural Elements of the Component Architecture#
Element	Sphinx directive	VS Code Template
Component Architecture	comp_arc_sta	comp_arc_sta_t
(Real) Interface	comp_arc_int	comp_arc_int_t
(Real) Interface Operation	comp_arc_int_op	comp_arc_int_op_t

The relations of those elements are described in Fig. 19

Review component architecture#

As soon as the design is in a mature state it can be reviewed according to <TBD> and merged into the main branch of the module repository.