Stefan Bosse - Material-integrated cluster computing in self-adaptive robotic materials using mobile multi-agent systems

Material-integrated cluster computing in self-adaptive robotic

materials using mobile multi-agent systems

Stefan Bosse

1,2

•

Dirk Lehmhus

Received: 16 July 2018 / Revised: 23 November 2018 / Accepted: 19 December 2018

Ó Springer Science+Business Media, LLC, part of Springer Nature 2019

Abstract

Recent trends like internet-of-things (IoT) and internet-of-everything (IoE) require new distributed computing and com-

munication approaches as size of interconnected devices moves from a cm

- to the sub-mm

-scale. Technological advance

behind size reduction will facilitate integration of networked computing on material rather than structural level, requiring

algorithmic and architectural scaling towards distributed computing. Associated challenges are linked to use of low

reliability, large scale computer networks operating on low to very low resources in robotic materials capable of per-

forming cluster computing on micro-scale. Networks of this type need superior robustness to cope with harsh conditions of

operation. These can be provided by self-organization and—adaptivity. On macro scale, robotic materials afford uniﬁed

distributed data processing models to allow their connection to smart environments like IoT/IoE. The present study

addresses these challenges by applying mobile Multi-agent systems (MAS) and an advanced JavaScript agent processing

platform (JAM), realizing self-adaptivity as feature of both data processing and the mechanical system itself. The MAS’

task is to solve a distributed optimization problem using a mechanically adaptive robotic material in which stiffness is

increased via minimization of elastic energy. A practical realization of this example necessitates environmental interaction

and perception, demonstrated here via a reference architecture employing a decentralized approach to control local

property change in service based on identiﬁcation of the loading situation. In robotic materials, such capabilities can

support actuation and/or lightweight design, and thus sustainability.

Keywords Pervasive computing  Ubiquitous computing  Agents  Optimization  Material informatics  Self-organizing

systems  Self-adaptive systems

1 Introduction

Cluster computing is commonly related to large-scale

networks composed of powerful computers and servers

connected by reliable high-bandwidth interconnections

and the Internet. There is an ongoing trend to create big

machines providing high storage, memory, and CPU

capacities towards Cloud computing and data centers.

This is the macro- scale level of computing. But there is

also an emerging micro-scale level of computing, using

low-resource and miniaturized computers towards the

scale deployed in material-integrated computer

networks and the internet-of-things [1]. The term material

is related to the micro-size-scale level (element size about

), and structures to the meso-size-scale level (ele-

ment size about cm

In the last decades there was a shift from passive single

sensors and centralized sensor data processing towards

large networks [2] of smart sensors equipped with Infor-

mation-Communication-Technologies (ICT) forming sen-

sorial materials as one class of material-integrated

intelligent systems (MIIS) [3]. Furthermore, there was a

signiﬁcant increase of the sensor density in sensor networks

integrating sensors and ICT in materials [3], used, e.g., for

structural health monitoring (SHM) [4] or in smart textiles.

& Stefan Bosse

sbosse@uni-bremen.de

Department of Mathematics and Computer Science,

University of Bremen, 28359 Bremen, Germany

Faculty of Computer Science, University of Koblenz-Landau,

56070 Koblenz, Germany

Fraunhofer IFAM, 28359 Bremen, Germany

123

Cluster Computing

https://doi.org/10.1007/s10586-018-02894-x

(0123456789().,-volV)(0123456789().,-volV)

Finally, micro system technologies enable the integration

of actuation in materials creating robotic materials [5], e.g.,

using thermoplastic actuators [6] to modify structures.

Robotic materials are characterized by a tight coupling

of sensing, actuation, computation, and communication.

Data processing in robotic materials can be considered as

cluster computing on micro-scale level. Sensorial and

robotic materials are operating under harsh environmental

conditions requiring resilient behaviour, captured by the

entire design of the ICT architecture and distributed

algorithms.

Load-bearing structures are typically designed towards

relevant load cases known at design-time. New technolo-

gies enabling the design of structures that change material

properties in service in response to load change (i.e., using

robotic materials) could raise additional weight saving

potentials, extending the lifetime, and increasing opera-

tional safety. Thus, self-adaptive robotic materials support

lightweight design and sustainability inspired by bionic

design, e.g., by a top-down approach based on the struc-

ture, load, and function with similarity classiﬁcation [7].

But still bionic design has to consider speciﬁc load cases

and perform classiﬁcation in advance, e.g., performed by

the ELiSE design framework [8]. Examples of cross-sec-

torial and material-independent structural lightweight

constructions propose weight savings about 20–50% [9].

Our approach aims to overcome this limitation.

Structures composed of simple and unreliable actuators

are difﬁcult to control due to non-linearity and a lack of

physical models. One concern regarding active smart cel-

lular structures is the correlated and self-organizing control

of cells’ responses, and the underlying informational

organization providing robustness.

Robustness and real-time capabilities require some kind

of self-organizing and self-adapting computational model

instead of the functional models commonly used (e.g., in

control theory).

The adaptation of mechanical actuated structures to

varying load situations based on external perception or

proprioception that is considered in this work can be

treated as an optimization problem that will be controlled

in this work by multi-agent systems.

The next Sect. 2 outlines the general problem descrip-

tion of distributed computing in material-integrated ICT

systems and the novelty of this work. Section 3 discusses

data processing integrated in materials and structures from

a technical point of view. Robotic materials and the ref-

erence architecture used in this work is described in

Sect. 4. The optimization problem addressed in this work is

introduced in Sect. 5, and the MAS implementation is

described in Sect. 6. Sections 7,8, and 9 address the agent

and simulation platform. Finally, Sects. 10 and 11 show

and evaluate a use-case study.

2 Problem description and contribution

An overview of the concepts addressed in this work is

shown in Fig. 1. Assuming large-scale sensor- and actuator

networks (i.e., sensorial and robotic materials) that are

integrated in materials (or microscopic structures), dis-

tributed computing problems are solved by self-* multi-

agent systems, ﬁnally performing distributed optimization

(adaptation of mechanical properties of a robotic material).

The four upper layers (green boxes) are addressed in this

work.

The lower four layers are the platform and deployment

ﬁelds of the proposed distributed computing approach

using mobile agents, not addressed in this work.

Optimization problems are commonly solved mathe-

matically and numerically [10, 11] or treated as global

problems [6, 12] that can only be solved by processing the

entire sensor data set in each solver iteration. But the

transition to distributed approaches with local processing is

necessary to reach scaling of large systems in the future

consisting of Thousands and Millions of small perceptive

and computational nodes (embedded computers). These

tiny computational units are characterized by their low

computational power and data storage capacity.

This work addresses distributed information processing

integrated in materials and structures posing self-adaptivity

Fig. 1 Overview of the concepts fusioned in this work (lower three

levels are the deployment ﬁelds)

Cluster Computing

123

of the material using a MAS approach with algorithms

based on multi-phase topology optimization (MPTO) [13]

and simulated annealing, which can be considered as a

bionic structural optimization approach.

On the macro-scale level, agents and distributed agent-

based systems are already deployed successfully in

heterogeneous large environments, e.g., production and

manufacturing processes [14, 15], facing adaptive manu-

facturing, maintenance, evolvable assembly systems,

quality control, and energy management aspects, and in

sensing applications, e.g., monitoring of mechanical

structures and devices [16]. Finally, the paradigm of

industrial agents meeting the requirements of modern

industrial applications by integrating sensor networks was

introduced in [17]. In the present study, we show that

agents can be deployed successfully on the micro-scale

level, too.

The central approach in this work focuses on mobile

agents solving an optimization problem by a divide-and-

conquer approach. They pose the ability to support mobile

reconﬁgurable code embedding the agent behaviour, the

agent data, the agent conﬁguration, and the current agent

control state, ﬁnally encapsulated in a portable textual

representation.

In this work JavaScript code (AgentJS) is used and

executed by the JAM platform [18]. The code is capable of

migration between nodes in the network required for

autonomous distributed data processing. This approach

requires only a minimal agent processing platform service

(APPS). The AgentJS code can be directly executed by the

underlying JS VM (e.g., nodejs, jxcore, JVM, webview for

mobile App. development, or spidermonkey used in

browsers).

On the one hand, robotic materials provide internal and

external perception that can be used in a wide range of

sensing applications on the Internet (e.g., product life-cycle

management). Robotic Materials will be part of larger

networks, i.e., the IoT. On the other hand, robotic materials

can proﬁt from environmental information, e.g., collected

by mobile devices and crowd sensing. Therefore, these

material-integrated computational networks should be

connected to a local Intranet or to the global Internet (see

Fig. 2, left side).

One of the major challenges in distributed sensing and

control systems is the derivation of meaningful information

from sensor data. Often the sensors of mobile consumer

devices (such as accelerometer, humidity, light, battery,

temperature, and location) suffer from a poor quality.

Distributed sensor fusion can be applied to improve the

statistical signiﬁcance of such sensor signals by collecting

sensor data in a region of interest from multiple devices.

Fusion can proﬁt from machine learning (ML), which

usually bases on classiﬁcation algorithms derived from

supervised machine learning or pattern recognition using,

e.g., self-organizing [2] and distributed multi-agent sys-

tems with less or no a-priori knowledge of the

environment.

The IoT, material-integrated ICT networks, mobile, and

Cloud environments differ signiﬁcantly in terms of

resources (computational power and data storage). The IoT

and mobile networks consist of a large number of low-

resource devices interacting with the real world and having

strictly limited storage capacities, energy, and computing

power, and the Cloud consists of large-scale computers

with arbitrary and extensible computing power and storage

capacities in a basically virtual world.

A uniﬁed and common data processing and communi-

cation methodology is required to merge the IoT with

Cloud environments seamlessly, which can be fulﬁlled by

mobile agent-based computing proposed in this work.

The scalability of complex ubiquitous applications using

such large-scale cloud-based and wide area distributed

networks deals with systems deploying thousands up to a

million agents.

Considering such strong heterogeneous environments

with computers ranging from 1 MIPS computational power

and 1 MB RAM to 1 GIPS and 1GB RAM a hybrid dual-

platform approach have to be used for agent processing

(Fig. 2, right side).

Addressing the Internet, mobile networks and the IoT,

the

JAM platform [18] is used offering agents directly

implemented in JavaScript (AgentJS) program code hold-

ing the entire control and data state of an agent

Agent processing on very-low resource platforms is

performed with a stack-based processor approach (exe-

cuting AgentFORTH code) featuring hardware implemen-

tation and advanced token-based agent process scheduling

using the AFVM platform [19].

Both program code models base on the same behaviour

and agent behaviour model (ATG/AAPL) and can be

transformed to each other. The agents themselves conform

to the mobile processes model introduced by Milner [20]

ensuring seamless agent mobility. The code can be modi-

ﬁed by the agent itself using code morphing techniques

required for behaviour adaptation (directly supported by

JavaScript Just-in-time and Bytecode Compiler VM

platforms).

This work adds to earlier work [21] the following

extensions and novelties:

– Distributed and decentralized solving of mechanical

optimization problems using different algorithms;

– Self-* multi-agent system performing distributed opti-

mization in a robotic material providing self-adaptation

based on varying load situations and mechanical

defects;

Cluster Computing

123

– Reference architecture of a robotic material composed

of a mesh-grid network of agent processing platforms;

– Different enhanced distributed mechanical optimization

algorithms and their evaluation applied to robotic

materials that are used to meet mechanical constraints

under varying load and damage situations (e.g. holes);

– Multi-domain simulation with tight coupling of phys-

ical and computational agent models.

The next sections offer an introduction to material-inte-

grated intelligent systems and the robotic material refer-

ence architecture, followed by an introduction of the

proposed distributed optimization algorithms and their

implementation with MAS. Finally, an evaluation of the

distributed MAS optimization is performed by a multi-

domain simulation (coupling physical and computational

models) of a JAM network embedded in a robotic material.

3 Material-integrated intelligent systems

Material-integrated intelligent systems feature materials

with embedded data processing, communication, sensors,

actuators, and energy supply. These materials can be

classiﬁed in:

Fig. 2 Uniﬁed distributed

information processing in

heterogeneous MIIS/IoT/Cloud

environments with mobile

agents using a hybrid platform

framework consisting of the

JavaScript agent machine

platform (JAM) and the low-

resource AgentFORTH machine

(AFVM)

Cluster Computing

123

1. Sensorial materials providing intrinsic or environmen-

tal perception capabilities by coupling sensing, com-

putation, and communication.

2. Robotic materials providing intelligent perception and

mechanical adaptation capabilities by coupling sens-

ing, actuation, computation, and communication.

3. Self-adaptive robotic materials providing a closed

control loop using perception to adapt the material/

structure to changing load situations or defects.

All three classes use large-scale autonomous distributed

networks with embedded systems characterized by low

power consumption, low data storage resources, and low

processing power. Commonly, the network nodes are self-

The main ﬁelds of application of Sensorial Materials are

Load and Structural Health Monitoring, the ﬁeld of appli-

cation of robotic materials are mechanical adaptive

structures.

Intelligence is provided on software level featuring self-*

capabilities. Adaptivity, reconﬁguration, and healing in the

presence of technical failures (data processing, networking,

communication, low energy, sensor faults) are elementary

features of resilient systems in safety-critical environments.

Load-bearing structures are typically designed towards

relevant load cases assuming static shape and ﬁxed sets of

materials properties decided upon during design and

materials selection. New technologies enabling the design

of structures that could change local properties in service in

response to load change could raise additional weight

saving potentials, thus supporting lightweight design and

sustainability. Materials with such capabilities must nec-

essarily be composite in the sense of a heterogeneous

build-up, exhibiting, e.g., an architecture consisting of

networks with numerous active cells providing sensing,

signal and data processing, communication, and actuation/

stimulation capability [4] forming robotic materials and

structures [22]. One example for such a material is a spe-

cial class of polymers being capable to change their elas-

ticity based on the inﬂuence of optical, thermal, or

electrical ﬁelds [5].

Although no speciﬁc technology assumptions were

made in this work, there are already micro-scale computers

suitable for such material-integrated computing. An

example is the Micro MOTE M3 [23] providing about

1MIPS computing power and 4 kB data memory with

0.1 mm

chip area consuming less 100 lW power. The

FreeScale KL03 provides 50 MIPS/2 kB with 4 mm

chip

area and 3 mW power consumption. Both microcontrollers

base on ARM architecture.

4 Robotic material and reference

architecture

The reference architecture in this work consists of a three-

dimensional grid network of controller nodes with physical

and communication connectivity between nodes, shown in

Fig. 3. The physical links are actuators that can change

mechanical properties of the material (e.g., stiffness). No

technology-speciﬁc assumptions were made regarding

communication links and actuators.

In our understanding, a self-adaptive robotic material

provides the following major features:

1. Perception using various kinds of sensors, e.g., measuring

of strain, displacement, temperature, pressure, forces;

2. Capability of changing local material and structure

properties by actuators, e.g., stiffness or damping

variation;

3. Integrated networks of information processing and

communication technologies (ICT);

4. Distributed approach: Local sensor processing, aggre-

gation, and actuator control; Global cooperation and

coordination solving optimization.

The general model of such a robotic material is shown in

Fig. 3. It is assumed that the material (on micro-scale level) or

structure (on meso-scale level) consists of volume elements

(bounded regions of the material) that are connected with

neighbourhood elements via links. The links should provide

some kind of sensing (e.g., measuring the strain or displace-

ment along the link main axis) and some kind of material or

structure control providing a controllable actuator (e.g.,

modifying the stiffness of the link). A link can be a discrete

part or a continuous region of the material. A set of actuators is

connected to each node. Two nodes share an actuator (e.g., a

damped spring of variable stiffness and damping).

Each element contains an embedded computer that is

considered as a node in a mesh-grid communication network.

Each node provides some kind of data processing (processor

or digital logic RTL), data and program memory, commu-

nication, energy supply and energy management. Since the

distributed sensing and control of the material should be

performed by an agent-based approach each node has to

provide an agent processing platform (APP).

The APP is executed typically on a virtual machine,

discussed in Sect. 7. Agents have to be able to access

sensors and actuators by a hardware abstraction layer

(HAL), optimally provided by the APP.

It is assumed that the nodes are organized in an ad-hoc

way. Technical failures of single nodes is considered as the

common and may not affect the operation of the robotic

Cluster Computing

123

material and its capability to satisfy some global objective

function. This implies a self-organizing and self-adaptive

approach with respect to the connectivity structure has to

be used to create some kind of holonic system and is the

ﬁrst level of intelligence in a smart system.

Each node controls a number of actuated springs and

dampers connected to neighbouring nodes as shown in

Fig. 3d. Each spring has a virtual strain (displacement)

sensor attached, e.g., a strain gauge sensor. Together with

the current stiffness parameter value, the spring energy can

be computed. It is assumed that the stiffness of each spring

can be varied between a lower and an upper boundary

]. A technically reasonable range is ± 50% around a

nominal stiffness value. The missing sensor values (spring

displacement and current stiffness) must be retrieved from

neighbour nodes.

The models of the actuator (relation of relative dis-

placement l  l

and force f

i;j

between two nodes) and the

sensor (strain gauge signal S

i;j

) are given in Eqs. 1 and 2,

respectively.

i;j

ðl; s; dÞ¼k

sðl  l

Þdu ð1Þ

i;j

ðf

i;j

Þ¼S

i;j

GF; with GF ¼ DR=ðeR

Þð2Þ

with s: stiffness parameter, k: a spring constant, d: damping

parameter, u: relative velocity between nodes i and j, R:

electrical resistance, GF: gauge factor, :strain.

The adaptivity of the robotic material requires percep-

tion based on sensors, interpretation of current and past

load situation (locally or globally or both) and the control

of the actuators. Besides the energy required to perform

computation and communication, the most prominent part

of the energy consumption during operation is caused by

the actuators. The change (increase or decrease) of the

stiffness of the springs commonly requires or releases

energy (e.g., thermoplastic materials require controlled

heating), or requiring energy in both directions, depending

on the actuator technology (e.g., optically excited bi-

stable materials)!

The entire computation and the entire agent processing

implementing the structure optimization discusse d in the

next Section is performed by the material-integrated ICT

network. There is no off-loading of parts of the computa-

tion to external computers.

5 Distributed self-optimization

The concept of self-adaptive robotic materials draws much

of its appeal from the fact that engineering design has to

decide which are the load cases or service conditions to

base design on, while reality typically knows no such

limitations: conventional techniques like shape, topology

(a)

(b) (c)

(d)

Fig. 3 a General network architecture of a robotic material =

sensorial ? actuated material b hardware ? software architecture

c functional decomposition: sensing, acting, processing $ data ?

instruction streams d node connectivity (physical) of controlled

actuators attached to neighbour nodes (shown are the delta vectors

relative to a node position)

Cluster Computing

123

or multi-material optimization all need to single out few or

even one set of boundary conditions to adapt to. Any real

world load-bearing structure may see different scenarios

including misuse, which might be impossible to capture

and deﬁne in the design stage. Such unforeseen loads may

in the worst case lead to immediate failure—in other cases,

they might just wear out a structure, causing it to fail

prematurely and/or in places determined by unexpected

local load histories. A smart adaptive material or structure

that is capable of adjusting its mechanical characteristics—

like stiffness—to external loads could actively manage this

local load history. It could protect areas already worn out

and distribute loads to others instead.

There are three different optimization algorithms that

are applied to materials of this kind and evaluated in this

work:

1. Global optimization;

2. Segmented optimization;

3. Neighbourhood optimization (originally proposed in

[21]),

summarized in Table 1. They are originally based on the

concept of multi-phase topology optimization (MPTO) and

simulated annealing used to optimize structures at design

time by reorganizing material parameter distributions [13].

The algorithms are reactive and iterative, in contrast to

classical mathematical minimization being commonly

functional, applying small changes step-wise to satisfy the

global goal and to minimize an error function. The global

algorithm is presented here for reference only as it requires

a central instance, although the action is performed locally

but based on a global observable. The neighbourhood

algorithm operates continuously without a deﬁned termi-

nation, while the two other algorithms can terminate if they

satisfy a bounded error condition.

The segment and neighbourhood algorithms are suit-

able for distributed processing performing region explo-

ration and negotiation, characterized by self-* features

(self-adaptivity and robustness in case of sensor or node

failures and changes in the network connectivity). That

means, there are multiple instances operating on spatially

bounded data (local data) satisfying global objectives, e.g.,

minimizing the mechanical strain energy of a structure.

One major issue in distributed systems without a central

instance is the efﬁcient collection and computation of

observation variables (observables) like the accumulated

strain energy of a region of nodes. This is discussed in the

next section. The optimization of the structure is performed

by modifying a target variable (control parameter), e.g., the

stiffness of the actuators, based on a comparison of a local

observable (e.g., the local node strain energy) with a global

or glocal (region) observable, e.g., the strain energy of

nodes in a region around the particular node or just a global

accumulated value.

The total strain energy U of a mechanical structure is the

integral of the strain tensor  over the volume V of the

Table 1 Different optimization algorithms (simpliﬁed) for material/

structure adaptation are shown, with N: Set of nodes, S: Set of

segments S, U: total strain energy; : Strain; r: stress; x

: observation

variable of i-th node (element), x: some observation variable; X:

some accumulated observation variable; r

: optimization ratio param-

eter for i-th node, |X|: cardinality of a set X, R: some radius, D: some

discretization function; s

: stiffness of i-th node/element, [s

, s

limits of stiffness, [r

, r

]: limits of optimization parameter, k

: some

problem speciﬁc mapping and scaling function with weight factor w;

|pos

-pos

j=1: neighbourhood relationship of elements or segments

Cluster Computing

123

structure. The discretized strain energy for each node u

computed from all attached springs j={1,...,n} with their

displacement d

and current stiffness s

. The total dis-

cretized strain energy of a structure is the sum over all node

strain energies given by Eq. 3.

U ¼

redV

node

i¼1

U ¼

i¼1

ð3Þ

There is a set of observation variables: Strain , Stress r,

and the strain energy U ﬁnally computed, which is an

objective variable, too. The optimization variable is the

stiffness of elements , which is used to minimize the strain

energy, stress, or strain. Thus, the optimization (objective)

function is: min U(,r) with (e) and r (e) being a function

of the e-module (stiffness).

The basic principle of optimization uses a ratio param-

eter r based on the relation of observation variables (either

, r,orU) to a spatially extended ensemble value of this

variable (mean). The ratio parameter is applied to the target

variables, i.e., the stiffness of elements of the material/

structure. In Table 1 there are two different example

functions k

and k

shown that compute the actual ratio

parameter using the strain energy U(=x).

There is a set of all nodes: N, a set of all segments

grouping nodes (uniquely or overlapping): S, and segments

with a sub-set of nodes: S  N. Each segment is centered

around a node of the network, i.e., neighbour segments

overlap that corresponds to a moving window. The seg-

mented algorithm performs modiﬁcation of elements par-

titioned in segments based on locally bounded data. The

neighbourhood algorithm performs element modiﬁcation

between two neighbouring nodes only (point-to-point).

6 Self-* MAS

Self-* capabilities are addressed in this work by (1) Dis-

tributed data processing and (2) Mechanical optimization.

The MAS in combination with used distributed algorithms

pose self-capabilities on different levels (compare [24]):

1. Self-conﬁguration

2. Self-organization

3. Self-adaptivity

4. Self-healing

There is no a-priori knowledge of the network and cluster

structure or any world model. The global system behaviour

is a result of self-conﬁguration and self-organization of the

agents on a local domain scope and by neighbourhood

relations. Self-adaptivity is provided by means of (1) Data

processing in the presence of technical failures of nodes or

communication and changing network connectivity, and

(2) Algorithmic adaptation of mechanical properties of the

structure based on perception and negotiation as part of the

optimization problem. Self-healing is provided by the MAS

(1) By locating and isolating faults (technical failures) [25],

and (2) By compensating defects or holes in the mechanical

structure by adapting mechanical properties.

Node controller agents have to control a set of springs

pointing to neighbouring nodes and sensors, shown in

Fig. 3d. Each spring has a virtual sensor attached deliver-

ing the strain (displacement between two nodes). Together

with the current stiffness parameter value of a spring, the

spring energy can be computed. It is assumed that the

stiffness of each spring can be varied between a lower and

an upper boundary [s

]. A technical reasonable range is

± 50% around a nominal stiffness value. The missing

sensor values (spring displacement and current stiffness)

from other neighbour nodes are delivered by remote tuple

operations (see Fig. 4b).

The MAS has the goal to minimize a global or local

mechanical variable, e.g., the total strain energy U and the

strain by using an observation variable. The control is

performed by modifying a control variable, e.g., the spring

stiffness. The three different algorithms introduced in

(a) (b)

(c)

Fig. 4 MAS interaction: a Observable propagation using remote

signals b sensor distribution using remote tuples c negotiation in

neighbourhood algorithm using remote tuples

Cluster Computing

123

Sect. 5 require different MAS behavioural models. The

neighbourhood algorithm bases on negotiation and uses a

simple stiffness swap algorithm, discussed below. The

segment algorithm bases on a region mean of the observ-

able. i.e., the mean strain energy in the region. The mean

value is used to modify the control variable based on a

simple decision tree.

The MAS is composed of different agent classes. All

approaches (Table 1) uses node agents but apply different

behavioural models that can be united in one agent

enabling the selective change of the optimization approach

and objectives. The negotiation approach uses an additional

broker agent for negotiation, having a distinct behaviour

described below and illustrated in Fig. 4. Additional

explorer and notiﬁcation agents can be used for segmented

or regional action (e.g., to compute a global observable by

random walk and directed diffusion).

6.1 Neighbour negotiation

Node agent

The negotiation approach considers only observables of

two neighbour nodes. The node agent is a stationary agent.

Its behaviour consists of the following main activities.

init The initialization activity mainly creates a

broker agent, starts the adaptation handler

timer, and set up the sensor acquisition and

spring control.

perceive Getting notiﬁcations via the tuple-space data

base. Listening for tuples:{SENSOR,

STIFFNESS, ADAPT}. The SENSOR tuple is

either sent by the world agent or by

surrounding neighbour node agents. The

ADAPT tuple is sent by the broker agent if there

is a change in the spring stiffness that was

negotiated (either an increase or decrease). All

controlled springs of a node are always set to

the same stiffness.

process New sensor data is processed, and the current

strain of each spring and the total node strain

energy is computed. Relevant sensor

distribution and negotiation events are started.

In the case of an energy event (i.e., the current

strain energy is above a threshold), an alarm

tuple ALARM(energy, stiffness, ..)

is created that is consumed by a waiting and

listening broker agent.

notify The notiﬁcation activity distributes sensor and

spring data to neighbour nodes by sending

remote SENSOR tuples. The attached broker

agents is notiﬁed by ENERGY and ALARM

tuples. Based on sensor data of all known

springs attached to this node a NEIGHBOURS

tuple is sent to the broker to inform about

connectivity.

adapt This handler changes the stiffness parameters

of all controlled springs. To avoid high stiffness

changes, a low-pass ﬁlter is applied. This

activity is executed periodically by a timer.

Again, all springs are set always to the same

stiffness.

Broker agent

The negotiation and broker agent is a mobile agent and

is responsible for the neighbourhood self-adaptation of the

material based on the current load situation in the neigh-

bourhood and self-regulation. It interacts with the node

agents and other broker agents via tuple exchange.

Its behaviour consists of the following main activities:

perceive Getting notiﬁcations via the tuple-space data

base. Listening for

tuples:{ENERGY,ALAR M,NEIGHBOURS,VOTE}.

The ENERGY tuple informs about the current

strain energy and stiffness setting of the node,

whereas the ALARM tuple triggers a voting

cycle (transition to vote activity). A VOTE

tuple containing a SWAP? request initiates an

election.

vote A voting cycle is initiated by sending a

VOTE(SWAP?) request tuple to a randomly

chosen neighbourhood node. During the

voting or election cycle further ALARM and

SWAP? requests from other nodes are blocked

(ignored).

notify If this broker started a voting cycle and got a

SWAP? response, it notiﬁes the node agent

about the successful stiffness swap negotiation

by sending an ADAP T tuple to commit the

election result.

Cluster Computing

123

election This is the election handler managing a swap election

initiated by the ﬁrst SWAP? vote

after a time-out. The election determines the

majority vote among all collected votes. If the

major vote with the highest energy can be

granted, the voter gets a SWAP? declaration,

otherwise it is declined with a SWAP-

declaration, and also all voters losing the

competition get a SWAP- declaration. The decision

for the stiffness swapping bases on the local strain

energy and stiffness, compared with the major

requesting node ’s energy and stiffness, i.e.,

swapit=this.energy\major.ener gy and this.

stiffness-major.request[this.stiffnes s.low.

6.2 Segment and global control

Node agent

The non-negotiated distributed control requires only one

node agent per node. The original numerical segment

approach (Table 1) partitioned the network in rectangular

segments. This requires a central instance. To avoid such

external instance, each node creates a segment region

around its position posing a set of overlaid moving window

segments. Each segment implements a virtual sensor of the

observable [26, 27]. In contrast to the negotiation approach

an extended region observable is collected in the seg-

mented approach, i.e., the accumulated strain energy of

nodes in the neighbourhood within a distance n (e.g., 2).

The actuator modiﬁcation (i.e., stiffness of springs) bases

on the ratio of this accumulated observable and the local

observable value. Node agents communicate with each

other directly via remote tuples or signals. The modiﬁca-

tion of the target variable (spring stiffness s) can be step-

wise and discretized, i.e., applying a small ﬁxed delta

change based on the observable ratio (u/U) resulting ﬁnally

in a minimum/maximum stiffness distribution, or linear

using the observable ratio directly for the computation of a

new correction value for the target variable:

Step-wise:

if u > U+ΔU then s=s+Δs

else if u < U-ΔU then s=s-Δs

Linear:

s=s

*u/U*k

init The initialization activity explores the neighbour-

hood connectivity and starts the adaptation handler

timer, and set up the sensor acquisition and spring

control.

perceive Getting notiﬁcations via the tuple-space data

base. Listening for tuples: {SENSOR,OBSERVABLE}.

The SENSOR tuple is either send by the world agent or

by surrounding neighbour node agents. The OBSERVA-

BLE tuple is sent by neighbouring nodes (alternatively

using remote signals, see below)

process New sensor data is processed, and the current

strain of each spring and the total node strain energy is

computed.

notify The notiﬁcation activity distributes sensor and

computed observable data to neighbour nodes by sending

remote SENSOR and OBSERVABLE tuples or signals. To

prevent high notiﬁcation rates, the notify activity is

inhibited for some time if there was recently a notiﬁca-

tion event.

adapt All actuators (springs) of a node are updated

(setting new stiffness values based on computation and

perception).

Signals and Handlers Depending on the data distribu-

tion approach, signal handlers are used to receive

neighbour and to trigger actuator updates (signals

SENSOR,OBSERVABLE). Instead, using an actuator

update activity (adapt) that has to be activated on an

event, a signal handler can be used that is activated by a

periodical timer.

6.3 Agent behaviour: explorer and notify agent

The explorer and notify agents explore a larger radius of

neighbourhood (not limited to direct node neighbours) to

collect and distribute sensor data and physical state infor-

mation (e.g., a mean strain energy of a segment region or

the global observable mean). Commonly a central instance

is required for global action. Random walk and directed

diffusion behaviour can be used to approximately compute

and distribute a global observable without a central

instance. The evaluation of the proposed distributed pro-

cessing from Sect. 9. shows that there is no strict require-

ment for any global observable. An observable mean in a

large region is sufﬁcient.

6.4 Distributed computation of observables

using chains

Another approach without a central instance is neigh-

bourhood exploration and chaining. Each node propagates

its current local observable value (e.g., the node strain

energy u

) to all its direct neighbour nodes via remote

signals if the observable has changed. After the ﬁrst

delivery phase, each node has neighbourhood information

of distance 1. Each next delivery can deliver distance 2

values by mean computation u

of orthogonal node

observables with respect to the current delivery direction

and the over next node observable in the opposite direction

Cluster Computing

123

), shown in Fig. 4a. Finally, each node can compute a

region value of the observable. The propagation of

observable values to neighbour nodes is given by the fol-

lowing algorithm:

∀ dir ∈{NORTH,SOUTH,WEST,EAST,UP,DOWN} do

ne=neighbours,u0=this.u

dir=WEST|EAST?: u1=ne[NORTH].u0+ne[SOUTH].u0

dir=NORTH|SOUTH?: u1=ne[WEST].u0+ne[EAST].u0

dir=NORTH|SOUTH?: u2=ne[SOUTH|NORTH].u0

dir=WEST|EAST?: u2=ne[EAST|WEST].u0

dir=UP|DOWN?: u2=ne[DOWN|UP].u0

sendto(dir, { u0:u0,u1:u1,u2:u2 })

7 Agent platforms

The selection of an appropriate agent programming model

(APM) and agent processing platform (APP) is eminent for

the foreseen use case of material-integrated ICT networks

that are connected to the Internet and Cloud environments.

The deployment of a single APP (the agent VM, com-

monly, e.g., the JAVA-based JADE platform) in such

strongly heterogeneous environments with different con-

straints and organizational structures is not possible.

Therefore, a set of APPs have to be deployed. But all APPs

should address the same APM to enable cross-over

migration.

There are only few agent programming models that

cover very low-resource processing platforms. The AAPL

programming model(a meta model, detailed description in

[18, 19]) relies on the Activity-Transition Graph behaviour

model given by an agent class template containing activity

and transition sections. AAPL is an abstract programming

meta model that can be implemented with different pro-

gramming languages. The agent is composed of activities

(graph nodes) with conditional or unconditional transitions

based on agent data (perception and state). AAPL offers

statements for parametrized agent instantiation, like the

creation of new agents and the forking of child agents

inheriting the parent state. Uniﬁed agent interaction is

provided by using synchronized Linda-like tuple database

spaces and signal propagation (messages carrying simple

data delivered to signal handlers). Agent mobility (migra-

tion) is provided by transferring the entire state and code of

an agent process. The destination can be speciﬁed by a

geometric relation and a direction (e.g., North, South, ..), a

delta-distance vector usable in mesh grids, a host port, or

an URL/IP address.

There are actually two different programmable agent

processing platforms supporting agents based on the meta

agent programming model AAPL: The Agent FORTH

Virtual Machine (AFVM)[19, 28] as a low-resource plat-

form and the JavaScript Agent Machine (JAM)[27]asan

Internet platform.

7.1 AFVM platform

The AFVM platform (see Fig. 5, right) is a low-resource

platform suitable for hardware integration (microchip

level), requiring about 1000 k logic gates (1 mm

chip core

area with a TSMC 65 nm manufacturing process). Among

a hardware implementation there are different software

implementations fully operational and code compatible

with each other that can be connected in heterogeneous

networks. The AFVM is a multi-processor computer

architecture using a stack processor providing multi-pro-

cess scheduling (of agent processes) using a token and

queue-based approach. Agents are implemented with code

frames consisting of FORTH code with agent speciﬁc

extensions and embedded data storing the entire agent

control and data state. Code morphing enables agent

behaviour modiﬁcation by changing activity or transition

functions.

7.2 JAM platform

The JAM platform (see Fig. 5, left) addresses the deploy-

ment in large-scale networks, i.e., the Internet (of Things),

mobile networks, and Clouds. It requires a JavaScript

execution platform, e.g., nodejs,jxcore, or any JS capable

Web browser. The deployment of JAM in large-scale

world-wide networks in an Earthquake monitoring use-case

was shown in [29]. Although both platforms support agents

with nearly the same behaviour and operational model they

are not compatible on code level. JAM agents are pro-

grammed in AgentJavaScript ([30]). JAM consists of a set

of modules providing agent programming, agent control,

agent mobility, agent interaction, and machine learning.

Basically JAM is implemented as a library that can be

integrated in any host application. The central Agent Input

Output System (AIOS) module is the (secured and sand-

boxed) interface between agents and JAM. Agents are

always created from JS text code. An agent JS object stores

the entire agent code and data. Due to functions being ﬁrst

order values in JS the agent behaviour can be changed by

modifying activities or transitions directly without recom-

pilation or recoding.

The mobility is granted by converting the agent program

and process snapshot in a textual JSON? representation

that can be sent via various communication technologies,

and ﬁnally executing the code by parsing the text again.

This mobile agent program code can be executed on a

variety of different host platforms including mobile

Cluster Computing

123

devices, embedded devices, macroscopic sensor nodes, and

servers, using JAM and a generic JS VM, bridging the gap

between the IoT and Internet/Cloud infrastructures.

7.3 Hybrid architecture and the IoT

Although in this work MAS are implemented and pro-

cessed in JAM networks, the technological realization of

material-integrated computing requires the execution of

MAS on the AFVM platform.

To enable the composition of future large-scale appli-

cations ranging from very-low-resource nodes (1mm

computers integrated in materials and structures) to high-

resource devices (generic computers, servers, mobile and

embedded devices), both platform architectures have to co-

exist supporting agent migration seamlessly. This co-ex-

istence demands a compatibility layer that can be realized

by introducing an on-the-ﬂy cross-compiler enabling agent

mobility between different platform technologies seam-

lessly, shown in Fig. 5 (middle). This cross-compiler

translates agents in AgentFORTH object code to AgentJS

text code agents and vice versa by preserving the entire

agent state. This compiler is optimally contained in JAM as

a service.

Fig. 5 The hybrid architecture

merges two agent processing

platforms: (Bottom, Left) JAM

& (Bottom, Right) AFVM

(Bottom, Middle) J2F Bridge

compiler (Top) deployment

areas compared with some other

popular platforms; Legend: TS

tuple space, WS watchdog, AMP

agent management port, CHAN

channel, MOBI mobility, CONF

code reconﬁguration, SIG

signals, AIOS agent input output

system, CS/DS/RS stacks, CCS

common code segment

Cluster Computing

123

8 Agent communication

Communication is central in large-scale distributed sys-

tems with a high impact on the overall system performance

and stability. Two main issues arise that affect design

considerations: 1. Efﬁciency of the communication with

respect to latency, computational complexity, and storage;

2. Addressing and delivery of messages to destination

entities. Efﬁciency is a key factor in self-powered material-

integrated low-resource computing networks. Commonly,

end-to-end communication is established between pro-

cesses using IP protocols and computer nodes having

unique addresses, which is not suitable for large-scale

material-integrated networks and mobile agents. The agent

model usually implies autonomy and requires a loosely

coupling to the environment, i.e., without a strong binding

to a speciﬁc node. Moreover, there is usually no global

knowledge of the current position of an agent in the net-

work at all. Basically three approaches are available to

exchange information between agents: Tuple-space access,

signal messages, and agent migration. Tuple-spaces were

proposed in [31] and [32] as a suitable MAS interaction

and co-ordination paradigm. They are discussed below and

compared in Fig. 6.

8.1 Tuple-spaces

Tuple-space communication exchanges data tuples

between entities based on pattern matching, i.e., between

processes and agents. The information exchange is data-

driven and bases on the data structure and content of the

data, and does not require any destination addressing or

negotiation between communicating entities. Furthermore,

tuple-space communication is generative, i.e., the lifetime

of data can exceeds the lifetime of the producer. There are

producer and consumer agents. A tuple-space can be

characterized by a local bounding posing a limited access

region, commonly limiting data exchange to entities exe-

cuted on the same network node. Distributed tuple-spaces

require inter-node synchronization and base on replication

and some kind of distributed memory model.

The AAPL agent model originally uses tuple-spaces only

for agent communication executed on the same node.

8.2 Agent-to-agent (A2A) signals

Signals are lightweight messages that are delivered to

speciﬁc agents (agent-to-agent, A2A), in contrast to the

anonymous tuple exchange. One major issue is facilitating

remote agent communication, i.e., agents executed on

different network nodes. Although an agent can be

addressed by a unique identiﬁer, the path between a source

and destination agent is initially unknown. For the sake of

simplicity and efﬁciency, advance routing table manage-

ment and network exploration is avoided. Instead, the

APPL platforms (JAM/AFVM) support signal delivery

along paths of mobile agents only. That is, that a signal

from a source node A can only be delivered to a destination

agent actually on node B iff the destination agent was

executed (or created) on node A some time ago.

The concept thus requires that two agents had to be

executed on the same node in the past. Agent migration and

signal propagation is recorded by the agent platform using

look-up table caches with time limited entries and garbage

collection. Signals have the advantage of being delivered

and processed asynchronously by signal handlers (although

(a)

(b)

(c)

(d)

Fig. 6 Agent communication in AAPL a tuple-space communication

between agents on same node b agent-to-agent signals c remote

agent-to-node signals d remote tuple operation

Cluster Computing

123

not pre-emptively) compared with tuples that have to be

read or consumed by the agent explicitly.

8.3 Agent-to-node (A2N) signals

Previous agent platform implementations only support

signal delivery along migration paths based on the desti-

nation agent identiﬁer (private, uni-cast) or the agent class

(public, broadcast). The new JAM platform 2.0 introduces

signal delivery of signals to speciﬁc remote platforms

(remote signalling) based on paths speciﬁed by the signal

sender agent. The destination platform node broadcasts the

signal to all listening agents executed on this particular

node. To simulate private A2A uni-cast (or multi-cast)

communication, agents can use a randomly generated sig-

nal name only known by the sender and the receiver. This

new approach enables agent interaction between agents

never executed on the same node. Furthermore, these

remote signals are used to implement distributed tuple-

spaces, discussed later.

8.4 Mobile agents

Mobile agents can be used to distribute information in

networks. They can get data/information from the tuple-

space of the current node and store them in remote tuple-

spaces by migrating to the respective nodes. The advantage

of this approach is the ability to ﬁnd suitable remote nodes

and paths to nodes autonomously or based on content

negotiation, and to ﬁlter, map, or process the collected data,

e.g., using data fusion techniques. The disadvantage is a

high communication and processing overhead caused by

the agent process migration.

Additionally, mobile agents can be used to deliver data

in mobile network environments by using a mobile device

for spatial migration (piggyback approach, see [27] for

details), not possible with A2A/A2N signals or remote

tuples.

8.5 Distributed tuple-spaces

The new JAM platform 2.0 introduces the support for tuple

migration using the collect, copyto, and store operations

performed by agents. This feature enables the composition

of distributed tuple-spaces controlled by agents. The collect

and copyto operations transfer tuples from the local tuple-

space to a remote using pattern matching, similar to the inp

and rd operations. The stor e operation sends a tuple to a

remote tuple-space, similar to the out operation.

Remote tuple space access is performed by A2N signals.

8.6 Assessment of communication

The scaling and performance of distributed and cluster

computing is strongly related to the communication

architecture. In this work, computation is coupled to a

physical system and communication depends on changes of

the physical system and the respective sensors (e.g., strain

sensors). To evaluate and compare different communica-

tion approaches described previously, a simulation of a

large scale network under real operation conditions was

performed using the reference architecture from Sect. 4

and the multi-domain simulation from Sect. 9.

The computational network consists of 8  5  3 nodes,

and the physical Device under Test (DUT) is a plate

(modelled with 8  5  3 body nodes). The network can

perform event-based sensor distribution as discussed in

Sect. 6. Results are shown in Fig. 7.

The bottom plots show the event-based communication

activity in the network as a response to a physical state

change. Nodes and their node agents decide individually

about distributing new sensor data avoiding the ﬂooding of

the network with messages. Three different physical con-

ﬁgurations were compared resulting in different network

behaviour: Full plate, plate with hole, and with an addi-

tional load (Fig. 7, top). The last case causes the highest

network activity due to the highest level of dynamic

changes of the physical system.

9 Multi-domain simulation

The design and technological implementation of robotic

materials is a considerable challenge. Fundamental con-

cepts have to be proven before any real system can be

developed. Due to the strong coupling of sensing, reactive

control, and information processing a multi-domain and

multi-scale simulation was conducted posing a tight cou-

pling of physical and computational models.

There are different mechanical models and solvers that

can be used to compute the behaviour of the physical

system in response to different load and use case situations

and the reaction of a computational control system:

1. Finite elements analysis (FEA); and

2. Multi-body physics (MBP, based on coupled spring-

mass element networks).

The second model is closer to the proposed computational

mesh-grid node network architecture and structures on

macro level, while the ﬁrst model is better related to

materials on micro level. Based on these two mechanical

models two different computational frameworks perform-

ing applying structure/material optimization are used.

Cluster Computing

123

FEA-NUM: ﬁnite element analysis is used to develop

and evaluate optimization algorithms, performing, e.g., the

minimization of a target function value numerically, e.g.,

reducing the total strain energy, local strain, or inner force

peaks. FEA is stationary, i.e., no swinging or oscillation of

the structure under test is considered, and a FEA simulation

iteration ends with a stationary state of the structure.

Algorithms operating on global (centralized) and local data

(distributed) were originally investigated using Abaqus

FEA simulation and Matlab performing the computational

part of the algorithms [33].

MBP-MAS: simulation of multi body physics in com-

bination with MAS is used to investigate and evaluate the

computational and coordination model proposed in this

work (details in [21]). In contrast to static FEA the MBP

simulation is dynamic and provides real-time resolution

behaviour of structures. The MAS interacts with non-sta-

tionary states of the structures (swinging, oscillation, ..),

too, which is closer to real-world interaction. The MAS

implements the algorithms investigated in prior FEA.

One major difference between the FEA-NUM and the

MBP-MAS approach concerns the sensor processing. The

nearly real-time resolution MBP-MAS approach performs

sensor distribution by MAS communication that introduces

different time delays affecting the optimization algorithms

and their outcome. Additionally, the MAS operates event-

based, leading to varying responses to a sensor stimulus as

a result of structure dynamics.

Monte-Carlo methods: complex distributed and cou-

pled systems tend to be very sensitive to small parameter

changes, i.e., small input changes (actio) result in large

output changes (reactio). Therefore, it is essential to repeat

simulations with varying randomized disturbances, e.g., by

applying small variations to an initial set-up of the spring

stiffness.

Fig. 7 Computation and

communication of a MAS:

simulation results and

comparison of different

communication strategies under

different structure and load

situations of the reference

architecture. Action of the

MAS: Event-based sensor

distribution. (Top) Case 1: plate,

Case 2: plate with large hole,

Case 3: plate with hole and an

additional circular load on the

top. (Middle) total computation

and communication after 15,000

simulation steps (Bottom)

selected time plots of

communication and signals for

remote tuple approach

Cluster Computing

123

Using the SEJAM simulator, the physical and compu-

tational system can be simulated simultaneously studying

the coupling and response of both systems to modiﬁcations.

The entire monolithic simulation framework is shown in

Fig. 8. It is entirely programmed in JavaScript and exe-

cuted by the node webkit framework (nodejs JS VM for

computation and IO combined with Chromium WEB

browser for GUI implementation), and the simulation

model consisting of the MAS program code and the

physical CANNON model is speciﬁed in JavaScript and

JSON, too. The computational and the physical simulation

are coupled tightly, i.e., agents can access the physical

model and simulation and vice versa. Agents are processed

with a JAM instance. This architecture enables the inte-

gration of the simulator in real world environments

(hardware-in-the-loop) deployed with JAM networks. Fur-

thermore, the direct JAM processing provides advanced

and realistic computational and communication analysis.

10 Use-case and evaluation

The multi-domain simulation introduced in the previous

section is used to demonstrate and evaluate the proposed

optimization algorithms, MAS implementation providing

self-organizing and self-adaptivity features, and the JAM

platform with an advanced use-case. The device under test

used in the simulation is a plate consisting of 8  5  3

nodes. Each node is a mass in the MBP model connected

up to nine neighbours via springs and a computer in the

MAS model connected to up to six neighbour nodes via

communication links. The start condition of the physical

plate is shown in Fig 8. Spring and gravity forces have an

effect on each mass element of the plate. Therefore, the

plate will swing between a maximal and a minimal bend

until it reaches a static state. The MAS will respond in a

given time to dynamic changes. The global goal may not be

effected by this dynamic response, e.g., the MAS behaviour

must not oscillate.

The event-based MAS will process sensor input data

differently (spatially and temporal) unlike the numerical

algorithms presented in Table 1. The results from the

simulation uses as a Device under Test (DUT) a plate basic

shape with a large central hole and an additional load on

the top of the DUT, which is shown Fig. 9. The diagrams in

Fig. 9 compare the outcome of physical and computational

properties of the DUT with different optimization algo-

rithms. All optimization results are compared with the

same DUT without performing optimization (no actuation,

only perception and sensor processing).

Fig. 8 (Bottom) The multi-

domain simulation environment

coupling physical and

computational systems (Top,

left) Computational network

using JAM for computation and

communication (Top, right)

physical body-spring network

using CANNON for solving the

physical equations

Cluster Computing

123

The physical properties give the accumulated total strain

energy U of the structure (global value), the maximum

node strain energy u (local value) from all nodes (including

boundaries), the maximum node energy of only the core

area of the structure, maximum of forces between nodes

(taken from the entire optimization run), and the accumu-

lated stiffness of all springs in the structure as a measure of

energy required for actuators (in arb. units).

The communication and computational properties give

the accumulated communication load (in Bytes), the

accumulated number of remote signals (messages), and the

total accumulated active computation time of all nodes (in

arb. units) as a measure of the electrical energy required for

the entire optimization run.

The hole in the DUT introduces interruptions of the

communication network and affects the migration of agents

or the delivery of signals, but not the global emergence

behaviour satisfying the optimization goal of the MAS,

shown in the optimization progress of the segment algo-

rithm still achieving nearly the same results as the global

algorithm.

The results show the suitability of the event-based MAS

approach and the distributed algorithms versa the global

centralized algorithm. The achieved strain energy reduc-

tion is about 40%. The segmented approach using a ﬂoating

segment window around each node ’ s center position

delivers comparable results without the need for a central

instance. However, there is a signiﬁcant difference between

the step-wise and linear correction function. Only the linear

stiffness adaptation between the (technical possible) limits

achieves a high total (global) strain energy and maximal

node strain energy reduction. The step-wise correction

(leading basically to a discrete stiffness distribution)

achieves only a 10% reduction. Among the total strain

energy the total sum of stiffness settings of all nodes is

important. Each stiffness increase (of an actuated spring)

requires energy, whereas a decrease can release energy

(that could be harvested and stored by the system). The

linear correction leads to an increase of the stiffness sum

about of 40%, whereas the step-wise (discrete distribution)

approach decreases the sum about of 35%. This overall

stiffness reduction can be considered as a structural

relaxation, and is a base for a high dynamic adaptation

capability of the structure as there is a better utilization of

the actuator ranges. The neighbour negotiation algorithms

underperforms compared with the new segment approach

but requires the lowest communication and computational

resources (about 50% less than the segmented approach)

As expected, the global approach creates the highest

communication and computational costs.

It should be noted that the results are sensitive to the

MAS parameter settings like sensor event and notiﬁcation

thresholds. For example, the communication and compu-

tational costs depend on the notiﬁcation behaviour inhibi-

tion delay (update interval setting). The lowest

accumulated computation time of the ICT network is

Fig. 9 Evaluation of simulation results (DUT: plate with hole and

external load) using different optimization algorithms (Top) Outcome

of physical properties of the DUT: Total strain energy U and node

strain energy u, forces, and stiffness [arbitrary units] (Bottom)

Outcome of ICT properties: Total communication [Bytes], signals

[arbitrary units], and computation [time, s]

Cluster Computing

123

required by the neighbour negotiation algorithm due to the

lowest sensor event rates and actuator modiﬁcations. The

three algorithms differ in convergence and stability

(oscillation of the structure due to over- and under-opti-

mization) and therefore have a signiﬁcant inﬂuence on the

ICT activity and the energy consumption.

The evaluation of a structure conﬁguration with a large

hole inside of the structure, interrupting communication

and actuation, demonstrates the capability of the used MAS

behaviour and optimization algorithm to compensate

missing nodes. The proposed approach shows a low sen-

sitivity to damages (both concerning the ICT and the

structure optimization).

11 Dynamic topology optimization

and lightweight structures

Topology optimization in its classical form is a technique

to improve material utilization: Within a given design

space, and for a given load case, blocks of material are

removed in areas with limited internal loads. A review of

various approaches has recently been provided by Sigmund

and Maute [34]. The underlying assumption is that these

material fractions contribute least to structural stiffness: It

may be added here that topology optimization is generally

executed in the linear-elastic regime. Since material is only

removed, but not relocated, stiffness must effectively be

reduced in the process.

However, this necessary loss in stiffness falls short of

the reduction in weight, leading to an increase in speciﬁc or

weight- related stiffness. A designer can thus in principle

exploit the result of an optimization run to generate a ﬁnal

structure which may—if permissible—transgress the

boundaries of the original part and offer the same stiffness

at reduced weight. The weight reductions achievable via

this principle are limited, but signiﬁcant. For example, by

rule of thumb, if the original problem is a solid beam,

supported at both ends and loaded in bending, a weight

reduction of roughly 30% can be achieved at a marginal

loss of stiffness. For other, more technical and thus more

complex components and associated load cases, weight

reductions of approximately 20% have been demonstrated.

Naturally, the success of the method in optimizing a given

structure depends on the level of sophistication of the

original design. In many cases, however, an exact quan-

tiﬁcation is impossible because the topology-optimized

design cannot be matched against a conventional one, as

the method is typically applied early in the design phase

and using the complete design space as starting point.

In practice, manufacturing process constraints and lim-

itations have sometimes hampered the implementation of

topology-optimized designs. Processes like milling require

direct access to the surfaces that are to be machined.

Typically, optimum designs thus undergo a reworking

based on manufacturability. In contrast, the geometrical

ﬂexibility of additive manufacturing has the potential of

developing into a high road for pushing topology- opti-

mized design from the virtual to the real world on a larger

scale. A recent publication by Zhu et al. has collected

several examples that illustrate the application of topology

optimization to aerospace structures [35].

Valdez et al. have recently published and overview of

benchmark solutions for typical, recurring 2D problems.

Their study does not provide clear answers on achievable

weight savings, since their starting point is a standard

rectangular design space, but conveys a good impression of

the type of solution the method generates, and their

dependence on—sometimes slight—changes in the

boundary conditions [36]. Multi-phase topology optimiza-

tion as developed by Burblies deviates from the above in

considering multiple materials having individual proper-

ties—speciﬁcally, their elastic properties (Young’s modu-

lus etc.) are assumed to differ. Depending on the load case,

the optimization approach relocates the originally arbi-

trarily distributed material elements within the set build

envelope/space to achieve maximum stiffness. This is done

by means of an element exchange technique which mini-

mizes total strain energy in the system. The result is a

structure which matches the original one in weight (mate-

rial is not removed, but only redistributed), but shows

superior stiffness. The high stiffness solution can then be

transformed into a design which takes over the suggested

structuring, but reduces the amount of material used and

thus the structure’s weight while still meeting stiffness

requirements [13]. The central drawback of the methods as

described above is that optimization is typically done for a

single load case. As a consequence, the resulting structure

may underperform compared to a non-optimized one if the

loading situation changes. Besides, the optimized structure

may turn out to behave more critical under unexpected load

cases: For example, topology-optimized designs typically

tend to be more prone to failure modes like buckling.

To avoid these issue, strategies like average design

can be adopted which generate a common solution out of

the optimization results obtained for several load cases.

However, this approach will naturally limit the weight

saving potential, since the ﬁnal solution moves away

from the optimum for each single load case considered.

This situation is the realm which must seem most

promising for the suggested dynamic optimization

approach: Instead of having a structure that can cope

reasonably well with different load cases, we propose a

structure that can dynamically adapt to the load cases it

recognises and will thus adopt the optimum conﬁguration

for each of them.

Cluster Computing

123

Needless to say, this type of structure will also be able to

respond to load cases not explicitly considered in the

component design phase. This capability may allow for

reduction of safety margins and thus facilitate additional

weight savings.

In summary, we consider an average weight saving

potential accessible through the suggested adaptive mate-

rials of approximately 20% a conservative estimate.

Beyond suitable algorithms as discussed in this paper,

materials and/or structural solutions that allow implemen-

tation of these will be a major issue to be solved in future

research.

12 Conclusion and outlook

This paper showed the suitability of Multi-Agent Systems

for reliable distributed computing in large-scale low-re-

source computer networks by evaluating the use case with

a reference architecture of a self-adaptive robotic material

composed of nodes connected by actuated spring elements.

Each node is a micro-controller providing sensor process-

ing, power electronics, communication (wired or wireless),

an agent processing platform, and data storage. Such

robotic materials are characterized by a tight coupling of

computation, communication, sensing, and actuation. The

distributed computing and communication in material-in-

tegrated large-scale computer networks can be considered

as micro-scale cluster computing.

The goal of the MAS is to optimize the material or

structure under varying load situations and damages by

collecting observation variables (i.e., strain sensor data)

and modifying target variables (actuators, i.e., stiffness of

spring parameters) without any central instance (self-or-

ganized and event-based). The emergence behaviour of the

MAS was robust by adaptivity in the presence of large

defects.

Different optimization algorithms were introduced and

evaluated using the JavaScript Agent Machine platform. A

global optimization approach based on Multi-Phase

Topology Optimization was used as a reference algorithm

for comparison with two distributed segment and neigh-

bour algorithms enabling dynamic topology optimization at

run-time. The segment algorithm achieved a 40% reduction

of the total mechanical strain energy of the structure under

test (with a damage and external load applied), which is a

relevant measure of stability by self-adaptation and self-

healing behaviour.

Although the JAM platform can be used on low-resource

embedded computers, another very-low resource platform

AFVM was introduced that is suitable for material-inte-

grated computing. A just-in-time cross-compiler approach

can be used to enable seamless migration of mobile agents

between both agent processing platforms, which is

mandatory for connecting robotic materials to the IoT and

Clouds.

Different agent communication approaches were dis-

cussed and evaluated under real conditions (sensor pro-

cessing in the robotic material) showing efﬁcient and

scalable behaviour. Mobile agents with a uniﬁed agent

programming and processing platform are the key tech-

nology for the creation of smart IT materials, e.g., tangible

user interfaces [37], product life-cycle management [17],

integration in the Internet of Things environment and

providing Cloud Services for and with robotic materials in

everyday customer devices.

Future work has to investigate the implementation of the

proposed MAS using the AFVM platform deployed in real

robotic structures. Although the AFVM bases on the same

AAPL agent metal model, is forces much higher limitations

and constraints with respect to agent code and data com-

plexity, and overall storage capacity. In this work the

simulation was performed with ideal actuators and sensors

described via linear input-output models. Technical actu-

ators, e.g., thermoplastic materials actuated by temperature

variations, show highly non-linear behaviour. The pro-

posed MAS and optimization algorithms have to be eval-

uated towards such unreliable and non-linear actuators and

sensors. Finally, the weight saving potential and energy

balances have to be investigated rigorously.

One major ﬁeld of application and future road map for

the proposed MAS and ICT architecture is the dynamic

topology optimization (DTO) in complex mechanical

structures and components introduced conceptually in

Sect. 11. A proof-of-concept has to demonstrate the weight

saving by DTO by the MAS at run-time. Furthermore,

transferring this future work to actual physical materials

and structure heavily depends on advances in manufac-

turing technologies, sensors, and hybrid material design.

References

1. Choi, T.L.M., Sui, Y., Lee, I.H., Meredith, R., Ma, Y., Kim, G.,

Blaauw, D., Gianchandani, Y.B.: Autonomous microsystems for

downhole applications: design challenges, current state, and ini-

tial test results. Sensors 17, 2190 (2017)

2. Di Lecce, V., Calabrese, M., Martines, C.: From sensors to

applications: a proposal to ﬁll the gap. Sens. Transd. 18, 5–13

(2013)

3. Bosse, S., Lehmhus, D., Lang, W., Busse, M. (eds.): Material-

Integrated Intelligent Systems: Technology and Applications.

Wiley, New York (2018). 978-3-527-33606-7

4. McEvoy, M.A., Correll, N.: Materials science. Materials that

couple sensing, actuation, computation, and communication.

Science 347(6228), 1261689 (2015)

Cluster Computing

123

5. McEvoy, M.A., Correll, N.: Materials science. Materials that

couple sensing, actuation, computation, and communication.

Science 347(6228), 1261689 (2015)

6. McEvoy, M.A., Correll, N.: Thermoplastic variable stiffness

composites with embedded, networked sensing, actuation and

control. J. Compos. Mater. https://doi.org/10.1177/

0021998314525982, (2014)

7. Zhao, L., Ma, J., Wang, T., Xing, D.: Lightweight design of

mechanical structures based on structural bionic methodology.

J. Bionic Eng. 7, 224–231 (2010)

8. Hamm, C., Mu

ller, S.: ELiSE—an integrated, holistic bionic

approach to develop optimized lightweight solutions for engi-

neering, architecture and design. In: Hamm, C. (ed.) Evolution of

Lightweight Structures. Springer, Dordrecht (2015)

9. Hamm, C.: ELiSE: Bionic Lightweight Design, Project Flyer.

Alfred-Wegener-Institut Helmholtz-Zentrum fu

r Polar- und

Meeresforschung, Bremerhaven (2013)

10. Jog, C., Haber, R., Bendsoe, M.: Topology design with opti-

mized, self-adaptive materials. Int. J. Numer. Methods Eng.

37(8), 1323–1350 (1994)

11. McEvoy, M.A., Correll, N.: Distributed inverse kinematics for

shape-changing robotic materials. Procedia Technol. 26, 4–11

(2016)

12. Joo, J.J., Sanders, B., Washington, G.: Energy based efﬁciency of

adaptive structure systems. Smart Mater. Struct. 15(1), 171

(2006)

13. Burblies, A., Busse, M.: Computer Based Porosity Design by

Multi Phase Topology Optimization. In: Multiscale & Function-

ally Graded Materials Conference (FGM2006), Honolulu, Octo-

ber 15th–18th (2006)

14. Caridi, M., Sianesi, A.: Multi-agent systems in production plan-

ning and control: an application to the scheduling of mixed-

model assembly lines. Int. J. Prod. Econ. 68, 29–42 (2000)

15. Leito, P., Karnouskos, S.: Industrial Agents Emerging Applica-

tions of Software Agents in Industry. Elsevier, Amsterdam (2015)

16. Bosse, S., Lechleiter, A.: Structural health and load monitoring

with material-embedded sensor networks and self-organizing

multi-agent systems. Procedia Technol. https://doi.org/10.1016/j.

protcy.2014.09.039, (2014)

17. Lehmhus, D., Wuest, T., Wellsandt, S., Bosse, S., Kaihara, T.,

Thoben, K.-D., Busse, M.: Cloud-based automated design and

additive manufacturing: a usage data-enabled paradigm shift.

Sens. MDPI 15(12), 32079–32122 (2015). https://doi.org/10.

3390/s151229905

18. Bosse, S.: Mobile Multi-Agent Systems for the Internet-of-

Things and Clouds using the JavaScript Agent Machine Platform

and Machine Learning as a Service. In: The IEEE 4th Interna-

tional Conference on Future Internet of Things and Cloud, 22–24

August 2016, Vienna, Austria (2016)

19. Bosse, S.: Uniﬁed Distributed Computing and Co-ordination in

Pervasive/Ubiquitous Networks with Mobile Multi-Agent Sys-

tems using a Modular and Portable Agent Code Processing

Platform. In: The 6th International Conference on Emerging

Ubiquitous Systems and Pervasive Networks (EUSPN 2015),

Procedia Computer Science (2015)

20. Milner, R.: The Space and Motion of Communicating Agents.

Cambridge University Press, Cambridge (2009)

21. Bosse, S., Lehnhus, D.: Towards Large-Scale Material-integrated

Computing: Self-Adaptive Materials and Agents. In: 2017 IEEE

2nd International Workshops on Foundations and Applications of

Self* Systems (FAS* W), IEEE, https://doi.org/10.1109/FAS-W.

2017.123, (2017)

22. Janocha, H. (ed.): Adaptronics and Smart Structures, 2nd edn.

Springer, Berlin (2007)

23. Choi, M., Sui, Y., Lee, I.H., Meredith, R., Ma, Y., Kim, G.,

Blaauw, D., Gianchandani, Y.B., Li, T.: Autonomous microsys-

tems for downhole applications: design challenges, current state,

and initial test results. Sensors 17(10), 2190 (2017). https://doi.

org/10.3390/s17102190

24. Poslad, S.: Ubiquitous Computing: Smart Devices, Environments

and Interactions. Wiley, London (2009)

25. Haneef, F., Angalaeswari, S.: Self-healing framework for distri-

bution systems. Int. J. Sci. Eng. Res. 4(7), 377–382 (2013)

26. Pournaras, E., Moise, I., Helbing, D.: Privacy-preserving Ubiq-

uitous Social Mining via Modular and Compositional Virtual

Sensors. In: IEEE 29th International Conference on Advanced

Information Networking and Applications, (2015)

27. Bosse, S., Pournaras, E.: An Ubiquitous Multi-Agent Mobile

Platform for Distributed Crowd Sensing and Social Mining. In:

FiCloud 2017: The 5th International Conference on Future

Internet of Things and Cloud, Aug 21, 2017–Aug 23, Prague,

Czech Republic, (2017)

28. Bosse, S.: Design of Material-integrated Distributed Data Pro-

cessing Platforms with Mobile Multi-Agent Systems in Hetero-

geneous Networks. In: Proceedings of the 6’ th International

Conference on Agents and Artiﬁcial Intelligence ICAART (2014)

https://doi.org/10.5220/0004817500690080

29. Bosse, S.: Incremental distributed learning with JavaScript agents

for earthquake and disaster monitoring. Int. J. Distrib. Syst.

Technol. (IJDST) (2017) https://doi.org/10.4018/IJDST.

2017100103

30. Bosse, S.: Distributed Machine Learning with Self-organizing

Mobile Agents for Earthquake Monitoring. In: 2016 IEEE 1st

International Workshops on Foundations and Applications of

Self* Systems (FAS*W), SASO Conference, DSS, 12 September

2016. Augsburg, Germany (2016)

31. Chunlina, L., Zhengdinga, L., Layuanb, L., Shuzhia, Z.: A mobile

agent platform based on tuple space coordination. Adv. Eng.

Softw. 33(4), 215–225 (2002)

32. Qin, Z., Xing, J., Zhang, J.: A replication-based distribution

approach for tuple space-based collaboration of heterogeneous

agents. Res. J. Inf. Technol. 2(4), 201–214 (2010)

33. Lehmhus, D., Bosse, S., Gemilang, A.: Multi-Agent System, A.,

based approach for Adaptive Property Control in Smart Load-

Bearning Structures, European Congress and Exhibition on

Advanced Materials and Processes, EUROMAT (2017), Sym-

posium E6, Modeling, Simulation and Optimization, 17–22

September, 2017, Thessaloniki, Greek

34. Sigmund, O., Maute, K.: Topology optimization approaches—a

comparative review. Struct. Multidiscip. Optim. 48, 1031–1055

(2013). https://doi.org/10.1007/s00158-013-0978-6

35. Zhu, J.-H., Zhang, W.-H., Xia, L.: Topology optimization in

aircraft and aerospace structures design. Arch. Comput. Methods

Eng. 23, 595–622 (2016). https://doi.org/10.1007/s11831-015-

9151-2

36. Ivvan Valdez, S., Botello, S., Ochoa, M.A., Marroquin, J.L.,

Cardoso, V.: Topology optimization benchmarks in 2D: results

for minimum compliance and minimum volume in planar stress

problems. Arch. Comput. Methods Eng. 24, 803–839 (2017).

https://doi.org/10.1007/s11831-016-9190-3

37. Kang, J.: Technique of Tangible User Interfaces for Smartphone.

In: 12 International Conference on Information and Computer

Applications (ICICA 2012) IPCSIT, vol. 24 (2012)

Cluster Computing

123

Stefan Bosse studied physics at

the University of Bremen. He

received a Doctoral Degree (Dr.

rer. nat.) in physics in the year

2002 (‘‘Laser and Advanced

Optical Measuring Tech-

niques’’) at the University of

Bremen, and the post-doctoral

degree (Habilitation) and the

Venia Legendi in Computer

Science in the year 2016 at the

University of Bremen with his

habilitation ‘‘Uniﬁed Dis-

tributed Sensor and Environ-

mental Information Processing

with Multi-Agent Systems: Models, Platforms, and Technological

Aspects’’. Starting from April 2018 he is an interim professor at the

University of Koblenz-Landau, Faculty Computer Science. His

research focuses on distributed artiﬁcial intelligence, in particular

agent-based modeling, simulation, and computation, with an highly

interdisciplinary work addressing computer science, material science,

technologies, and sociology. He teaches several courses at the

University of Bremen and Koblenz-Landau in fundamental computer

science and in selected advanced topics covering the design of par-

allel and distributed systems, multi-agent systems, multi-domain

simulation, high-level synthesis, and material-integrated intelligent

systems with a high interdisciplinary background. He published about

100 publications and several books.

Dirk Lehmhus is a senior

researcher at the Fraunhofer

Institute for Manufacturing

Technology and Advanced

Materials (IFAM), Department

of Shaping and Functional

Materials, Bremen, Germany.

He studied Mechanical Engi-

neering at the University of

Hanover, and got his PhD

degree of Dr.- Ing. on produc-

tion and properties of aluminum

foams at the University of Bre-

men in the year 2007 (supervi-

sor Prof. M. Busse). He has a

longterm experience as a Managing Director of the Scientiﬁc Centre

ISIS Sensorial Materials from the University of Bremen. His research

focuses on functional materials and structures for sensing and energy

harvesting applications, multifunctional composite and hybrid mate-

rials, and the integration of sensorial capabilities in materials and

components, cellular metallic materials, and metal foams.

Cluster Computing

123