The next step in the systems engineering process is to define the functional architecture. This architecture contains function and flow types, flows showing relations (inputs / outputs) of functions. The functional architecture will show a hierarchical decomposition of system functions. There is a strong link between functions and requirements, we define this link by allocating requirements in functions.

Create Functions and flows

We proceed to use the view "3.1. Define functional architecture"

To define the functions and flows, the first thing to do is to design the system's inputs / outputs. Those are showed in by links (flow type) between the system and its enabling systems.

Create external flows between enabling systems and system

We will define our system inputs / outputs. Those inputs / outputs could be data, mechanical flows (pressure...), electrical flow (supply...) and a lot more. All are showing using the two "flow" types objects: data flows and physical flows.

The objective is, before creating system functions, to have a complete list of all inputs / outputs of our system.

To start, we complete our example with three additional enabling systems. We now have the following enabling systems : "Mouse", "Office", "Screen", "Rooter". We will define links between this environment and the system. Those links can be a physical connection (mechanical, electrical...) or a data exchange. This two connections will be shown by different flow types in , data flow and physical flow.

Be careful, flows have a direction. Do not forget to choose the producer first and then the consumer.

The first link we will draw is the "Position of the mouse", a data flow sent from the "Mouse" to the "Laptop". Once you select the producer and the consumer (here "Mouse" and "Laptop"), a window will open to ask you the type of the flow you want to draw. Here we choose data flow and we will then indicate the wanted name, here "Position of the mouse".


In addition, we will show the creation of a physical flow. The same way we did it before, but selecting physical flow this time, we will draw a connection called "220 V supply" between the "Office" and the "Laptop".


As you can see, data flows and physical flows are physically different, the first one is green and the second one is blue. It allows us to recognize them easily. By completing this exchanges, we will have the complete list of links between the system and the enabling systems of its environment. In our example, we will create the following exchanges :

Between "Mouse" and "Laptop""Position of the mouse" (type data flow)

Between "Rooter" and "Latop": "Internet WiFi connection" (type physical flow) and "Internet cabled connection" (type physical flow)

Between "Screen" and "Laptop": "Graphical connection response" (type data flow)

Between "Laptop" and "Screen": "Graphical data" (type data flow)

Between "Office" and "Laptop": "220 V supply" (type physical flow)


It's also possible to have functional relations between several external elements. In our example, we could draw a physical flow between "Office" and "Screen" to show the screen supplying. Using the same method, draw a link between these two objects, and choose to draw a physical flow. You will be asked to choose between drawing a new physical flow or to reuse the "220 V supply" that already exists. We will choose to create a new flow that we will call "220 V". This gives us following view:


Create functions under the system

We will now define functions in our system. In the same view, enter the system by double-clicking on it.

By doing this, you will be able to see inside your system all the inputs / outputs we defined, showed by the flows we drew. These flows are represented by boxes that show whether it is a flow beginning or ending point. This box is linked to a port. Ports are objects showing that a flow is produced / consumed by an object not present in the current diagram. We have two kinds of ports, one to design the external producers and the other one for external consumers.


In our example, we can see that our system ("Laptop") has five inputs coming from external (enabling systems) and one output going to external.

To create a function, use the palette to drag and drop a function (type object) in the system. In our example, we will start creating the function "Capture internet signals".


Create functions hierarchy

As requirements, functions can have children (sub-functions). As we did before to create sub-functions, enter the main function by double clicking on it and create new functions there (you can also create new functions without entering the parent function, by dragging-and-dropping the new functions directly from the palette into the parent functions). In our example, we will create a function "Capture Internet signals" and create two sub-functions that will be called "Capture the cabled internet connection signal" and "Capture the WiFi internet signal"


Once you created the two functions, use the expand feature on the parent function (right click on it -> expand), and you will see something like this:


Create or complete relations

It's now time to define relations in the functional architecture. Functions can have two possible relations. We will call them external or internal relations.

An internal relation is a flow exchanged by two functions, we will not see it if we are looking from the system's environment. An external one will be just like those we mentioned before, coming from (or going to) enabling systems.

Enabling system - function relation (flows coming from external environment)

Let's start with an external relation. We will consider the flow "220 V supply" coming from the enabling system "Office". We want to show that it is consumed by a function we defined previously, called "Supply the Laptop". We will move the flow box from the system to the function, using the right click to drag and drop the flow into the function and choosing the option move here.



This shows a relation between the enabling system producing the flow and the function consuming it.

Flows can be linked with sub-functions too. In the example, we took the sub-functions (parent "Capture Internet signals" having two children "Capture the Cabled Internet Connection Signal" and "Capture the WiFi signal"), two flows coming in the system will be linked with them. Those flows are "Internet Cabled Connection" and "Internet WiFi Connection". There are two ways to place the flows in the concerned functions. The first one is to place the two flows in the parent function, enter it, and place each flow in the corresponding sub-function. The second one, a more practical one, is using the expand feature on the parent function and using the move here command (right click and drag and drop) for each flow directly into the concerned sub-function


Function - function relations (internal flows)

We will now define internal exchanges. In our example, our two sub-functions captured the two internet signals and will send them to a third sub-function we will call "Interpret internet signals".

The first thing to do is to create this third sub-function .Once it's done, we will draw a link between the function "Capture the Cabled internet Connection Signal" and "Interpret internet signals". We will call this flow "Captured cabled internet connection signal". The same way, we will draw another link between the function "capture the WiFi signal" and "Interpret internet signals" that will be called "Captured WiFi signal"


Define functions

Defining functions is the way we use to justify the creation of a new function. A function is created to answer a requirement, we will consequently allocate in each function the requirements it is answering. This work is done in an other view, "3.2. Allocate Reqs on functions and flows".

In our example, we will allocate the requirement "Laptop has to be able to receive internet connection using all known transmission ways" in the function "capture internet signals".

In this view (in the system) we will find all the functions we created in the precedent view. We will allocate requirements in functions. In , to do this allocation, we place requirements as children functions. To add a requirement into the concerned function, right click on it and choose the Add existing object feature. Then will propose a list of object types, choose the type of object you want to add, in this case, a requirement.


You now have the requirements dictionary. Choose the one you want to allocate in the function and click on the add button. The requirement will be placed in the function once you close the dictionary window.


Expanding your function (which was already expanded in precedent steps), you will now see the allocated requirement(s) in addition to children functions.