[LUA]
[DE]
[SCRIPT] code/bit32.lua
[SCRIPT] code/inspect.lua
[SCRIPT] code/class.lua
[SCRIPT] code/try-catch-finally.lua
[SCRIPT] code/switch.lua
[SCRIPT] code/pervasives.lua
[PLUGIN] popup.plugin
[PLUGIN] button.plugin
[PLUGIN] help.plugin
[PLUGIN] simu2.plugin
[TITLE] Lua Nezwork Simulation 2
[AUTHOR] Stefan Bosse
[VERSION] 11.2023

[FUN]
```js
function updateConfig(id) {
  console.log(id,Inputs[id])
  switch (id) {
    case 'input1': appConfig.user=Inputs[id]; break;
  }
}

new HelpUI({
  welcome:'Enter search keywords.',
  label:'HelpBot',
  callback:function (text,search) {
    return search(text)
  },
  documents : {
    Simulator : EmbeddedText.simu2
  }
})
```

[TEXT] simu2:simu2.help.md

# Mobile Netzwerke Simulation mit Lua

[TOC]
## Discrete-Event 2D World Simulation

### Create Simulator

```lua
simulator = Simulator({
  width?  = number,
  height? = number
})
```
### Adding Nodes

- A node consists of at least one shape or a shape group
  + The positions of all group members is relative to the group position
- A shape descriptor is a visual record table 
- A node must have a unique identifier (any string)
- A node is created and added to the simulation world using the `simulator:add(nodeid,shapedesc)` method
- A node can response to events (named signals with data)
  + A listener for an event is installed with the `node:on(event,handler function(data))` method
  
```lus
type shapedesc = {
  shape : 'Rect' | 'Circle' | 'Ellipse' | 'Line' | 'Text'| 'Group',
  class? : string,
  x? : number, y?: number,  -- center position, or
  left?: number, top?:number,
  width?:number, height?:number,
  radius?:number,
  line?:{color:string,width:number},
  fill?:{color:string,opacity:number [0,1] },
  label?: string | {text:string, fontSize:number, fontFamily:string },
  members? : shapedesc { }, -- group only
}
```

### Modifying Nodes

- The current node position is stored in the `node.position` field (`{x:number,y:number}`)
- The identifier of a node is stored in the `node.id` field 
- The shape or a pericular shape of the node can be modified by the `node:modify(shapeclass,attr)` method; *attr* is a record table specifying shape visual attributes

### Moving Nodes

- A node can be moved in the 2D world using the `node:move(dx,dy)`, `node:move(d,nil,angle)`, or `node:moveTp(x,y)` methods

```
node:move(dx,dy,angle)
node:moveTo(x,y)
node:turn(deltaAngle)
node:turnTo(angle)
```

### Node Activities

- Each node is defined by its geometric shape (or shape group) and a set of activity handlers.

```
node:on('before',function (self,step) end)
node:on('activity',function (self,step) end)
node:on('after',function (self,step) end)
```

### Searching Nodes

- A node can search for other nodes, either by specifying its own shape class (or a class of one shape of a group), the radius, or the bounding box of the search
- Either within the bounding box (only ndoes fully within the bounding box) or overlapping search can be performed

```lua
node:search(shapeclass,overlap?:boolean)
node:search(left,top,width,height,overlap?)
```

### Properties

- Node ID: `self.id`
- Node x and y position: `self.x`, `self.y`

### Events

- Event signals are sent by the simulator to nodes or nodes can send event signals to other nodes
- The `node:send(nodeid,event,data)` method is used to send a signal to a specific node 
- Messages are processed by a nodes using an event handler:

```
node:on('msg',function (self,data) end)
```

### Simulation

- Each world simulation step consists of three phases signalling different events:
  + `before`
  + `step` or `activity` is the main simulation activity event
  + `after`
  
- These events can be handled by each node and by the simulator (world) itself
- Only in the main activity handler function the state of a node should be changed (state that has impact on other nodes)

### Data

- Data variables can be assigned both to the simulator and to nodes just by adding record table fields

```lua
node.data = { .. }
simulator.data = { .. }
```

- Test before assignment if the field already exists

## Beispiel

[CODE] Erzeugen des Simulators
```lua
simu = Simulator({})
```

[CODE] Simulation ausführen (Wichtig: Erst Simulator mit nachfolgenden Schritten aufsetzen) { lines:10; height:10 }
```lua
loop(function (self,count)
  print(count)
  simu:step(1);
  return count < 10
end)
```

[CODE] Test des Simulators 
```lua
print(simu:info())
```

[CODE] Statistik Monitor aktivieren { lines:5; height:10 }
```lua
simu.statistics=T{collisions=T{}}
simu:on('after', function (self,step) 
  print('simu',step)
  local collisions=0
  for i,node in pairs(self.nodes) do
    if #node.messages > 1 then collisions=incr(collisions) end
  end
  simu.statistics.collisions:push(collisions)
end)
```

[CODE] Statistik ausgeben { lines:10; height:3 }
```lua
print(simu.statistics.collisions:print())
```

[CODE] Erzeugung von Knoten { lines:5; height:20 }
```lua
node1 = simu:add('node1',{
    shape='Group',
    x    = 50, y    = 150,
    members={
      {
        shape = 'Rect',
        class = 'node',
        x = 0, y  = 0, width = 20, height = 20,
        line = { width=2, color='blue'},
        -- fill = { color='green' },
        label = "1"
      },
      {
        shape = 'Circle',
        class = 'radio',
        x = 0, y = 0, radius = 30,
        line = { width=1, color='black'},
      }    
    }
  })
node2 = simu:add('node2',{
    shape='Group',
    x    = 70, y    = 170,
    members={
      {
        shape = 'Rect',
        class = 'node',
        x = 0, y  = 0, width = 20, height = 20,
        line = { width=2, color='blue'},
        -- fill = { color='green' },
        label = "2"
      },
      {
        shape = 'Circle',
        class = 'radio',
        x = 0, y = 0, radius = 30,
        line = { width=1, color='black'},
      }    
    }
  })
```

[CODE] Behandlung von Aktivitäten { lines:5; height:20 }
```lua
node1:on('activity',function (self,step) 
  print('node.activity',self.id,self.x,self.y,step)
  local neighbors = self:search('radio',true);
  print(#neighbors)
  for i,node in pairs(neighbors) do
    -- print (node.id)
    if node.id ~= self.id then
      self:send(node.id,'msg',{ from = node.id })
    end
  end
  self:move(10,10)
end)
node1:on('before', function (self,step) 
  self.messages=T{}
end)
node1:on('msg',function (self,data) 
  print('msg',self.id,data.from);
  self.messages:push(data.from);
end)
node1:on('after', function (self,step) 
  print('got #'..#self.messages..' messages')
end)
node2:on('before', function (self,step) 
  self.messages=T{}
end)
node2:on('activity',function (self,step) 
  print('node.activity',self.id,self.x,self.y,step)
  local neighbors = self:search('radio',true);
  print(#neighbors)
  for i,node in pairs(neighbors) do
    -- print (node.id)
    if node.id ~= self.id then
      self:send(node.id,'msg',{ from = node.id })
    end
  end
  self:move(10,10)
end)
node2:on('msg',function (self,data) 
  print('msg',self.id,data.from);
  self.messages:push(data.from);
end)
node2:on('after', function (self,step) 
  print('got #'..#self.messages..' messages')
end)
```

[CODE] Dynamische Änderung der Simulationsparameter { lines:5; height:5 }
```lua
-- Change radio radius randomly
-- Modifies search tree, too
for i,node in pairs(simu.nodes) do
  if math.random() > 0.5 then
    node:modify('radio',{radius=30+math.random()*10})  
  end
end
```

## Aufgaben

[EXERCISE] Experiment
1. Erstelle eine Funktion die eine Simulationswelt mit *N* Knoten programmatisch (iterativ). Die Konten sollen parametrisierbar sein bzüglich initialer Position, Kommunikationsradius, und Ausfallwahrscheinlichkeit γ.
2. Erstelle eine Simulationswelt mit N=100 zufällig platzierten Knoten
3. Implementiere Random Walk der mobilen Knoten innerhalb der Simulationswelt
4. Modifiziere den Radio R Radius (Monte Carlo Simulation mit Verteilung im Bereich 20..70)
5. Führe ein Monitoring der Radio Inteferenz durch (Interferenz wenn ein Knoten pro Simulationsschritt mehr als eine Nachricht empfängt)
6. Variere die Simulationsparameter: *N*=20,50,100, R=20,30,50,70 (einmal statisch, dann durch MC verteilt *R*~min~=20,*R*~max~=70), und der Geschwindigkeit der Knoten v=Δ/step
7. Trage die mittelren Kollisionsraten in eine Tabelle ein (abhhängig von den Parametern)
8. Führe ein γ = 0.7 ein (mit `math.random()` entscheiden ob eine Nachricht empfangen wird). Wiederhole exexmplarisch einige der Experiement und beobachte Veränderungen.
[EXERCISE]

[INPUT]

[TABLE] { label:"table1" }
| N | Rmin | Rmax | γ | v | Kollisonen | 
|:--|:--|:--|:--|:--|
| 0 | 0 | 0 | 1 | 0 | 0 |
| 0 | 0 | 0 | 1 | 0 | 0 |
| 0 | 0 | 0 | 1 | 0 | 0 |
| 0 | 0 | 0 | 1 | 0 | 0 |
| 0 | 0 | 0 | 1 | 0 | 0 |
| 0 | 0 | 0 | 1 | 0 | 0 |
| 0 | 0 | 0 | 1 | 0 | 0 |
| 0 | 0 | 0 | 1 | 0 | 0 |
| 0 | 0 | 0 | 1 | 0 | 0 |
| 0 | 0 | 0 | 1 | 0 | 0 |
| 0 | 0 | 0 | 1 | 0 | 0 |
| 0 | 0 | 0 | 1 | 0 | 0 |
| 0 | 0 | 0 | 1 | 0 | 0 |
| 0 | 0 | 0 | 1 | 0 | 0 |
| 0 | 0 | 0 | 1 | 0 | 0 |

---

[BUTTON] Hilfe { action:post; label:Absenden; style:"color:red" }
```
{
  url:'edu-9.de:28888',
  // url:'localhost:28888',
  form:['Name','Email','Pin','Frage'],
  email:{from:'$Email', to:'sbosse@uni-bremen.de', name:'$Name'},
  subject:'Hilfe Kurs ML $TITLE',
  message:'$Name: $Frage',
  attachments:[{filename:'$FILE.json',content:'$CODE'}],
  pin:1827,
}
```

[BUTTON] Einreichung (Assignment #03-86664) { action:post; label:Absenden; style:"color:green" }
```
{
  url:'edu-9.de:28888',
  // url:'localhost:28888',
  form:['Name','Email','Pin','Kommentar'],
  submit: { from:'$Email', to:'sbosse@uni-bremen.de' },
  assignment:'03-86664',
  name : '$Name',
  comment : '$Kommentar',
  attachments:[{filename:'$FILE.json',content:'$CODE'}],
  pin:1827,
}
```

[BUTTON] Prüfen { action:post; label:Laden; style:"color:browm" }
```
{
  url:'edu-9.de:28888',
  // url:'localhost:28888',
  form:['ID','Pin'],
  load: { id:'$ID' },
  pin:[1827,9223],
}
```

[BUTTON] Bewerten (Lehrer) { action:post; label:Absenden; style:"color:blue" }
```
{
  url:'edu-9.de:28888',
  // url:'localhost:28888',
  form:['ID','Marking','Pin','Remarks'],
  submit: { id:'$ID', from:'sbosse@uni-bremen.de', name:'$Name' },
  marks : '$Marking',
  remarks : '$Remarks',
  attachments:[{filename:'$FILE.json',content:'$CODE'}],
  pin:9223,
}
```

---

Mobile Netzwerke Simulation mit Lua

Inhalt.

Mobile Netzwerke Simulation mit Lua

Discrete-Event 2D World Simulation

Create Simulator

Adding Nodes

Modifying Nodes

Moving Nodes

Node Activities

Searching Nodes

Properties

Events

Simulation

Data

Beispiel

Aufgaben

Discrete-Event 2D World Simulation

Create Simulator

simulator = Simulator({
  width?  = number,
  height? = number
})

Adding Nodes

A node consists of at least one shape or a shape group
- The positions of all group members is relative to the group position
A shape descriptor is a visual record table
A node must have a unique identifier (any string)
A node is created and added to the simulation world using the simulator:add(nodeid,shapedesc) method
A node can response to events (named signals with data)
- A listener for an event is installed with the node:on(event,handler function(data)) method

type shapedesc = {
  shape : 'Rect' | 'Circle' | 'Ellipse' | 'Line' | 'Text'| 'Group',
  class? : string,
  x? : number, y?: number,  -- center position, or
  left?: number, top?:number,
  width?:number, height?:number,
  radius?:number,
  line?:{color:string,width:number},
  fill?:{color:string,opacity:number [0,1] },
  label?: string | {text:string, fontSize:number, fontFamily:string },
  members? : shapedesc { }, -- group only
}

Modifying Nodes

The current node position is stored in the node.position field ({x:number,y:number})
The identifier of a node is stored in the node.id field
The shape or a pericular shape of the node can be modified by the node:modify(shapeclass,attr) method; attr is a record table specifying shape visual attributes

Moving Nodes

A node can be moved in the 2D world using the node:move(dx,dy), node:move(d,nil,angle), or node:moveTp(x,y) methods

node:move(dx,dy,angle)
node:moveTo(x,y)
node:turn(deltaAngle)
node:turnTo(angle)

Node Activities

Each node is defined by its geometric shape (or shape group) and a set of activity handlers.

node:on('before',function (self,step) end)
node:on('activity',function (self,step) end)
node:on('after',function (self,step) end)

Searching Nodes

A node can search for other nodes, either by specifying its own shape class (or a class of one shape of a group), the radius, or the bounding box of the search
Either within the bounding box (only ndoes fully within the bounding box) or overlapping search can be performed

node:search(shapeclass,overlap?:boolean)
node:search(left,top,width,height,overlap?)

Properties

Node ID: self.id
Node x and y position: self.x, self.y

Events

Event signals are sent by the simulator to nodes or nodes can send event signals to other nodes
The node:send(nodeid,event,data) method is used to send a signal to a specific node
Messages are processed by a nodes using an event handler:

node:on('msg',function (self,data) end)

Simulation

Each world simulation step consists of three phases signalling different events:
- before
- step or activity is the main simulation activity event
- after
These events can be handled by each node and by the simulator (world) itself
Only in the main activity handler function the state of a node should be changed (state that has impact on other nodes)

Data

Data variables can be assigned both to the simulator and to nodes just by adding record table fields

node.data = { .. }
simulator.data = { .. }

Test before assignment if the field already exists

Beispiel

Erzeugen des Simulators

simu = Simulator({})

▸

✗

≡

Simulation ausführen (Wichtig: Erst Simulator mit nachfolgenden Schritten aufsetzen)

loop(function (self,count)
  print(count)
  simu:step(1);
  return count < 10
end)

▸

✗

≡

Test des Simulators

print(simu:info())

▸

✗

≡

Statistik Monitor aktivieren

simu.statistics=T{collisions=T{}}
simu:on('after', function (self,step) 
  print('simu',step)
  local collisions=0
  for i,node in pairs(self.nodes) do
    if #node.messages > 1 then collisions=incr(collisions) end
  end
  simu.statistics.collisions:push(collisions)
end)

▸

✗

≡

Statistik ausgeben

print(simu.statistics.collisions:print())

▸

✗

≡

Erzeugung von Knoten

node1 = simu:add('node1',{
    shape='Group',
    x    = 50, y    = 150,
    members={
      {
        shape = 'Rect',
        class = 'node',
        x = 0, y  = 0, width = 20, height = 20,
        line = { width=2, color='blue'},
        -- fill = { color='green' },
        label = "1"
      },
      {
        shape = 'Circle',
        class = 'radio',
        x = 0, y = 0, radius = 30,
        line = { width=1, color='black'},
      }    
    }
  })
node2 = simu:add('node2',{
    shape='Group',
    x    = 70, y    = 170,
    members={
      {
        shape = 'Rect',
        class = 'node',
        x = 0, y  = 0, width = 20, height = 20,
        line = { width=2, color='blue'},
        -- fill = { color='green' },
        label = "2"
      },
      {
        shape = 'Circle',
        class = 'radio',
        x = 0, y = 0, radius = 30,
        line = { width=1, color='black'},
      }    
    }
  })

▸

✗

≡

Behandlung von Aktivitäten

node1:on('activity',function (self,step) 
  print('node.activity',self.id,self.x,self.y,step)
  local neighbors = self:search('radio',true);
  print(#neighbors)
  for i,node in pairs(neighbors) do
    -- print (node.id)
    if node.id ~= self.id then
      self:send(node.id,'msg',{ from = node.id })
    end
  end
  self:move(10,10)
end)
node1:on('before', function (self,step) 
  self.messages=T{}
end)
node1:on('msg',function (self,data) 
  print('msg',self.id,data.from);
  self.messages:push(data.from);
end)
node1:on('after', function (self,step) 
  print('got #'..#self.messages..' messages')
end)
node2:on('before', function (self,step) 
  self.messages=T{}
end)
node2:on('activity',function (self,step) 
  print('node.activity',self.id,self.x,self.y,step)
  local neighbors = self:search('radio',true);
  print(#neighbors)
  for i,node in pairs(neighbors) do
    -- print (node.id)
    if node.id ~= self.id then
      self:send(node.id,'msg',{ from = node.id })
    end
  end
  self:move(10,10)
end)
node2:on('msg',function (self,data) 
  print('msg',self.id,data.from);
  self.messages:push(data.from);
end)
node2:on('after', function (self,step) 
  print('got #'..#self.messages..' messages')
end)

▸

✗

≡

Dynamische Änderung der Simulationsparameter

-- Change radio radius randomly
-- Modifies search tree, too
for i,node in pairs(simu.nodes) do
  if math.random() > 0.5 then
    node:modify('radio',{radius=30+math.random()*10})  
  end
end

▸

✗

≡

Aufgaben

Aufgabe. Experiment

Erstelle eine Funktion die eine Simulationswelt mit N Knoten programmatisch (iterativ). Die Konten sollen parametrisierbar sein bzüglich initialer Position, Kommunikationsradius, und Ausfallwahrscheinlichkeit γ.
Erstelle eine Simulationswelt mit N=100 zufällig platzierten Knoten
Implementiere Random Walk der mobilen Knoten innerhalb der Simulationswelt
Modifiziere den Radio R Radius (Monte Carlo Simulation mit Verteilung im Bereich 20..70)
Führe ein Monitoring der Radio Inteferenz durch (Interferenz wenn ein Knoten pro Simulationsschritt mehr als eine Nachricht empfängt)
Variere die Simulationsparameter: N=20,50,100, R=20,30,50,70 (einmal statisch, dann durch MC verteilt R_min=20,R_max=70), und der Geschwindigkeit der Knoten v=Δ/step
Trage die mittelren Kollisionsraten in eine Tabelle ein (abhhängig von den Parametern)
Führe ein γ = 0.7 ein (mit math.random() entscheiden ob eine Nachricht empfangen wird). Wiederhole exexmplarisch einige der Experiement und beobachte Veränderungen.

Hilfe

Einreichung (Assignment #03-86664)

Prüfen

Bewerten (Lehrer)

Created by the NoteBook Compiler Ver. 1.25.0 (c) Dr. Stefan Bosse (Mon Dec 11 2023 22:59:49 GMT+0100 (Central European Standard Time))