This page describes the mode resolution mechanism. Its goal is to compute the computation mode of a block according to its input, outputs, memories and parameters DataTypes, SignalTypes and values.

In order to find the correct mode for an instance of a block, it is mandatory to represent each mode by a different expression (signature). For a BlockType it will not be possible to have two BlockModes having the same signature. If it is the case, it will not be possible to select a mode for this block. This will mean either:

- The provided block instance is not correct
- The specification is not correct
- The specification is not complete

In the *BlockLibrary instance verification* page we describe how to check that a block’s
specification is correct according to the previously exposed conditions.
We also provide means to verify if a block specification is complete.

According to this, if we do **not** manage to find a correct BlockMode for a block instance
this means that the provided block instance is **not** correct.

BlockModes **implements** BlockVariants. BlockVariants **extends** other BlockVariants.
These two relations are modeled using **VariantSet** model elements. See
*BlockLibrary Meta-model* page for documentation. A **VariantSet** is contained
in either a BlockVariant, a BlockMode or an Other **VariantSet**. Each
**VariantSet** has an attached operator giving him a specific semantics.
We distinguish between two operators **AND** and **ALT**:

**AND**operator: The**AND VariantSet**container must implement (or extend if the container is a BlockVariant) all of the BlockVariants and VariantSets refered by this**VariantSet**.**ALT**operator: The**ALT VariantSet**container must implement (or extend if the container is a BlockVariant) one of the BlockVariants and VariantsSets refered by this**VariantSet**.

It is worth noting that:

- From one BlockMode/BlockVariant we can have multiple relations. This allows to combine the two kind of relations.
- A
**VariantSet**has either a reference to BlockVariants or to VariantSets but not combinations of both.

We need here to introduce a new symbol for logical formulas: \(\bigodot\)
named **ALT** for Aternative.
This symbol is stating that for a set of logical properties if *exactly one* of
these properties is true (this behavior is close to the one of the binary
logical operator XOR but generalized for a set of values). It is ofter
refered to as n-ary XOR.

Here is the formal definition of the ALT operator:

\[S = \{a_1, a_2, ..., a_{n}\}, \forall i \in [1..n], a_i
\in \mathcal{B}\]\[\bigodot^{n}_{i=1} S(i) =
\left(
\bigvee^{n}_{i=1} S(i)
\right) \wedge
\left(
\bigwedge^{i,j \leq n, i \not= j}_{i,j =1}
\neg(S(i) \wedge S(j))
\right)\]

Let’s assume the following operations definitions:

\(SIG(e)\):

*BlockMode*|*BlockVariant*->*Signature*The signature of \(e\). Detailed definition is given below.

\(SC(e)\):

*StructuralFeature*-> Set(*Annotation*)The collection of structural constraints of \(e\). Structural constraints are the properties expressed in the

*StructuralFeatures*of the element \(e\) and its structural constraints.**Returns**a collection of*Annotations*.**Note**In the following, \(SC(e)_i\) is the \(i^{th}\) element of this collection.\(BV^{\&}(e)\):

*BlockMode*|*BlockVariant*-> Set(*BlockVariant*)The collection of BlockVariants

**implemented**(if \(e\) is a BlockMode) or**extended**(if e is a BlockVariant) by the \(e\) :*SpecificationElement*related to it by**AND**relations.**Returns**a collection of BlockVariant.**Note**In the following, \(BV^{\&}(e)_i\) is the \(i^{th}\) element of this collection.\(BV^{\odot}(e)\):

*BlockMode*|*BlockVariant*-> Set(Set(*BlockVariant*))The collection of collections of BlockVariants

**implemented**(if \(e\) is a BlockMode) or**extended**(if \(e\) is a BlockVariant) by the \(e\) :*SpecificationElement*related to \(e\) by**ALT**relations. Each sub collection in the result contains the elements related in one**ALT**relation.**Returns**a collection of collections of BlockVariants.**Note**In the following, \(BV^{\odot}(e)_{i,j}\) is the \(j^{th}\) BlockVariant of the \(i^{th}\) collection of BlockVariants.

We will refer in the following with \(|X|\) as the cardinal (number of elements) of the collection \(X\).

According to the previous definitions:

- The signature of an element \(e\) (either a BlockMode or a BlockVariant) is recusively defined by:

\[\begin{split}SIG(e) = \left( \bigwedge^{|SC(e)|}_{i=1} SC(e)_i \right) \land
\left(
\left(
\bigwedge^{|BV^{\&}(e)|}_{i=1} SIG(BV^{\&}(e)_i)
\right)
\land
\left(
\bigwedge^{|BV^{\odot}(e)|}_{i=1}
\left(
\bigodot^{|BV^{\odot}(e)_i|}_{j=1}
SIG(BV^{\odot}(e)_{i,j})
\right)
\right)
\right)\end{split}\]

**Example 1:**

Let take a BlockMode called \(a\). Let’s imagine a first **ALT** (\(\odot\))
relation between \(a\) and three BlockVariants (\(v_1, v_2, v_3\))
and a second **ALT** relation between \(a\) and two BlockVariants
(\(v_4, v_5\)). As these two **ALT** relations needs to be satisfied
then a **AND VariantSet** holds both of them. A compact form for this is:

- \(a\) implements \(\&(\odot(v_1, v_2, v_3), \odot(v_4, v_5))\)

We give in the following the result for the computation of the set of signatures for \(a\):

\(SIG(a) = \bigodot\{\)

\[\left(\bigwedge^{|SC(a)|}_{i=1} SC(a)_i \right) \land
\left(\bigwedge^{|SC(v_1)|}_{i=1} SC(v_1)_i \right) \land
\left(\bigwedge^{|SC(v_4)|}_{i=1} SC(v_4)_i \right) \land
\left(\bigwedge^{|SC(v_5)|}_{i=1} SC(v_5)_i \right),\]

\[\left(\bigwedge^{|SC(a)|}_{i=1} SC(a)_i \right) \land
\left(\bigwedge^{|SC(v_2)|}_{i=1} SC(v_2)_i \right) \land
\left(\bigwedge^{|SC(v_4)|}_{i=1} SC(v_4)_i \right) \land
\left(\bigwedge^{|SC(v_5)|}_{i=1} SC(v_5)_i \right),\]

\[\left(\bigwedge^{|SC(a)|}_{i=1} SC(a)_i \right) \land
\left(\bigwedge^{|SC(v_3)|}_{i=1} SC(v_3)_i \right) \land
\left(\bigwedge^{|SC(v_4)|}_{i=1} SC(v_4)_i \right) \land
\left(\bigwedge^{|SC(v_5)|}_{i=1} SC(v_5)_i \right)\]

\(\}\)

In the OCL constraints specified on the BlockLibrary metamodel, we specified that no cycle can exists in the BlockVariant hierarchy. Furthermore, there is a finite number of BlockVariants and BlockModes in a BlockLibrary. This make the previous calculus possible to finish and so the calculation always possible.