Examples

[joaquinffernandez]

Simple Air Conditioners Population
Modelica model:

 equation
    for i in 1:N loop
      der(th[i]) = (THA/RES[i]-POT[i]*on[i]-th[i]/RES[i]+noise[i]/RES[i])/CAP[i]; // Node 1
    end for;

  algorithm

    for i in 1:N loop   // Node 2
      when th[i] - tref[i] + on[i] - 0.5 > 0 then
        on[i] := 1;
      elsewhen th[i] - tref[i] + on[i] - 0.5 < 0 then
        on[i] := 0;
      end when;
    end for;

    for i in 1:N loop // Node 3
      when time > nextTref[i] then
        if (nextTref[i] == 1000) then
          tref[i] := 20.5;
        else
          tref[i] := 20;
        end if;
        nextTref[i] := 2000;
      end when;
    end for;

    for i  in 1:N loop // Node 4
      when time > nextSample[i] then
        nextSample[i] := nextSample[i]+1;
        noise[i] := 2*abs(sin(i*time))-1;
      end when;
    end for;

SBG-Partitioner Input

For the lhs of computing node 1
$V_1 = \{$
$\text{id} : th$
$\text{exp} = (1,0) \rightarrow$ to form the expression $1\times i+0$ that corresponds to $th[i]$
$\text{defs} = \{\}$
$\}$

For the rhs of computing node 1
$V_2 = \{$
$\text{id} : th$
$\text{exp} = (1,0) \rightarrow$ to form the expression $1\times i+0$ that corresponds to $th[i]$
$\text{defs} = \{n_1\}$
$\}$

$V_3 = \{$
$\text{id} : on$
$\text{exp} = (1,0) \rightarrow$ to form the expression $1\times i+0$ that corresponds to $on[i]$
$\text{defs} = \{n_2\}$
$\}$

$V_4 = \{$
$\text{id} : noise$
$\text{exp} = (1,0) \rightarrow$ to form the expression $1\times i+0$ that corresponds to $noise[i]$
$\text{defs} = \{n_4\}$
$\}$

For the lhs of computing node 2
$V_5 = \{$
$\text{id} : ev_1$
$\text{exp} = (1,0) \rightarrow$ to form the expression $1\times i+0$ that corresponds to $ev_1[i]$
$\text{defs} = \{\}$
$\}$

$V_6 = \{$
$\text{id} : on$
$\text{exp} = (1,0) \rightarrow$ to form the expression $1\times i+0$ that corresponds to $on[i]$
$\text{defs} = \{\}$
$\}$

For the rhs of computing node 2
$V_7 = \{$
$\text{id} : th$
$\text{exp} = (1,0) \rightarrow$ to form the expression $1\times i+0$ that corresponds to $th[i]$
$\text{defs} = \{n_1\}$
$\}$

$V_8 = \{$
$\text{id} : on$
$\text{exp} = (1,0) \rightarrow$ to form the expression $1\times i+0$ that corresponds to $on[i]$
$\text{defs} = \{n_2\}$
$\}$

$V_9 = \{$
$\text{id} : tref$
$\text{exp} = (1,0) \rightarrow$ to form the expression $1\times i+0$ that corresponds to $tref[i]$
$\text{defs} = \{n_3\}$
$\}$

For the lhs of computing node 3
$V_{10} = \{$
$\text{id} : ev_2$
$\text{exp} = (1,0) \rightarrow$ to form the expression $1\times i+0$ that corresponds to $ev_2[i]$
$\text{defs} = \{\}$
$\}$

$V_{11} = \{$
$\text{id} : tref$
$\text{exp} = (1,0) \rightarrow$ to form the expression $1\times i+0$ that corresponds to $tref[i]$
$\text{defs} = \{\}$
$\}$

$V_{12} = \{$
$\text{id} : nextTref$
$\text{exp} = (1,0) \rightarrow$ to form the expression $1\times i+0$ that corresponds to $nextTref[i]$
$\text{defs} = \{\}$
$\}$

For the rhs of computing node 3
$V_{13} = \{$
$\text{id} : nextTref$
$\text{exp} = (1,0) \rightarrow$ to form the expression $1\times i+0$ that corresponds to $nextTref[i]$
$\text{defs} = \{n_3\}$
$\}$

For the lhs of computing node 4
$V_{14} = \{$
$\text{id} : ev_3$
$\text{exp} = (1,0) \rightarrow$ to form the expression $1\times i+0$ that corresponds to $ev_3[i]$
$\text{defs} = \{\}$
$\}$

$V_{15} = \{$
$\text{id} : nextSample$
$\text{exp} = (1,0) \rightarrow$ to form the expression $1\times i+0$ that corresponds to $nextSample[i]$
$\text{defs} = \{\}$
$\}$

$V_{16} = \{$
$\text{id} : noise$
$\text{exp} = (1,0) \rightarrow$ to form the expression $1\times i+0$ that corresponds to $noise[i]$
$\text{defs} = \{\}$
$\}$

For the rhs of computing node 4
$V_{17} = \{$
$\text{id} : nextSample$
$\text{exp} = (1,0) \rightarrow$ to form the expression $1\times i+0$ that corresponds to $nextSample[i]$
$\text{defs} = \{n_4\}$
$\}$

The nodes can be represented as:

$N_1 = \{$
$\text{id} : n_1$
$\text{interval} : [1,N]$
$\text{lhs} : \{V_1\}$
$\text{rhs} : \{V_2, V_3, V_4\}$
$\}$

$N_2 = \{$
$\text{id} : n_2$
$\text{interval} : [1,N]$
$\text{lhs} : \{V_5, V_6\}$
$\text{rhs} : \{V_7, V_8, V_9\}$
$\}$

$N_3 = \{$
$\text{id} : n_3$
$\text{interval} : [1,N]$
$\text{lhs} : \{V_{10}, V_{11}, V_{12}\}$
$\text{rhs} : \{V_{13}\}$
$\}$

$N_4 = \{$
$\text{id} : n_4$
$\text{interval} : [1,N]$
$\text{lhs} : \{V_{14}, V_{15}, V_{16}\}$
$\text{rhs} : \{V_{17}\}$
$\}$

$Nodes = \{N_1, N_2,N_3, N_4\}$

air_conditioners.json

[joaquinffernandez]

A few more examples with different simple features to test:

• Advection 2D model:

equation
  
    // Origin equation
    der(u[1,1])=-ax*u[1,1]/dx - ay*u[1,1]/dy + r*(u[1,1]^2-u[1,1]^3);
    
    // Borders 
    for i in 2:N loop
      der(u[i,1])=-ax*u[i,1]/dx - ay*(u[i,1] - u[i-1,1])/dy + r*(u[i,1]^2-u[i,1]^3);
    end for;

    // Borders 
    for j in 2:N loop
      der(u[1,j])=-ax*(u[1,j] - u[1,j-1])/dx - ay*u[1,j]/dy + r*(u[1,j]^2-u[1,j]^3);
    end for;

    // Rest of the grid.
    for i in 2:N, j in 2:N loop
      der(u[i, j])=-ax*(u[i,j] - u[i,j-1])/dx - ay*(u[i,j] - u[i-1,j])/dy + r*(u[i,j]^2-u[i,j]^3);
    end for;

advection2D.json

• RL test model:

equation
  a1[1]=((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;

rltest.json

• Simple 1D advection model:

  equation
    der(u[1])=(-u[1]+1)*N-mu*u[1]*(u[1]-alpha)*(u[1]-1);
    for j in 2:N loop
      der(u[j])=(-u[j]+u[j-1])*N-mu*u[j]*(u[j]-alpha)*(u[j]-1);
  end for;

advection.json

[joaquinffernandez]

• For the initial tests of the graph builder and initial partition algorithm we should use advection 1D and RLtest examples and use them as regression tests for the Air Conditioners Population and advection 2D examples.
• Once we have these examples working we can then tests more advanced models like air conditioners population with a controller and the spiking neuron networks

[joaquinffernandez]

Spiking Neurons sample model:

model spl_neurons
  constant Integer N=300000,M=60000;
  Real v[N](each start=-60),gex[N],ginh[N];
  parameter Real tau=20, vrest=-60, vthres=-50,Trefrac=5,Eex=0,Einh=-80,tauex=5,tauinh=10,dgex=0.4,dgin=1.6;
  discrete Real  active[N](each start=1),tfire[N](each start=10000);
  discrete Real  nextev[M](each start=random10());
  parameter Real Period=10,lastTime=100;
  parameter Integer SNmap1[N];
  parameter Real ex[N];
  discrete Real exReinit[N];
  discrete Real inhReinit[N];
  discrete Real nextGlobalTime[M];
  discrete Real inputs[M];
  initial algorithm
    for i in 1:M loop
      SNmap1[i]:=randomN();
    end for;

    for i in 1:N loop
      NNmap1[i] := randomC(i);
    end for;

    for i in 1:N loop
      ex[i]:=random100(i);
    end for;

  equation
    for i  in 1:N loop
      der(v[i])=active[i]*((vrest-v[i])+gex[i]*(Eex-v[i])+ginh[i]*(Einh-v[i]))/tau;
      der(gex[i])=-gex[i]/tauex;
      der(ginh[i])=-ginh[i]/tauinh;
      end for;

  algorithm
    for i in 1:N loop
      when v[i]*ex[i]>vthres then
        reinit(v[i],vrest);
        reinit(ginh[i],0);
        reinit(gex[i],0);
        for j in 1:EX_CON loop
          exReinit[j] := 1;
        end for;
        active[i]:=0;
        tfire[i]:=time;
      end when;
    end for;

    for i in 1:N loop
      when v[i]*(1-ex[i])>vthres then
        reinit(v[i],vrest);
        reinit(ginh[i],0);
        reinit(gex[i],0);
        for j in 1:IN_CON loop
          inhReinit[j] := 1;
        end for;
        active[i]:=0;
        tfire[i]:=time;
      end when;
    end for;

    for i in 1:N loop
      when exReinit[i] > 0.5 then
         reinit(gex[i],gex[i]+dgex);
         exReinit[i]:=0;
      end when;
    end for;

    for i in 1:N loop
      when inhReinit[i] > 0.5 then
         reinit(ginh[i],ginh[i]+dgin);
         inhReinit[i]:=0;
      end when;
    end for;

    for i in 1:N loop
      when time>tfire[i]+Trefrac then
        active[i]:=1;
      end when;
    end for;

    for i in 1:M loop
      when time>nextev[i]+nextGlobalTime[i] then
        exReinit[SNmap1[i]] := 1;
        inputs[i] := inputs[i] + 1;
        nextev[i]:=time+10*sin(i*inputs[i])^2;
      end when;
    end for;

    for i in 1:M loop
      when time > lastTime then
         nextGlobalTime[i] := 1e10;
      end when;
    end for;
end spl_neurons;

spiking_neurons.json

[joaquinffernandez]

Dummy 1 to N example:

for i in 1:2 loop  // Node 1
      when 1 then
        sendPartTotal[i] := partTotal[i];
        partTotal[i] := 0;
      end when;
    end for;

for i in 1:N loop // Node 2
      when 2 then
        partTotal[1]:= partTotal[1] + 10;
    end when;		
    end for;

dummy_1_N.json

The graph generated should have only 1 edge with the form:

$1 \leftarrow \{1:N\} \rightarrow i$