Which of the following design processes refers to the identification of subsystems and their relationships?

II.B Summary

Our system model recognizes the need to support interfaces to external controlled objects (COs) that either change continuously or in discrete steps. Within the computer system real-time entities (RTSV) will track the behavior of these external objects. A system designer has the choice of making the computer system entirely time-triggered, in which case all COs are polled, or to be event-triggered, in which case continuously COs are polled but discrete COs give rise to events that are directly represented and supported. The decision of which methods to use must take into account the temporal characteristics of the external COs and the structure and reliability of the electronics needed to link each external object to the computer system's interface.

We have defined an ET interface that allows state data and events ports to be used. All communication through an interface is unidirectional. Such interfaces link the computer system to its environment and are used internally to link distinct subsystems. Events themselves give rise to state changes in which the final state of the RTSV is specified (not a delta change).

In the next section we develop the computational model that allows the internal behavior of the computer system (or subsystem) to be specified and analyzed. This will enable the temporal obligation defined in the system's interface to be realized.

5 Conclusions

In this work, the MIMO-NARX model has been developed for batch esterification process by decomposing the NARX model into two MISO sub-system models. In NARX model identification, the model performance is studied based on the selected number of input and output lags. The model order nu = 2 and ny = 2 for NARX: y1t) and nu=1 and ny= 2 for NARX: y2 (t) has been chosen as the best model order to represent the real process data. Finally, it can be concluded that, the developed NARX models are effective to represent the process system in batch esterification reactor.

12.1.1 The Roadrunner Model

In this figure, we see two high level packages. The first – SEModel – holds the systems engineering information and is composed of packages as we expect. The second – SSModel – is focused on the subsystem design. SSModel has three singular packages – InterfacesPkg, CommonTypesPkg, and Domains – that hold information shared by the subsystems. In addition, SSModel has the SS1Pkg, which holds the basic structure that will be replicated for all subsystems, once we identify them. I didn’t put the otherwise-imported SSSpec package in the SS1Pkg because it can be directly referenced from its location in the SEModel package now, since it is all in one model.

8.3 Gather Subsystem Specification Data

For the purpose of this task, there are two kinds of engineering data to gather for the handoff—data within the SysML model and other data of interest to the handoff. I’ll address these two different sets of data separately in the following sections.

8.3.1 Gathering SysML Model Data

Back in Chapter 3, Figure 3.12 shows the recommended system engineering model organizational schema. The basic organization of information for the handoff is located with the architectural design package of the systems engineering model (Figure 8.2).

Figure 8.2. Model organization to support the handoff.

The data to be handed off is exclusively found in the Architectural Design Package (ArchDesignPkg in the figure). This package contains three uses of nested packages:

•

SSnPkg

There is one package here per subsystem. This package contains the requirements allocated to the subsystem, its subsystem-level use cases, and the functional analysis models for those use cases. Each subsystem model will import its corresponding subsystem specification package from the systems engineering model.

•

InterfacesPkg

This package contains the logical interfaces (including interface blocks) provided or required by those interfaces. Because this information inherently involves more than one architectural element, it will provide the basis for the physical interface definitions in the Shared Model. Depending upon its complexity, it may be subdivided into internal packages.

•

TypesPkg

This package contains the logical data types and flow item specifications used by the interfaces in the package above.

This organization is meant to ease the handoff of the information. Each subsystem team has a single place where it needs to go to get it’s specification and the shared model has only two packages that it must import and adapt.

8.3.2 Gathering Other Engineering Data

The requirements, interfaces, and shared data schema form the primary sets of data that must be handed downstream. However, systems engineering may have a great deal of other data to be handed down as well, and much of these data may be in other formats and tools. This includes:

•

process guidelines and standards,

•

work product standards,

•

project plan,

•

project schedule and work items,

•

certification plan,

•

dependability analyses (including safety, reliability, and security analyses),

•

performance analyses,

•

test plans,

•

trace data,

•

configuration data.

Because this information is likely to be held in many different repositories, formats, and tools, I recommend the creation of a Handoff Index document (which can be a diagram in the subsystem specification package with hyperlinks to actual data) that links all of the data to be handed off. Figure 8.3 shows an example of a handoff index as a diagram to be found within the architectural design package of the systems engineering model. The underlined texts are hyperlinks that either go to the appropriate work product or area in the model or bring up the work product in its associated tool.

Figure 8.3. Handoff index.

2.6.5 Regression Equations

Physical correlations that exist among and between variable components of a physical system embody the principle of cause and effect. In general, these correlations consist of causal elements that effect entropic changes, changes that are nonlinear with respect to time. However, in some instances variable components are related only by statistical correlations. Both types of correlation are represented quite simply at Δt increments of time by linear regression equations that express physical and/or statistical correlations between variables within the circumscribed system (model world). Multiple linear regression has the following form:

Xk= c0+∑j=1ncjXj,

where k ≠ j, and cj need not be unity valued and can be zero. In standard statistical applications, regression relationships are selected from various predicting equation forms, for example, linear, nonlinear, exponential, and so on. In systems modeling, regression equations are selected from various linear dynamic forms.

System variables may also interact with one or more external variables (outside the circumscribed system) in establishing system levels. Although circumscription omits (by excluding) these variables, it may be advantageous to integrate their average (lumped) effect into the model, thereby to impact the system balance equation. Regression equations provide structure for implicit inclusion of external variables. The average, nonzero effect of omissions is modeled by the constant term c 0. As shown in Chapter 1, the regression equation can be viewed as an incomplete balance equation whose cj values have been adjusted above or below unity to compensate for these omissions. An expanded (more micro) model is obtained by differentiating (dividing) the lumped effect of external variables into system variables for explicit inclusion in the balance equation(s) of additional subsystem(s).

3.4.6 Are Models Documentation?

In MBD, we are often met with the “models are documentation” fallacy that we believe has further perpetuated the lack of proper documentation across industries using MBD. However, any engineer responsible for maintaining real-world industrial-size Simulink models understands that a Simulink model is notoriously hard to reverse engineer or maintain without additional information about the model that can be documented in an SDD. For example, Simulink lacks facilities to explicitly represent the interface inputs/outputs of a model/subsystem. This issue was discussed and suggestions were made in [23]. Also, a model does not contain rationale for design decisions. However, experience teaches us that documenting rationale is crucial for proper software development and maintenance.

We illustrate the importance of having a good SDD by an anecdotal story from our collaboration with one of our industrial partners. Their newly hired engineer was tasked with maintaining a Simulink model implementing algorithms within his expertise area. There was no documentation associated with the model. Although the engineer was very familiar with the model’s algorithms and their application, comprehending the model took approximately 2 months due to the fact that no requirements specification, and particularly, design documentation, existed for this model. As a result, every part of the model had to be manually examined and understood. After reverse engineering the model, the engineer asked for our help with documenting the model to significantly ease the maintenance efforts in the future. This is not the only instance of such setbacks we saw, and it clearly illustrates that even a domain expert, with all of the relevant background knowledge, is still hampered significantly by a lack of documentation. Again, this is a clear example that the Simulink model is not the requirements, nor effective documentation in and of itself.

11.5 Performing Architecture Analysis

11.5.1 Structure views

The Structure viewpoint defines several noun and verb concepts that represent architectural elements of the system of interest, such as subsystems, layers, and packages, and define the traceability of these elements to other KDM facts for the same system. The Structure viewpoint is defined by the following considerations:

Concerns

•

What are the structural elements of the system, and what is the organization of these elements?

•

What software elements compose the system?

•

How are the structural elements of the system related to the computational elements?

•

What are the connections of these elements based on the relationships between the corresponding computational elements?

•

What are the interfaces of the structural elements of the system?

Analytic methods

The Structure architectural viewpoint supports the following kinds of analysis:

•

Dependencies (are components properly connected?)

•

Coupling and cohesion (the number of internal relationships within a component compared to the number of relationships to other components)

•

Efferent and afferent relationship (uses of a component by other components and uses of other components by the given component)

•

Interfaces (what is the required and provided interface of the given component?)

Construction methods

•

Structure views that correspond to the KDM Structure architectural viewpoint are usually constructed by analyzing the architecture models of the given system. The Structure extractor tool uses knowledge of the architecture models to produce one or more Structure views as output.

•

As an alternative, Structure views can be produced manually using the input from the architect of the system and architecture documentation.

•

Construction of the Structure view is determined by the architectural description of the system.

•

Construction of the Structure views corresponding to a particular architectural description may involve additional information (system-specific or architecture-specific). This information can be attached to KDM elements using stereotypes, attributes, or annotations.

The organization of the system may be presented as a single Structure view or as a set of multiple Structure views showing layers, components, subsystems, or packages. The reach of this representation extends from a uniform architecture to an entire family of module-sharing subsystems.

The Structure model owns a collection of StructuralElement instances.

Packages are the leaf elements of the Structure model, representing a division of a system's Code modules into discrete, nonoverlapping parts. An undifferentiated architecture is represented by a single Package.

The StructuralGroup recursively gathers StructuralElements to represent various architectural divisions. The Software System subclass provides a gathering point for all the system's packages directly or indirectly through other Structure elements. The packages may be further grouped into Subsystems, Layers, and Components, or Architecture views.

Structure views are used in combination with Code views, Data views, Platform views, UI views, and Inventory views. Structure elements are the main “locations” of the system of interest for the purpose on integrating various non-KDM vocabularies, in particular the operational and system views, threats, and risks.

Figures 41 and 42 illustrate the noun and verb concepts of the KDM Structure viewpoint.

Figure 41. The noun concepts of the Structure viewpoint

Figure 42. The verb concept of the Structure viewpoint

Relationships of the Structure views are entirely defined by the mechanism of aggregated relations. The only relationship defined in the Structure view established the vertical traceability links between the system elements (instances of the noun concepts of the Structure vocabulary) and other KDM elements. The next diagram, Figure 43, illustrates an architecture significant Structure view of the Clicks2Bricks system (from the case study that is described in Chapter 12).

Figure 43. Example of the Structure view at a less detailed level of resolution

The view at Figure 43 maps the entire code base of the Clicks2Bricks into the elements of the Model-View-Controller architecture pattern. The facts in Figure 43 can be verbalized using the SBVR Structured English as follows:

There exists Subsystem with name “View.”

There exists Subsystem with name “Controller.”

There exists Subsystem with name “Model.”

Subsystem “View” depends on Subsystem “Model.”

Subsystem “View” depends on Subsystem “Runtime Paltform APIs.”

Subsystem “Model” depends on Subsystem “Runtime Paltform APIs.”

Subsystem “Controller” depends on Subsystem “View.”

Subsystem “Controller” depends on Subsystem “Model.”

Subsystem “View” depends on Subsystem “Runtime Paltform APIs.”

Figure 43 shows that Subsystems “Model,” “View,” “Controller,” and “Runtime Platform APIs” cover an entire set of system facts. This is based on the absence of relations to ENV nodes and from ENV nodes (to and from the rest of the system), as well as on the understanding that the KDM system model is a closed system that contains all known facts about the system of interest (within the scope of the model). Under these assumptions, the above view is evidence for the claim that the Subsystem “Model” depends only on the entities inside the subsystem “Runtime Platform APIs.”

11.5.2 Conceptual views

The Conceptual viewpoint defined in the KDM Conceptual package provides constructs for creating a linguistic and behavior models during the analysis phase of knowledge discovery from the existing code.

The Conceptual viewpoint is defined by the following considerations:

Concerns

•

What domain concepts are implemented by the system?

•

What are the behavior elements of the system?

•

What business rules are implemented by the system?

•

What scenarios are supported by the system?

Analytic methods

The Conceptual viewpoint supports the following main kinds of checking:

•

Conceptual relationships (what are the relationships between conceptual entities, based on their implementation by the Code and Data entities?)

•

Scenario flow (what are the control-flow relationships between the two scenarios based on the flow between action elements referenced by each scenario?)

•

BehaviorUnit coupling (what are the control-flow and data-flow relationships between two behavior units based on the action elements referenced by each behavior unit?)

•

Business Rule analysis (what is the logic of the business rule based on the action elements referenced by the business rule?)

Conceptual views are used in combination with Code views, Data views, Platform views, UI views, and Inventory views.

Construction methods

•

Conceptual views can be produced manually using the input from the information analysis and the architect of the system and architecture documentation.

•

Construction of the Conceptual view is determined by the domain model and the architectural description of the system.

•

Construction of the Conceptual views corresponding to a particular architectural description may involve additional information (system-specific or architecture-specific). This information can be attached to KDM elements using stereotypes, attributes, or annotations.

The Conceptual Model enables mapping of KDM compliant model to models compliant to other specifications. Currently, it provides “concept” classes—TermUnit and FactUnit facilitating the mapping to SBVR specification, described in Chapter 10.

KDM TermUnit is a representation of the SBVR noun concept or SBVR individual concept as a first-class citizen on a KDM view. This element can be further connected to its implementation by lower-level KDM elements for the Code, Data, UI and Platform views by the vertical traceability links using the “is implemented by” relationships. This is the key to mechanism for using KDM as the nucleus of the Common Fact Model and importing the vocabularies, defined in Chapters 4–74567 in a KDM-compliant tool for the purpose of establishing the integrated system model.

Similarly, a KDM FactUnit is a representation of the SBVR verb concept in the integrated fact model. KDM RuleUnit element is the representation of the SBVR elements of behavior guidance.

The Conceptual Model also provides “behavior” types—BehaviorUnit and ScenarioUnit that support mapping to various external models, including but not limited to activities/flow chart and swim lane diagrams, and use case scenarios. The following explains the difference between these “behavior” types:

•

BehaviorUnit represents a behavior graph with several paths through the application logic and associated conditions. The “implementation” of this graph is provided by the ActionElements connected with Flow relations, from the Program Elements KDM layer. The graph can be as small as a single ActionElement. BehaviorUnit is an “abstraction” of ActionElements since it provides a modeling element for representing a collection of ActionElements that is meaningful from the application domain perspective, and further manipulates with this representation as a first-class citizen of the ConceptualModel of KDM.

•

ScenarioUnit represents a path (or multiple related paths) through the behavior graph. For example, ScenarioUnit corresponds to a trace through the systems, or a “use case.” ScenarioUnit can own an entire collection of BehaviorUnits, connected with ConceptualFlow elements, and can thus represent a slice of the original behavior graph in implementing the software system. The conditions responsible for navigation between alternative paths within the graph can be represented as RuleUnits.

•

RuleUnit represents a condition, a group of conditions, or a constraint. RuleUnit is a representation for some meaningful navigation conditions within behavior graphs represented by several BehaviorUnits.

11.5.2.1 Linguistic viewpoint

The purpose of Linguistic elements is to provide a bridge between low-level, physical, and implementation viewpoints and high-level policy documents describing the business rules of the system of interest. Also, systematic traceability from domain-specific vocabulary terms all the way down to the individual code elements provides an efficient way of navigating the system and allows assurance of certain evaluation activities.

Figure 44 illustrates the noun concepts of the KDM Linguistic viewpoint.

Figure 44. The noun concepts of the Linguistic viewpoint

The next diagram, Figure 45, illustrates the verb concepts of the Linguistic viewpoint.

Figure 45. The verb concepts of the Linguistic viewpoint

Figure 46 illustrates KDM linguistic facts for a fragment of the Conceptual Model for Clicks2Bricks system, described in more detail in Chapter 12.

Figure 46. Example of the KDM linguistic facts in the Conceptual view

11.5.2.2 Behavior viewpoint

The purpose of Behavior elements is to provide a bridge between low-level, physical, and implementation viewpoints and high-level functional views of the system of interest. Also, systematic traceability from the system functions all the way down to the individual code elements provides an efficient way of navigating the system and allows assurance of certain evaluation activities.

The next two diagrams, Figures 47 and 48, illustrate the concepts of the KDM Behavior viewpoint.

Figure 47. The noun concepts of the Conceptual viewpoint: behavior

Figure 48. The verb concepts of the Conceptual view: behavior

BehaviorUnit is a named unit of functionality, defined by the vertical traceability links to other KDM elements (for example, to ActionElements). In addition, direct “flows into” facts involving BehaviorUnits can be generated if needed.

Figure 49 illustrates KDM BehaviorUnits by using a fragment of the Data-Flow Diagram describing Clicks2Bricks system from Chapter 12.

Figure 49. Example of the behavior facts in the KDM Conceptual view

Abstract

As part of the drive for global food security, all nations will need to intensify food production, including those situated in hyper arid climates. The State of Qatar is one such example of a national system that whilst it is presented with environmental challenges, seeks to enhance food security. The energy, water and food (EWF) nexus approach is an effective means to accurately ascertain resource consumption, identify synergies and trade-offs, and quantify environmental burdens in the delivery of products and services. The EWF nexus theory has been uniquely applied to a hypothetical food system in Qatar where sub-system model’s representative of EWF systems are developed. It has been suggested that the fertilization of agricultural systems with CO2 can enhance their productivity. The study described in this paper considers the life cycle yield improvements which can be made possible at the farm level by utilizing the captured CO2. This requires a modification of the EWF nexus model to consider the spatial characteristics of the modelled elements. The newly built model is used to investigate the CO2 transport methods (pipeline and truck), and distance that CO2 captured from combined cycle gas turbine (CCGT) and biomass integrated gasification combined cycle (BIGCC) sub-systems which may then be transported for CO2 fertilization, and yield improvements to be justified from an energy utilization perspective. In this regard, an integrated analysis using GIS-based optimization is applied where the sub-systems are represented as geospatial elements together with their design constraints, such as the capacity-related parameters of the fertilization systems, and the energy requirements of the transport network connecting the CO2 sources with the fertilization systems at multiple greenhouse locations in Qatar. These form part of the problem formulation for the determination of optimal locations of food production systems using Non-Linear Programming (NLP) to ensure the feasibility of CO2 fertilization and realize environmental improvements within the overall EWF nexus framework. The results indicate the optimal locations and extents for new greenhouse developments that are constrained by the available farming infrastructures and CO2 transportation options to balance for the net energy and water requirements for food production.

5.2 The Hand-off from Systems to Downstream Engineering

Thus far, this chapter has focused on the specification of the architecture of the system. This includes the identification of subsystem themselves, their responsibilities (as specified by their subsystem-level use cases), and the interfaces between them. Following systems engineering specification is the design and implementation of the system, a set of workflows we refer to as the hand-off to downstream engineering. This involves the evolution from logical interfaces to physical interfaces, the allocation of subsystem responsibilities to different engineering disciplines (such as mechanical, electronic, and software engineering), and the identification of the cross-disciplinary interfaces. The goal of the hand-off to downstream engineering is to allocate the design and implementation of the system specification to the different subsystem teams with enough information and direction so that their work can proceed with an appropriate expectation that it will fit together later.

If we’re going to all this trouble to really understand and specify the requirements and architecture from a systems perspective, it makes little sense to lose precision by handing off text-based specifications to downstream engineering. Figure 2.10 shows the workflow for the hand-off to downstream engineering.

Problem 5.5

Creating the Shared Model

At the gross level, creating the shared model is easy. It is generally a separate model with three high-level packages: CommonTypesPkg, InterfacesPkg, and DomainsPkg. The latter package will be used later to share software types used in multiple subsystem designs and is elaborated during the software design and implementation phases (and so may be ignored here). The first two packages are to hold specification data that applies to more than one subsystem, that is, common data types passed between subsystems and the physical interfaces that carry data of those types. The difficulty arises in that to this point the interface specifications have been logical and not physical, but we want to specify these interfaces and types to support integration of the actual subsystems. This requires interfaces and types that are physical and not logical.

To understand the problem, imagine a portion of a sequence diagram that refers to the TargetingSubsystem requesting a radar track from the RadarSubsystem. In the systems engineering model, this would most likely be shown as an event pair, and each event would carry data, as shown in Figure 5.25. In the actual implementation, it would almost certainly not be implemented in this way, even though it would achieve the same purpose. The actual implementation might be over a 1553 avionics bus that connects to both subsystems. The bus message would have a specific data format with bits allocated to the message header, message contents, cyclic redundancy check (CRC), and other important message fields. The data carried by the logical event would have to be represented not as some abstract data type but as a physical type with endianness and a specified bit organization. A corresponding physical interface implementation is shown in Figure 5.26. Of course, the internal messages on the RadarSubsystem are not part of the interface but help to explain the usage of the messages that are.

It is crucial that the physical interface be specified and shared with the subsystem teams using the interface so that they build the correct system. Storing the interface in a shared location means that all teams using the interface must rely on that definition and not make up one of their own. Should a defect in the interface be discovered during development, the relevant parties involved in the use of the interface should be represented during the negotiation of the correction.

For bigger systems, each of the primary packages will require an internal suborganization – a single package containing many dozens of interfaces and types is hard to use. There are many ways these packages may be internally organized. My preference is usually as follows:

For interfaces provided by a single subsystem, create a nested package in the InterfacesPkg corresponding to that subsystem. Every other subsystem that wishes to require that interface can find it there.

For interfaces provided by multiple subsystems (if any), create a CommonInterfacesPkg and place them there.

For larger systems, I tend to place the common types in the interfaces packages in the same way. If a type is used only within a single interface, then I place it in the same package as that interface, otherwise it goes into the generic CommonInterfacesPkg. As I mentioned, there are many good ways to organize this information and any method that allows all clients of an interface or type to easily find and manipulate it will probably be fine.

For this problem, create a package within the Roadrunner model to hold the interface information outside of the systems engineering package. Then take an interface identified between a pair of subsystems from each of our sample projects, decide on a design approach, and clarify the physical interface between them.

For the UAV system, create a separate shared model and structure that model to hold the shared hand-off information.

Problem 5.6

Initiating the Subsystem Model

The last problem in this chapter is to perform the right-side workflow for the hand-off, shown in Figure 2.10. The tasks are

Create the subsystem model

Define interdisciplinary interfaces

Allocate requirements to engineering discipline

The first part of this workflow creates a separate model (or, in small systems, package) for each subsystem, each subdivided into internal nested packages. Larger systems will use separated models for each subsystem. In this case, you must import the subsystem specification from the systems engineering model for the subsystem in question. For small models, it is more appropriate to merely reference the corresponding specification package from within each subsystem package.

In terms of organizing the subsystem model (or package), I recommend a subsystem organization that has packages for

Subsystem requirements and use cases

Subsystem functional analysis (if required, based on complexity)

Deployment architecture and interfaces

Software development

Software architecture

Software design

These nested packages will most likely be further subdivided as work progresses.

The latter two tasks create what is called the deployment architecture for the subsystem. This identifies the presence and roles that different engineering disciplines (e.g., mechanical, electronic, and software) will play in the subsystem, allocate requirements to those disciplines, and define interfaces among the disciplines to support the mission of the subsystem. It is expected that software development will continue within the model but that other disciplines will use their portion of the model solely as specifications and perform their engineering work with other means and tools.

The deployment model created to support the subsystem development will not be greatly detailed – in fact, it is common to just have the collective work products of each represented as a single block, although a more detailed deployment architecture identifying major elements within the discipline is also common. The important aspects here are to specify the requirements allocated to each discipline and how the elements of that discipline will interface with the others, particularly how the software will interface to the electronics.

UML does provide a diagram called a deployment diagram, but it is insufficiently expressive to be used for embedded systems. In fact, it was so underpowered that when we created the SysML profile, it wasn’t even included. I recommend that you create a class (or block, if you prefer) diagram with stereotyped classes representing the disciplines or their major elements to show the deployment architecture.

For example, Figure 5.27 shows a typical deployment diagram for a patient ventilator. Various elements from different disciplines are shown but little detail is shown, meaning that the necessary detail must be captured elsewhere.

An alternative is to use a class (or block) diagram to represent the same information. Figure 5.28 shows the high-level view. This view simply shows classes (blocks) representing the different disciplines (identified by their suffixes – SW for software, EE for electronics, and ME for mechanics) with the interfaces. In this view, discrete interfaces are shown using so-called “standard” ports, typed by standard interfaces, while continuous values are depicted using flow ports. In this example, all the SW-EE interfaces are discrete and all the EE-ME interfaces are continuous. Also notice that port multiplicity is used to show the fact that there are multiple valves (one per gas supply) in the gas manifold as well as multiple knobs and buttons on the front panel display.

Figure 5.29 shows the same deployment while identifying the large scale pieces of the included disciplines.

Allocations of requirements may be done either by moving them to a separate package for each discipline or by adding dependencies between each requirement and the discipline-specific element that will realize it. In SysML, this dependency is stereotyped «satisfy» while in UML «trace» is more common.

In many cases, a requirement may be directly allocated to a single discipline. However, in many other cases, the requirement must be decomposed into derived requirements, which may then be allocated. For example, consider a requirement such as

The volume of each breath delivered by the ventilator shall be settable in 1 ml increments from 100 ml to 1200ml, delivered with an accuracy of 0.5 ml.

This requirement decomposes into requirements for multiple disciplines. For example

The volume of each breath delivered by the ventilator shall be settable in 1 ml increments from 100 ml to 1200ml, delivered with an accuracy of 0.5 ml.

•

(Software) SW shall command the breath control pump in a range of 100 to 1200 ml, in increments of 1 ml.

•

(Software) SW shall command the pump to follow the standard volume curve updating the pump speed at least every 100ms.

•

(Electronics) The electronic pump control shall command the pump piston to a new commanded position within 1ms.

•

(Mechanical) The gas manifold shall deliver mixed gas continuously to the pump.

•

(Mechanical) The pump piston shall complete its response to an electronic signal to change position within 10ms with a positional accuracy of at least 5%.

These requirements may then be directly allocated to their respective disciplines.

The interfaces among the engineering disciplines are characterized with appropriate metadata describing the cross-disciplinary interface. The flow ports are typed by the electrical or mechanical properties of the interface. The discrete interfaces similarly characterize the properties of the interface. For SW-EE interfaces, I add tags to the interface for each service within the interface, identifying the kind of connection (interrupt-mapped, memory-mapped, or port-mapped), the address, the size of the connection, and the bit allocation. Figure 5.30 shows what this might look like for the iManifoldEE interface, which has a single operation, setValvePosition(valveNum, position). This metadata ensures that the software and electronic engineers have enough information to design their portions of the system properly.

For this problem, do the following:

If you have not yet done so, create a subsystem package for each subsystem in the Roadrunner model and a separate model for at least one subsystem in the UAV vehicle. Each should have a nested package organization as described in this chapter.

For one subsystem each in the Roadrunner and UAV models, create a deployment architecture and allocate requirements to the engineering disciplines.

2 The Modelling, Simulation, and Validation Framework

The proposed framework is based upon a modular and structured approach towards modeling, simulation and validation of large-scale complex system of systems with many interactions. The framework is implemented in the object-oriented, equation-based Modelica language which is specifically designed for heterogeneous modeling. Modelica includes libraries for a large variety of domains such as electronics, mechanics, thermodynamics, control, etc. which matches with our goal of providing a generic framework that can be applied to as many areas as possible.

However, the users of the framework are not restricted to use Modelica and are free to connect black box models either using co-simulation via the Functional Mockup Interface/FMI or using the Modelica option which allows calling external functions which are not written in Modelica but translated into C or Fortran. The external functions can be called from Modelica via a Dynamic Link Library of the exported functions.

As shown in figure 1, the framework represents each subsystem by four model components: the design model is a possibly simplified version of the subsystem model which can be used by a local management and control algorithm in cases where a model-based optimization strategy is used in order to drive the subsystem towards an optimal operation with respect to a local (optimization) problem formulation.

After the required number of iterations with the design models, the result of the optimization algorithms can be validated using a set of validation models, detailed models that precisely represent the physical SoS. The black arrows on the right most part of the figure 1 represent the physical connections between the subsystems (flows of material or energy). For the implementation of such interfaces, the standard Modelica interfaces are used. Similar connections are realized between the design models. An optional global coordination algorithm is included which interacts with the local optimizers in cases where a system-wide coordination algorithm is implemented.

The framework offers generic interfaces for the implementation of interconnections between model components and validation components and optimization algorithms. All interfaces support time-discrete as well as event-driven communication. The interface between local management and optimization algorithms and validation models additionally supports time-continuous communication for situations where the local management system includes a low-level controller that is acting on the real plant.

In large-scale SoS, for which the modeling and simulation framework is designed, manual interconnection of the components requires considerable effort. Besides, full knowledge of the communicated variables is necessary. Worst of all, there is always a probability that errors are made. The framework therefore offers an automatic routine for generating the interconnections using a Modelica model generator. An XML configuration file which contains information on the parametrization of all the interfaces (i.e. the names, types, dimensions of the variables, the required frequency of information exchange, etc.) together with two repositories of white box and black box models are provided to the model generator. Using this information, the Modelica model generator verifies the structural correctness of the model components, generates the required communication structure and adds the required model components. The work flow of such an automatic process is represented in figure 2.

All components must communicate via a Modelica-based model management engine. The model management engine requires the local management systems to define their parameters in the beginning of the simulation (i.e. either they support discrete-time or event-driven simulation, execution delays, the possibility of being triggered by other coordinators, etc.) and send data requests in order to obtain information from other management systems during the simulation. The data request contains (1) the ID of the target, (2) the ID of the requested variable, and (3) a specific index/indices of the requested variable if it is of type vector or matrix. The data request might be rejected by the model management engine in situations where triggering the operation of the target management system is not allowed according to the parameterization information which is provided to the model management engine in the beginning of the simulation. In addition, a publish/subscribe communication pattern between local and global optimizers is supported. For more details on the modeling, simulation and validation framework, please see Kampert et al. (2014).

The use of the framework is demonstrated below for the model of a petrochemical production complex where three different plants, a power plant, a cracker and an ammonia plant, are connected via networks of mass and energy.