Struct graph JSON input and constructors.

[joaquinffernandez]

JSON input definition (Version 1)

Components:

$\text{Var} = \{$
$\text{id} : string$
$\text{type} = \{ \text{State} | \text{Algebraic} | \text{Discrete}\}$
$\text{size} = [[d_{1_s},d_{1_e}],\dots,[d_{n_s},d_{n_e}]]$
$\}$

$\text{VarUsage} = \{$
$\text{id} : \text{string}$
$\text{exp} = (\text{slope}, \text{constant}) $
$\}$

$\text{Expression} : \{$
$\text{id} : \text{string}$
$\text{type} = \{ \text{StEQ} | \text{AlgEQ} | \text{Stm}\}$
$\text{interval} : [[d_{1_s},d_{1_e}],\dots,[d_{m_s},d_{m_e}]]$
$\text{lhs} : \{ L_1, \dots, L_k \}$ where $L_i$ has type $\text{VarUsage}$
$\text{rhs} : \{ R_1, \dots, R_g \}$ where $R_i$ has type $\text{VarUsage}$
$\}$

using these components we can represent a model in the following way:

$\text{Model} : \{$
$\text{VarDefs} : \{ V_1, \dots, V_k \}$ list of variables defined in the model of type $\text{Var}$
$\text{Exps} : \{ E_1, \dots, E_g \}$ list of expressions defined in the model of type $\text{Expression}$
$\}$

Finally, given a model $M$ we can define an algorithm that constructs a dependency graph:

$\mathbf{BuildSBG}(M):$

• $D_o \leftarrow 1$ // Initial domain value for vertices.
• $O_m \leftarrow \emptyset$ // Keep a map of each vertex set initial (min) value.
• $G \leftarrow \emptyset$
• // First generate all graph vertices
• $\forall V_i \in M\text{.VarDefs}$ do
  • $G\text{.AddVertex}(V_i, D_o)$ // Generate a new set from var size and the current offset.
  • $O_m\text{.Add}(V_i\text{.id}, D_o)$
  • $\text{UpdateOffset}(V_i\text{.size}, D_o)$
• $\forall E_i \in M\text{.Exps}$ do
  • $G\text{.AddVertex}(E_i, D_o)$ // Generate a new set from exp interval and the current offset.
  • $O_m\text{.Add}(E_i\text{.id}, D_o)$
  • $\text{UpdateOffset}(E_i\text{.size}, D_o)$
• // Generate all graph edges
• $\text{GenerateEdges}(G, M\text{.Exps}, D_o, RHS)$
• $A \leftarrow (\forall E_i \in M\text{.Exps} | E_i\text{.type} = \text{AlgEq})$
• $\text{GenerateEdges}(G, A, D_o, LHS)$

$\mathbf{GenerateEdges}(G, \text{Exps}, D_o, S):$

• $\forall E_i \in Exps$ do
  • $e_o \leftarrow O_m\text{.Get}(E_i\text{.id})$
  • $U \leftarrow$ If $(S = \text{RHS})$ then $E_i\text{.rhs}$ else $E_i\text{.lhs}$
  • $\forall U_j \in U$ do
    • $u_o \leftarrow O_m\text{.Get}(U_j\text{.id})$
    • $d \leftarrow \text{GenerateDom}(D_o, E_i\text{.intervals})$
    • $(m_o, m_d) \leftarrow \text{GenerateMaps}(E_i, U_j, d, e_o, u_o)$
    • $\text{UpdateOffset}(E_i\text{.size}, D_o)$
    • $(u, v) \leftarrow$ If $(S = \text{RHS})$ then $(m_o, m_d)$ else $(m_d, m_o)$
    • $G\text{.AddEdge}(u, v, d)$

$\mathbf{GenerateMaps}(E, U, d, e_o, u_o):$

• $d_i \leftarrow d\text{.MinElem}()$
• $c_d \leftarrow$ If $(U\text{.slope} = 0)$ then $(U\text{.constant} + u_o - 1)$ else $(u_o - d_i + U\text{.constant})$
• $m_o \leftarrow$ If $(E\text{.interval.size}() = 1)$ then $(0, e_o)$ else $(E\text{.interval.step}(), d_i - e_o)$
• $m_d \leftarrow (U\text{.slope}, c_d)$
• return $(m_o,m_d)$

Example

Given this Modelica model:

model rltest
  constant Integer N=10;
  Real x1[N],x2[1];
  Real a1[N];
  parameter Real R=1,C=1,L=1;
equation
  a1[1]=0((10-x1[1])^3)/R; 
  for i in 1:N-1 loop
    a1[i+1]=((x1[i]-x1[i+1])^3)/R; 
  end for;
for i in 1:N-1 loop
    der(x1[i])=((a1[i]-a1[i+1])^3)/C;
  end for;
   der(x1[N])=(a1[N]-x2[1])/C;
  der(x2[1])=x1[N]/L;
end rltest;

We can define the following variables:

Variables
$A_1 = \{$ $\text{id} : a_1$ $\text{type} = {\text{Algebraic}}$ $\text{size} = [[1,N]]$ $\}$	$X_1 = \{$ $\text{id} : x_1$ $\text{type} = \{\text{State}\}$ $\text{size} = [[1,N]]$ $\}$	$X_2 = \{$ $\text{id} : x_2$ $\text{type} = \{\text{State}\}$ $\text{size} = [[1,1]]$ $\}$

and from the equation section we can define the following expressions:

From: a1[1]=((10-x1[1])^3)/R:

$a1[1]$	$x1[1]$	Exp
$U_1 = \{$ $\text{id} : a1$ $\text{exp} = (0,1)$ $\}$	$U_2 = \{$ $\text{id} : x1$ $\text{exp} = (0,1)$ $\}$	$E_1 : \{$ $\text{id} : Eq\_a1_1$ $\text{type} = \text{AlgEQ}$ $\text{interval} : [[1,1]]$ $\text{lhs} : \{ U_1\}$ $\text{rhs} : \{ U_2\}$ $\}$

From a1[i+1]=((x1[i]-x1[i+1])^3)/R;:

$a1[i+1]$	$x1[i]$	$x1[i+1]$	Exp
$U_1 = \{$ $\text{id} : a1$ $\text{exp} = (1,1)$ $\}$	$U_2 = \{$ $\text{id} : x1$ $\text{exp} = (1,0)$ $\}$	$U_3 = \{$ $\text{id} : x1$ $\text{exp} = (1,1)$ $\}$	$E_2 : \{$ $\text{id} : Eq\_a1_i$ $\text{type} = \text{AlgEQ}$ $\text{interval} : [[1,N-1]]$ $\text{lhs} : \{ U_1\}$ $\text{rhs} : \{ U_2, U_3\}$ $\}$

From: der(x1[i])=((a1[i]-a1[i+1])^3)/C:

$x1[i]$	$a1[i]$	$a1[i+1]$	Exp
$U_1 = \{$ $\text{id} : x1$ $\text{exp} = (1,0)$ $\}$	$U_2 = \{$ $\text{id} : a1$ $\text{exp} = (1,0)$ $\}$	$U_3 = \{$ $\text{id} : a1$ $\text{exp} = (1,1)$ $\}$	$E_3 : \{$ $\text{id} : Eq\_x1_i$ $\text{type} = \text{StEQ}$ $\text{interval} : [[1,N-1]]$ lhs} : \{ U_1\}$ $\text{rhs} : \{ U_2, U_3\}$ $\}$

From: der(x1[N])=(a1[N]-x2[1])/C:

$x1[N]$	$a1[N]$	$x2[1]$	Exp
$U_1 = \{$ $\text{id} : x1$ $\text{exp} = (0, N)$ $\}$	$U_2 = \{$ $\text{id} : a1$ $\text{exp} = (0,N)$ $\}$	$U_3 = \{$ $\text{id} : x2$ $\text{exp} = (0, 1)$ $\}$	$E_4 : \{$ $\text{id} : Eq\_x1_N$ $\text{type} = \text{StEQ}$ $\text{interval} : [[1,1]]$ $\text{lhs} : \{ U_1\}$ $\text{rhs} : \{ U_2, U_3\}$ $\}$

From der(x2[1])=x1[N]/L:

$x2[1]$	$x1[N]$	Exp
$U_1 = \{$ $\text{id} : x2$ $\text{exp} = (0,1)$ $\}$	$U_2 = \{$ $\text{id} : x1$ $\text{exp} = (0,N)$ $\}$	$E_5 : \{$ $\text{id} : Eq\_x2_1$ $\text{type} = \text{StEQ}$ $\text{interval} : [[1,1]]$ $\text{lhs} : \{ U_1\}$ $\text{rhs} : \{ U_2\}$ $\}$

The model can then be defined as:

$\text{M} : \{$
$\text{VarDefs} : \{ A_1, X_1, X_2 \}$
$\text{Exps} : \{ E_1, E_2, E_3, E_4, E_5 \}$
$\}$

The final goal of this initial stage is to be able to build a dependency graph from an input JSON file obtained from a Modelica model like one described before:

As an example, a possible output of the final algorithm used in the construction of a communication graph could be:

where all the algebraic variables are removed.