Stefan Bosse - A hybrid approach for Structural Monitoring with self-organizing multi-agent systems and inverse numerical methods in material-embedded sensor networks

A hybrid approach for Structural Monitoring with self-organizing

multi-agent systems and inverse numerical methods in

material-embedded sensor networks

Stefan Bosse

⇑

, Armin Lechleiter

University of Bremen, Dept. of Mathematics & Computer Science, Robert Hooke Str. 5, 28359 Bremen, Germany

article info

Article history:

Received 17 November 2014

Revised 24 July 2015

Accepted 23 August 2015

Available online 28 October 2015

Keywords:

Structural health monitoring

Sensor network

Mobile agent

Heterogeneous networks

Embedded systems

Inverse numerical computation

abstract

One of the major challenges in Structural Monitoring of mechanical structures is the derivation of mean-

ingful information from sensor data. This work investigates a hybrid data processing approach for

material-integrated structural health and load monitoring systems by using self-organizing mobile

multi-agent systems (MAS), and inverse numerical methods providing the spatial resolved load informa-

tion from a set of sensors embedded in the technical structure with low-resource agent processing plat-

forms scalable to microchip level, enabling material-integrated real-time sensor systems. The MAS is

deployed in a heterogeneous environment and offers event-based sensor preprocessing, distribution,

and pre-computation. Inverse numerical approaches usually require a large amount of computational

power and storage resources, not suitable for resource constrained sensor node implementations.

Instead, the computation is partitioned into spatial off-line (outside the network) and on-line parts, with

on-line sensor processing performed by the agent system. A uniﬁed multi-domain simulation framework

is used to proﬁle and validate the proposed approach.

1. Introduction

Structural Monitoring of mechanical structures allows to derive

not just loads by using Load Monitoring (LM), but also their effects

to the structure, its safety, and its functioning from sensor data,

offering some kind of Structural Health Monitoring (SHM). A load

monitoring system is a basic component of a SHM system, which

provides spatial resolved information about loads (forces,

moments, etc.) applied to a technical structure, with applications

ranging from robotics to building monitoring.

One of the major challenges in SHM and LM is the derivation of

meaningful information from sensor input. The sensor output of a

SHM or LM system reﬂects the lowest level of information. Beside

technical aspects of sensor integration the main issue in those

applications is the derivation of a information mapping function

Map(s, E): s  E ? i that basically maps the raw sensor data input

s,an-dimensional vector consisting of n sensor values, on the

desired information i,am-dimensional result vector. The result

of the computed information commonly depends on some abstract

environmental setting E (see Fig. 1) arising in all technical systems,

i.e., the disturbance of data caused by communication, data

processing, energy supply, or temporal and spatial data

distribution. The goal of the mapping function it to reduce the data

dimension signiﬁcantly, i.e., m  n.

This work investigates a hybrid data processing approach for

material-integrated LM systems by using self-organizing and

event-driven mobile multi-agent system (MAS), with agent

processing platforms scaled to microchip level which offer

material-integrated real-time sensor systems, and inverse numer-

ical methods providing the spatially resolved load information

from a set of sensors embedded in the technical structure. Such

inverse approaches usually require a considerable amount of com-

putational power and storage resources, not very well matching

resource constrained sensor node implementations. Instead, off-

line computation is performed, with on-line sensor processing by

the agent system. Commonly off-line computation operates on a

continuous data stream requested by the off-line processing sys-

tem delivering sensor data continuously in ﬁxed acquisition inter-

vals, resulting in high communication and computational costs. In

this work, the sensor preprocessing MAS delivers sensor data

event-based if a change of the load was detected (feature extrac-

tion), reducing network activity and energy consumption signiﬁ-

cantly. Inverse numerical algorithms use matrix computations

extensively, so it is in principle possible to distribute and perform

http://dx.doi.org/10.1016/j.mechatronics.2015.08.005

⇑

Corresponding author.

Mechatronics 34 (2016) 12–37

Contents lists available at ScienceDirect

Mechatronics

journal homepage: www.elsevier.com/locate/mechatronics

some of the matrix computations in the sensor network offering an

on-line pre-computation by the MAS. This is a main advantage over

Machine Learning methods used in LM and SHM systems [1–3],

which are more difﬁcult to distribute efﬁciently due to long dis-

tance data dependencies.

Basically there are two different information extraction

approaches for material-integrated LM systems and a possible

optimization of sensor positions: (I) Those methods based on a

mechanical and numerical model of the technical structure, the

Device under Test (DUT), and the sensor; (II) Those without any

or with a partial physical model. The latter class can proﬁt from

artiﬁcial intelligence, which is usually based on classiﬁcation algo-

rithms derived from supervised machine learning or pattern recog-

nition using, for example, self-organizing systems like multi-agent

systems with less or no a priori knowledge of the environment.

One common approach in SHM is the correlation of measured

data resulting from an induced stimuli at run-time (system

response) with data sets retrieved from an initial (ﬁrst-hand)

observation, which makes it difﬁcult to select damage relevant

features from the measurement results. Other variants are based

on statistical methods, data analysis using Fourier- or wavelet-

techniques, or neural network approaches. We refer to [4–8]

(Chapter 12) posing examples illustrating the variety of possible

approaches.

Inverse methods generally belong to the ﬁrst class of

approaches since they are based on a mechanical model T of the

technical structure mapping loads to sensor signals. In this study,

we consider measurements of surface strains and aim to compute

the associated spatially varying (discretized) loads l on the struc-

ture. The mechanical model T is gained from linear elasticity and

can, in a discretized setting, be represented by a matrix. Given a

sensor signal vector s (serialization of a two-dimensional sensor

matrix S, which is a approximately linear depending on the mea-

sured strain), inverse methods try to stably ‘‘invert”; the mapping

T, that is, to ﬁnd a stable solution l to the problem Tl = s. Since mea-

sured signals and the underlying physical model always contain

numerical and modelling errors, inverse methods do not attempt

to ﬁnd an exact solution to the latter equation. Indeed, inversion

problems, in particular those with incomplete data, are usually

extremely ill-conditioned, meaning that small errors in the signals

or the model lead to huge errors in any ‘‘solution”; gained by such a

naive approach. Instead, inverse methods try to stabilize the inver-

sion process, using, e.g., one of the following techniques:

 A classical and well-known inversion method is Tikhonov regu-

larization. Pick amongst all approximated solutions to Tl = s the

one that minimizes a certain functional – the simplest func-

tional to minimize would be the Tikhonov functional

l # Tl  s

; ð1Þ

where a > 0 and kk

is the 2-norm of a vector deﬁned by Eq.

(2), but different and more complicated variants exist and might

also be convenient choices. The latter vector norm is deﬁned for

any dimension n 2 N and any vector

v ¼ðv

; ...; v

2 R

j¼1

1=2

: ð2Þ

 Alternatively, consider any iterative method that minimizes the

residual Tl  s and stabilize the inversion by stopping the itera-

tion when the norm of the residual is about the magnitude of

the expected signal and modelling error. Examples for such iter-

ative techniques include the Landweber iteration, the conjugate

gradient iteration, but also recent soft shrinkage techniques, see

[9,10].

If the mechanical model T is linear, then the best known inver-

sion method in the ﬁrst class is the Tikhonov regularization mini-

mizing the quadratic functional (Eq. (1)) by solving the equivalent

linear system (T

⁄

T +

)l = T

⁄

s, where T

⁄

denotes the transpose

matrix of T. The most powerful algorithm in the second class is,

arguably, the conjugate gradient iteration. The disadvantage of

inverse methods with regard to applications based on sensor net-

works usually is their cost in terms of computing time and memory

requirements which deﬁnitely is a drawback for material-

integrated SHM and LM systems. The possibly high computing

Fig. 1. Initially unknown external forces acting on a mechanical structure lead to an deformation of the material based on the internal forces. A material-integrated active

sensor network [22] composed of sensors, electronics, data processing, and communication, together with mobile agents can be used to monitor relevant sensor changes with

an advanced event-based information delivery behaviour. Inverse numerical methods can compute ﬁnally the material response. The unknown system response for

externally applied load l is measured by the strain sensor stimuli response s’ (a function of s), and ﬁnally inverse numerical methods compute an approximation l’ to the

applied load.

S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

time and memory requirements for pre-computations before actu-

ally launching the monitoring device due to the physical and

numerical model are nowadays becoming less important due to

advanced numerical simulation methods and increasing computa-

tional power.

Reliable distributed data processing in sensor networks using

multi-agent systems (MAS) were recently reported in [11] and

employed for SHM applications in [12]. An adaptive and learning

behaviour of MAS, which is a fundamental principle in the agent

model, can aid to overcome technical unreliability and limitations

[13]. Artiﬁcial intelligence and machine learning can be used in

sensorial materials without a predictive mechanical model at hand

[1], which is a deﬁnite advantage for complex materials.

Multi-agent systems can be used for a decentralized and self-

organizing approach of data processing in a distributed system like

a sensor network (that is already applied in macro-scale applica-

tions, e.g., in [14]), enabling information extraction, for example,

based on pattern recognition [15], by decomposing complex tasks

in simpler cooperative agents.

In this work the behaviour of mobile agents is related to a state

and is modelled with an activity-transition graph (ATG) which is

implemented with the Activity-based Agent Programming Lan-

guage AAPL [16]. An activity is related with a state and actions per-

formed by activating an activity by a transition.

AAPL models can be compiled to various agent processing plat-

form architectures including programmable code-based stack

machines [17] and non-programmable, part of each sensor node.

The non-programmable agent processing platform implements

the ATG behaviour directly [16], enabling very low-resource single

microsystem platforms. In the case of the programmable agent

platform the program code implements the agent behaviour

entirely. The ATG can be modiﬁed at run-time by the agent itself

using dedicated AAPL transformation statements [18]. By using

program code that is executed on a Virtual Machine (VM) this is

performed by code morphing techniques provided by the VM.

Agents carrying the code, data, and already applied modiﬁcations,

are capable to migrate in the network between nodes [18]. Both

processing platform architectures use token-based and pipelined

agent processing for optimized resource sharing and parallel

execution.

The programmable agent processing platform used for the exe-

cution of agents is a pipelined stack-based virtual machine, with

support for code morphing and code migration. This VM approach

offers small sized agent program code, low system complexity,

high data processing performance, and enables the support of

heterogeneous network ranging from microchips to the internet.

The agent platform VM can be implemented directly in hardware

with a System-on-Chip design. Agents processed on one particular

node can interact by using a tuple-space server provided by each

sensor node. Remote interaction is provided by signals carrying

data which can cross sensor node boundaries.

This approach provides a high degree of computational inde-

pendency from the underlying platform and other agents, and

enhanced robustness of the entire heterogeneous environment in

the presence of node, sensor, link, data processing, and communi-

cation failures. Support for heterogeneous networks considering

hardware (System-on-Chip designs) and software (microproces-

sor) platforms is covered by one design and synthesis ﬂow includ-

ing functional behavioural simulation. For material-integration,

there is an application speciﬁc agent processing platform that

implements the agent behaviour on-chip, offering the lowest

resource and chip area requirements.

The mechanical model of the structure under investigation

allows in particular the pre-computation of a sufﬁciently accurate

discretization of the forward mapping T linking loads with mea-

sured signals. Moreover, this pre-computation allows to associate

to each sensor an individual signal level that might potentially

be critical for the entire structure.

Hence, when a load change that is potentially critical is detected

by one the material-integrated sensors, the signals measured by all

sensors are propagated to an exterior CPU. An alternative way is

that merely those sensors noting a critical load change start to

propagate their signals to the exterior CPU. The propagated signals

are then fed into a regularization scheme that is able to stably

invert signals into loads.

As discussed above, Tikhonov regularization is a feasible regu-

larization scheme, computing an approximation to the true load

as solution to the linear system

ðT



T þ

Þl ¼ T



s þ

; ð3Þ

where T

⁄

denotes the transpose of T. The solution to this system is

hence computed rapidly with low cost if one is able to pre-compute

a singular value decomposition of the matrix T. The disadvantage of

this inversion scheme is that reconstructions of discontinuous

loads, in particular with small support, are smoothed out which

makes the precise location of the support of a load difﬁcult. Several

iterative inversion techniques such as the steepest descent method

or the conjugate gradient method applied to T

⁄

Tl = T

⁄

g avoid this

disadvantage. Further, they merely require the ability to compute

matrix–vector products and a (cheap stopping) rule to stabilize

the inversion. The class of iterative inversion methods also includes

the so-called Landweber iteration and its variant, the so-called iter-

ative soft shrinkage. The disadvantage of the latter two techniques

is their slow convergence, and the huge number of iterations are

necessary to compute accurate inversions [9,19].

Combining Self-organizing Multi-Agent Systems (SoMAS) and

event-based sensor data distribution with inverse numerical meth-

ods into a hybrid data processing approach has several advantages:

First, the (possibly distinct) critical level for an individual sensor

signal can be pre-computed for each sensor position individually.

Second, depending on the a priori knowledge on the expected loads

on the structure, a suitable regularization technique can be chosen

as inversion method, promoting speciﬁc features of the expected

loads. Third, the sensor positions themselves might well be opti-

mized with respect to the last two points, aiming for sensor posi-

tions that maximize the detectability of critical loads and/or

sensor positions that maximize the quality of load reconstructions

from sensor signals.

This work introduces some novelties compared to other data

processing and agent platform approaches and previously pub-

lished work [16,18,17,20]:

 Complete multi-domain simulation of large-scale multi-agent

systems, sensor networks, and numerical computation with a

uniﬁed database centric simulation environment.

 Sensor signal preprocessing at run-time inside the sensor net-

work by using multi-agent systems. Event-based sensor data

distribution and pre-computation with agents reduces commu-

nication and overall network activity resulting in reduced

energy consumption.

 Agent mobility crossing different execution platforms in mesh-

like networks and agent interaction by using tuple-space data-

bases and global signal propagation aid solving data distribu-

tion and synchronization issues in the design of distributed

sensor networks connected to generic computer networks and

the Internet.

 Enhanced inverse numeric improving stability and accuracy is

used to compute the load for a structure from noisy and incom-

plete sensor data.

 An advanced on- and off-line processing with off-line inverse

numerical computation of mechanical loads form on-line pre-

processed sensor data allows the determination of the system

14 S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

response. FEM simulation is used to 1. Retrieve the inverse

numeric for real-world sensing system; and 2. For the creation

of synthetic sensor data of the technical structure in simulation.

 Rigorous analysis and evaluation of the load computation for a

structure with temporal and spatial disturbed or incomplete

sensor input data. Temporal disturbance is caused by data dis-

tribution latencies, and spatial disturbance is caused by techni-

cal failures in the sensor network (e.g., communication failures).

The next sections summarize the activity-based agent process-

ing model, available mobility and interaction, and the used agent

processing platform architecture related to the programming

model. A summarized description of the sensor signal processing

algorithms and a rigorous description of the proposed inverse

numerical methods for load computations are following, which

are proﬁled and validated with an extensive simulation framework.

2. Agent behaviour model

The agent behaviour is composed and modelled with an activity

graph, with activities representing the control state of the agent rea-

soning engine, and conditional transitions connecting and enabling

activities, shown in Fig. 2 (detailed description in [16,20]). Activities

provide a procedural agent processing by sequential execution of

imperative data processing and control statements.

The activity-graph based agent model is attractive due to the

proximity to the ﬁnite-state machine model, which simpliﬁes the

hardware implementation, but still enabling efﬁcient software

implementations.

An activity is activated by a transition which can depend on a

predicate as a result of the evaluation of (private) agent data

related to a part of the agents belief in terms of Belief-

Desire-Intention (BDI) architecture. An agent belongs to a speciﬁc

parameterizable agent class AC, specifying the behaviour, local

agent data (only visible for the agent itself), types, signals, activi-

ties, signal handlers, and transitions.

The class AC can be composed of sub-classes, which can be inde-

pendently selected. Plans are related to AAPL activities and transi-

tions close to conditional triggering of plans.

This reactive behaviour can be summarized to the following

operational semantic:

 Procedural data processing takes place in activities computing

and changing private and global data.

 Transitions between activities represent the progress and the

external visible change of the control state of an agent. Transi-

tions can be conditional depending on the evaluation of agent

data.

 Body variables of an agent are private data only visible to the

speciﬁc agent. The data content of body variables are mobile

and can be inherited by forked child agents.

 Each agent owns a public set of agent parameters initialized on

agent creation.

 Global data is exchanged by using a tuple database and syn-

chronized and atomic read, test, remove, and write operations.

 Agents can migrate between different physical and spatially dis-

tinguished execution platforms by preserving and transferring

the control and data state of the agent.

 The agent behaviour can be either implemented directly by the

processing platform (application speciﬁc and static platform

class) or can be implemented with program code executed by

a generic agent processing platform (dynamic platform class).

 Agents can be created at run-time, regardless of the platform

class. Agents can inherit the control and data state from parent

agents (forking behaviour).

 Agents can communicate and synchronize peer-to-peer by using

signals, which can be delivered to remote execution nodes, too.

Fig. 2. Agent behaviour programming level with activities and transitions (AAPL, left); agent class model and activity-transition graphs (top); agent instantiation, processing,

and agent interaction on the network node level (right) [17].

S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

A short notation of AAPL used to specify the agent behaviour in

this work is presented in Appendix A.

3. Agent processing platform

There are two different agent processing platforms capable of

processing of the mobile agents used in this work: a non-

programmable and a programmable platform architecture. The

non-programmable platform implements the agent behaviour for

different agent classes directly, whereas the programmable plat-

form provides generic agent processing of program code supplied

externally which implements the agent behaviour of a particular

agent class. Both platforms can be implemented entirely on hard-

ware (SoC), or software, or simulation model level. All implemen-

tations of each platform class can be deployed and connected in

a heterogeneous network environment, shown in Fig. 3. They are

compatible on operational and interface level. That means agents

can migrate between different platform implementations and dif-

ferent host environments. The simulation of MAS can be based

on a pure behavioural model (BSIM) by simulating the agents itself

or based on an architectural model by simulating the agent pro-

cessing platform (PSIM) using agents.

Table 1 compares the characteristics and the advantages/disad-

vantages of both platform architectures. Fig. 3 shows the modelling

and synthesis of agent platforms from a common model and pro-

gramming sources.

4. Sensing with multi-agent systems

Large scale sensor networks with hundreds and thousands of

sensor nodes require smart data processing concepts far beyond

the traditional centralized approaches. Multi-Agent systems can

be used to implement smart and optimized sensor data processing

in these distributed sensor networks.

In this work, three different data processing and distribution

approaches are used and implemented with agents, leading to a sig-

niﬁcant decrease of network processing and communication activity

and a signiﬁcant increase of reliability and the Quality-of-Service:

1. An event-based sensor distribution behaviour is used to deliver

sensor information from source sensor to computation nodes.

2. Adaptive path ﬁnding (routing) supports agent migration in

unreliable networks with missing links or nodes by using a

hybrid approach of random and attractive walk behaviour.

3. Self-organizing agent systems with exploration, distribution,

replication, and interval voting behaviours based on feature

marking are used to identify a region of interest (ROI, a collec-

tion of stimulated sensors) and to distinguish sensor failures

(noise) from correlated sensor activity within this ROI.

It is assumed that sensor nodes arranged in a two-dimensional

grid network (as shown in Fig. 4) providing spatially resolved and

distributed sensing information of the surrounding technical struc-

ture, for example, a metal plate. Each sensor node shall sense

mechanical properties of the technical structure nearby the node

location, for example, by using strain gauge sensors. Usually a sin-

gle sensor cannot provide any meaningful information of the

mechanical structures. A connected area of sensors (complete sen-

sor matrix or a part of it) is required to calculate the response of the

material due to applied forces. The computation of the material

response requires high computational power of the processing

unit, which cannot offered by down-scaled single micro-chip plat-

forms. For these reasons, sensor nodes use mobile agents to deliver

their sensor data to dedicated computational nodes located at the

edges of the sensor network, shown in Fig. 4, discussed in detail in

the following sub-sections. The computational nodes arranged at

the outside of the network are further divided in pre-

computation and the ﬁnal computation nodes (the four nodes

located at the corners of the network). The pre-computational

nodes can be embedded PCs or single micro-chips, and the compu-

tational nodes can be workstations or servers physically displaced

from the material-embedded sensor network. Only the inner sen-

sor nodes are micro-chip platforms embedded in the technical

structure material, for example, using thinned silicon technologies.

4.1. Event-based sensor data processing with agents

The computation of the system response information requires

basically the complete sensor signal matrix S. In traditional sensor

signal processing networks this sensor matrix is updated in regular

time intervals, resulting in a high network communication and

sensor node activities. In this approach presented here the ele-

ments of the sensor matrix are only updated if a signiﬁcant change

of speciﬁc sensors occurred. Only the four corner computational

nodes store the complete sensor matrix and perform the inverse

numerical computations, explained in Section 6.

The sensor processing uses both stationary (non-mobile) and

mobile agents carrying data, illustrated in Fig. 5 on the left side.

Fig. 3. Different agent processing platform architectures and implementations, but a common agent behaviour model and programming sources. (PCSP: Pipelined

Communicating Sequential Processes, PAVM: Pipelined Agent Forth Virtual Machine, ATG: Activity-Transition Graph, AAPL: Agent Programming Language, HWS: Hardware

Synthesis, SWS: Software Synthesis, PSIM: Platform Simulation, BSIM: Behavioural Agent Simulation).

16 S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

There are two different stationary (non-mobile) agents operating

on each sensor node: the sampling agent which collects sensor

data, and the sensing agent, which pre-processes and interprets

the acquired sensor data. If the sensing agent detects a relevant

change in the sensor data, it sent out four mobile event agents,

each in another direction. The event agent carries the sensor data

and delivers it to the pre-computation nodes at the boundary of

the sensor network. The agent behaviour is speciﬁed in Algorithm

2 in Appendix A, and an overview of the agent behaviour and the

ATG can be found in Fig. 5 on the right side.

An event agent has a pre-deﬁned path in the direction dir which

is followed by the move activity as long as there is connectivity to

the next neighbour node in this direction. Normally the agent trav-

els to the outside of the network on the given direction by applying

the route_normal routing strategy successfully. If it is not possi-

ble to migrate in the pre-deﬁned direction, an alternative path is

chosen by using the route_opposite routing strategy, which

chooses a path away from the original destination to bypass not

connected nodes and missing communication links. Using the

route_relax routing strategy the agent is directed again to the

original planned path. Making routing decisions and migration

are performed in the move activity of the agent, followed by the

check activity which collects sensor data from the current node

and checks the destination node goal, and if reached delivering

the sensor values in the deliver activity.

Each pre-computation node stores a row or a columns of the

sensor matrix S. If their data changes, the pre-computation nodes

will sent out two mobile distribution agents in opposite directions,

delivering a row or column of S to the ﬁnal computation nodes,

located at the edges of the sensor network.

4.2. Self-organizing MAS and feature recognition

The event-based sensor data distribution relies on well operating

sensors and trustful sensor values. Faulty or noisy sensors can

disturb the further data processing algorithms (inverse numeric)

signiﬁcantly and should not delivered to the computational nodes.

Usually sensor values are correlated within a spatially bounded

region. The goal of the following MAS is to ﬁnd the outline of

extended correlated regions of increased sensor stimuli which can

be distinguished from the neighbourhood. For example, strain

gauge sensors which deliver information about mechanical distor-

tion of a material resulting from externally applied load forces. A

single stimulated sensor cannot be a result from a mechanical load.

To ﬁnd such a correlated stimulated sensor region, a distributed

directed diffusion behaviour and self-organization (see Fig. 6) are

used, derived from the image feature extraction approach

(proposed by [15]). A single sporadic sensor activity not correlated

with the surrounding neighbourhood should be distinguished from

an extended correlated region by marking nodes nearby the bound-

ary of the region, which is the feature to be detected (edge detector).

Sensor nodes detecting a signiﬁcant change of their sensor val-

ues send out explorer agents which perform the feature detection

and marking. Sensors nodes sending out the feature recognition

agents but get no markings can decrease a trust probability for

their sensor values for further assessment and activity planning.

The feature detection is performed by the mobile exploration

agent, which supports three main different behaviours: explo-

ration, diffusion, and reproduction. The diffusion behaviour is used

to move into a region, mainly limited by the lifetime of the agent,

and to detect the feature, here the region with increased

mechanical distortion (more precisely the edge of such an area).

The detection of the feature enables the reproduction behaviour,

which induces the agent to stay at the current node, setting a

feature marking and sending out more exploration agents in the

neighbourhood. The local stimuli H(i

, j) for an exploration agent

to mark a speciﬁc node with the coordinate (i, j) is given by Eq. (4).

Hði; jÞ¼

u¼R

v ¼R

f sði þ u; j þ

Þsði; jÞ

6 dg

s : SensorSignalStrength

R : SquareRegionaroundði; jÞ

ð4Þ

Table 1

Comparison of both agent processing platform architectures and their implementations (PCSP: Pipelined Communicating Sequential Processes, PAVM: Pipelined Agent Forth

Virtual Machine).

Programmable PAVM Non-programmable PCSP

Approach  Program code based approach

 Data is embedded in code

 Zero-operand instruction format

 Stack memory centric data processing model

 Platform is generic

 Code embeds instructions, conﬁguration (control state), and data

 Migration: code transfer

 Application-speciﬁc approach

 Platform is application-speciﬁc

 Activities of the ATG are mapped to processes

 Token-based agent processing

 ATG reconﬁguration by switching token channel paths

 Migration: data and control state transfer (including conﬁguration

table)

Hardware  Optimized Multi Stack Machine

 Each stack processor is attached to a local code segment and two stacks

shared by all agents. There is no data segment!

 Single SoC Design

 Multiprocessor architecture with distributed and global shared code

memory

 Multi-FSM RTL hardware architecture

 Automatic Token-based agent process scheduling and processing

 Code morphing capability to modify agent behaviour and program code

(ATG modiﬁcation)

 Data- and code word sizes can be parameterized

 Pipelined Communicating Processes Architecture composition imple-

menting ATG and token-based agent processing

 Single SoC Design

 Optimized resource sharing – only one PCSP for each agent class

implementation required

 Activity process replication for enhanced parallel agent processing

 For each agent class there is one PCSP with attached data memory

(agent data)

 Single SoC Design

 LUT conﬁguration matrix approach for ATG reconﬁguration

Software  Multi-Threading or Multi-Process software architecture

 Inter-process communication: queues

 Software model independent from programming language

 VM sources for various programming languages: C, ML, Javascript, ...

 Can be embedded in existing software

 Multi-Threading software architecture

 Optimization: Functional composition and implementation of ATG

behaviour instead PCSP

 Interprocess-communication: queues

 Software model independent from programming language

 Source code for various programming languages: C

, ML, ...

 Can be embedded in existing software

Simulation  Agent-based Platform simulation

 Generic simulation model – can execute machine code directly

 Processor components and managers are simulated with agents

 Agent-based platform simulation

 Application-speciﬁc simulation model

 ATG activity processes are simulated with agents

S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

The calculation of H at the current location (i,j) of the agent

requires the sensor values within the square area (the region of

interest ROI) R around this location. If a sensor value s(i + u, j +

)

with i,j 2 {R, ..., R} is similar to the value s at the current position

(diff. is smaller than the parameter d), H is incremented by one.

If the H value is within a parameterized interval @



¼½



;



, the

exploration agent has detected the feature and will stay at the cur-

rent node to reproduce new exploration agents sent to the

neighbourhood.

If H is outside this interval, the agent will migrate to a neigh-

bour different node and restarts exploration (diffusion).

The agent behaviour is speciﬁed in Algorithm 4 in Appendix A,

and an overview of the agent behaviour and the ATG can be found

in Fig. 6 on the right side. An initial root explorer agent is instanti-

ated by the node agent with a direction argument ORIGIN. This

explorer agent will read the local sensor values from the tuple

database. In this work there are two strain-gauge sensors con-

nected to each node (sensor data s

). The root agent will send

out explorer child agents to all connected neighbour nodes (in

activity percept). These child agents compute a partial term of

the H calculation by sending out additional explorer child agents

(in activity percept_neighbour) until the boundary of the ROI

is reached. To avoid multiple visiting of a node by different child

agents of the same exploration group, a marking is set on each vis-

ited node (a tuple with a limited lifetime removed by a garbage

collector). If there is already a marking, an explorer child agent will

Fig. 4. The logical view of a sensor network with a two-dimensional mesh-grid topology (left) and examples of the population with different mobile and immobile agents

(right): event deliver, node, and computational processing agents. The sensor network can contain missing or broken links between neighbour nodes.

Fig. 5. Up: Sensor data distribution with event (green) and pre-processing agents (blue): A sensor node which detected a signiﬁcant change of the sensor values creates event

agents which are sent in all four directions to the network boundary (pre-computation nodes). Down: ATG behaviour model of the event agent. (For interpretation of the

references to colour in this ﬁgure legend, the reader is referred to the web version of this article.)

18 S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

go back immediately to its parent agent node location and delivers

the computed partial term h of H(i, j). An explorer or explorer child

agent which sent out additional child agents will wait (sleep) until

all child agents had returned their computation results or a time-

out occurs. Data is exchanged between child and parent agents

by using the tuple space database and synchronization (wake-up)

is handled by using signals.

4.3. SoMAS simulation and evaluation

To evaluate the capabilities of the feature marking SoMAS intro-

duced in the previous section, the simulation environment

described in Section 5 is used to carry out simulations with syn-

thetic and real-world sensor data (though obtained from FEM sim-

ulation, the data sets are rather realistic including noise).

Fig. 7 shows simulation results of a connectivity-incomplete

8  8 sensor network with a rectangular sensor stimuli region hav-

ing a sharp boundary. The network had a communication connec-

tivity of CN = 70% (30% communication links are not operating).

The creation of a root explorer agent involves three parameters:

1. The radius R and the size N

of the square ROI (R = 1 means 9

sensor values, R = 2 means 27 sensor values contributing to the H

calculation); 2. The lifetime L in node distance units; 3. The deci-

sion interval @



¼½



;



. In all simulations a setting of @



¼½3; 6

was used.

With a parameter set {R =1, L = 1} the sharp boundary of the

sensor stimuli is detected reliable for a cluster size of 8 and 15

sensors shown in the plots (a)–(c) and (d). Surprisingly the

CL = 15 cluster is not recognized with a parameter set {R =2,

L = 1}(e), in contrast to the smaller cluster with CL = 8. Increasing

the lifetime usually not increases the quality of feature recognition.

In the case of the larger cluster size CL = 15 (f) the fuzziness of the

boundary increases if the lifetime is increased.

In Fig. 8 the feature detection is applied to data sets retrieved

from load and strain simulations of a steel plate using FEM

simulation described in Section 6, which leads to a more

continuously sensor stimuli distribution without having a sharp

boundary.

The ﬁrst data set related with a speciﬁc load case has a signiﬁ-

cant increase of sensor values at the east side of the network. The

boundary feature detection SoMAS reliable ﬁnds the west side of

the region regardless of the different parameter settings, shown

in the plots (a)–(c).

The second data set and load case with a smoother sensor value

distribution and a lower sensor value gradient shows a totally dif-

ferent result. In plot (d) with the parameter set {R =1,L = 1} the ﬂat

region is marked instead the sensor value gradient on the east side.

This changes again with the parameter sets {R =2,L = 1} and {R =2,

L = 2} shown in the plots (e)–(f), now detecting the gradient

boundary correctly.

The third data set and load case with a nearly constant gradient

of the sensor values shows again different results for R = 1 and

R = 2 settings. The R = 2 setting always marks the entire network,

which is primarily a result of the decision interval setting @



. The

R = 1 setting ﬁnds again the west side of the sensor stimuli related

with the lowest sensor values.

To summarize the edge detection capabilities of the SoMAS are

mostly suitable to recognize a stimulated sensor value region and

can be used for triggering of the event-based sensor data distribu-

tion and processing described in Section 4.1. The quality of the fea-

ture detection depends on the parameter set {R, @



}, which can be

adjusted at run-time by using reinforcement learning performed

by the agents based on a quality feedback from the computational

nodes.

5. Simulation

In this work a multi-domain simulation technique is used to

study the effects of technical failures, sensor noise, and computa-

tional dependencies on the computation of structure loads from

disturbed and incomplete sensor data, both in temporal and spatial

Fig. 6. Up: Feature marking of stimulated sensor clusters by using explorer agents investigating the neighbourhood of their current position using forked child agents. On

successful feature detection explorer agents are replicated, otherwise they diffuse to the neighbourhood to ﬁnd features. Down: ATG behaviour model of the explorer agent

and the explorer child agent class branching from the percept activity.

S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

dimensions. Simulation domains are related here to different levels

of the sensing environment, basically the communication network,

the agent processing, the sensing process, computational mechan-

ics, and FEM simulation used for the computation of T and deliver-

ing synthetic sensor data.

The simulation of the data processing and the physical simula-

tion using FEM and numerical computation approaches are com-

bined in one unique database centric and agent-based simulation

environment.

The outcome of numerical computations depends on the senso-

rial input data, which can be disturbed by the physical sensing pro-

cess itself and by technical features and failures, for example,

caused by communication (temporal latency, lost of data). Com-

monly Monte Carlo experiments are used in simulation experi-

ments for computing some general time-dependent system

function F(s, E, t) of an initial synthetic sensor data input s ={s

, ..., s

} by adding noise d (e.g., common distributed) to the orig-

inal input data, i.e., s’ ={s

, s

+ d

, ..., s

+ d

}, creating multiple

simulation experiments with sets s’

, s’

, ... of different artiﬁcially

pertubated input data with variances of the original input data set

and the outcome of F:

l : Fðs; E; tÞ!

Monte-Carlo

Technical-Failure

: Fðs þ d

; E

Þ; l

: Fðs þ d

; E

Þ; ...

E # fCommunication; Processing; Sensingg

ð5Þ

The outcome of the sensor processing (the desired information)

is the mechanical load l that depends additionally on a particular

environmental setting E, i.e., network connectivity, communication

error rates, data distribution and processing algorithms, and the

processing platform lifeliness, disturbed by probalistic processes,

too. I.e., the system function F includes the inverse computation,

but additionally technical failures arising in the sensor network,

e.g., communication failures between nodes, missing or faulty sen-

sor data, temporal effects (collected sensor data is updated with a

latency creating incomplete input data sets at a speciﬁc time), and

effects of distributed computing algorithms on the sensor data

(rounding errors, missing data, old data, ...) are considered in the

simulation resulting in a more realistic simulation of a technical

sensing system. This is covered by different experiments with dif-

ferent environmental settings E

that parameterizes a particular

simulation run. In the best case, the output of the computation

function F should asymptotical converge to the expected informa-

tion output, in the worst case F delivers completely different

results, analysed in the next sections.

The complete simulation framework is shown in Fig. 9. The cen-

tral part of the simulation framework is a SQL database server

enabling the data exchange and synchronization between different

programs, mainly the Multi-Agent Simulator SeSAm [21] and the

MATLAB program used for the inverse numerical computation. A

Remote Procedure Call (RPC) interface provides synchronization

between the programs of the framework. All programs are commu-

nicating with the database server by using named ﬁle system

pipes. This approach has the advantage to require only a native ﬁle

system interface to connect a heterogeneous program environ-

ment, supported basically by all programs. No program modiﬁca-

tion and no special database or inter-process communication

modules are required.

The behavioural simulation of the agents based on the AAPL

model using the SeSAm agent behaviour model [21] – which is only

a partial sub-set of the AAPL model – requires the application of

some transformation rules:

 Each AAPL agent class AC

is implemented with a SeSAm agent

class SC

 Each AAPL sub-class AC

i,j

is implemented with a SeSAm agent

class SC

. At run-time different agents exist derived from each

sub-class.

(a) CL=8 R=1 L=1 (b) CL=8 R=2 L=1 (c) CL=8 R=2 L=2

(d) CL=15 R=1 L=1 (e) CL=15 R=2 L=2 (f) CL=15 R=1 L=2

Fig. 7. SoMAS Feature Marking (red circles) with a localized rectangular sensor stimuli region having a sharp boundary (yellow dotted line). CL: Cluster size, R: Exploration

radius, L: Explorer lifetime, Network connectivity CN = 70%. (For interpretation of the references to colour in this ﬁgure legend, the reader is referred to the web version of this

article.)

20 S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

 Functions and procedures of an AAPL agent class AC

must be

implemented with SeSAm feature class FCi.

 AAPL signal handlers must be implemented with a separated

SeSAm agent class SC

i,sig

. At simulation time each AAPL agent

having signal handlers is associated with a shadow agent of

the class SC

i,sig

 Signals n are passed by synchronized queues.

 AAPL activities a

which contain blocking statements (tuple

space access and waiting for time-outs) require a split into a

set of computational and blocking SeSAm activities a

) {a’

i,1

a’

i,2

, a’

i,3

...}

 Migration of agents is only virtual by changing the position of a

SeSAm agent and connecting the agent to the new node agent

infrastructure, i.e., changing the data scope. Migration of agents

requires the migration of the shadow agents (signal handler

agents), too.

The sensor network simulation and the SoMAS- and event-

based sensor data distribution is used for the proof and the proﬁl-

ing of the inverse numerical methods, discussed in Section 6.

Fig. 10 shows the temporal resolved agent population (in simula-

tion time steps) for the experiments performed for Section 6 and

the feature recognition marking resulting from the SoMAS feature

recognition (explorer and explorer child agents), triggering the

sensor data distribution by the event and distributor agents.

6. Inverse methods for structural load monitoring

Inversion algorithms for the computation of loads from mea-

sured surface strains are based on a mechanical model of the con-

sidered structure and require stabilization due to intrinsic ill-

posedness such that they typically rely on regularization methods

[9,19]. If such a model is discretized and if a loading on the struc-

ture is given, numerically solving the discretized system allows to

approximate the response of the structure to the load. Thus, a

mechanical model ﬁrst allows to simulate signals measured by

sensors on or in the structure that are due to loads. This yields a

mapping T such that forgiven load l, the sensor signals equal Tl.

The mechanical model allows in a second step to deduce loads

from sensor signals s by solving the equation Tl = s for the load l.

Our goal is to demonstrate that the latter task can be tackled by

an embedded sensor network relying on inverse methods based on

models from linear elasticity.

Obviously, numerical simulations always involve several

errors, most obviously the discretization error and the modelling

error due to the choice of the model, but also errors due to

imprecise knowledge of the plate’s geometry or the sensor posi-

tions. Finally, any experimentally measured sensor signal is

affected by measurement errors, too, due to limited digital pre-

cision leading to round-off errors or incorrect data transmission.

Numerical precision limited to few digits is a crucial restriction

(a) LC=1 R=1 L=1 (b) LC=1 R=2 L=1 (c) LC=8 R=2 L=2

(d) LC=2 R=1 L=1 (e) LC=2 R=2 L=1 (f) LC=2 R=2 L=2

(g) LC=3 R=1 L=1 (h) LC=3 R=2 L=1 (i) LC=3 R=2 L=2

Fig. 8. SoMAS Feature Marking (red circles) with a large area sensor stimuli region having no clearly deﬁned boundary (continuos change). LC: Load case, R: Exploration

radius, L: Explorer lifetime, Network connectivity CN = 70%. (For interpretation of the references to colour in this ﬁgure legend, the reader is referred to the web version of this

article.)

S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

of accuracy in particular for embedded and autonomous sensor

networks.

6.1. Computational setting and pre-computations

We consider load monitoring assuming a sensor network that is

embedded in a thin plate of size 0.5 m  0.5 m  0.02 m consisting

of construction steel. This plate is ﬁxed at one of its four vertical

sides. We limit ourselves to the case of loads that are so small that

the equations of linear elasticity provide an accurate physical

model, i.e., stresses caused by such loads are below the yield

strength.

We moreover assume in our numerical experiments that the

loaded structure is isotropic and homogeneous, such that the

material behaviour can be described by its elastic modulus E and

its Poisson ration

. Moreover, any (spartially variable) load on

the structure is assumed act constantly in time during a certain

time interval, such that the deformation ﬁeld u =(u

, u

)

static during this time interval and can be described by the equa-

tions of static linear elasticity,

ðk þ

divu þ

u ¼ 0inX; ð6Þ

where k and

are Lame parameters deﬁned by

k ¼

mE=½ð1 þ mÞð1  2mÞ and

¼ E=ð2 þ 2mÞ. The deformation ﬁeld

vanishes at the boundary where the plate is ﬁxed and satisﬁes trac-

tion and free boundary conditions on the top and remaining sides,

respectively. The (linearized) strain tensor then equals

ðuÞ¼1=2ðru þðruÞ

Þ, which allows to compute surface strains

once the deformation ﬁeld has been approximated numerically.

The structure’s response to a load hence is elastic deformation.

Note that loads are always placed on the upper horizontal surface

of the plate, such that the associated forces act in normal direction

to the surface.

We assume that the sensors embedded in the material measure

surface strain on the lower horizontal surface of the plate at

M = M

sensor positions in a grid of sensors of size M

 M

More precisely, these sensors measure surface strain on the lower

surface of the plate at the sensor position, both in the x- and in the

y-direction.

Using a ﬁnite element discretization we simulate a ﬁnite num-

ber of loads caused by cylindrical weights with (cross-section)

radius of 0.0125 m placed at N = N

equidistant grid points

i;j

ð0:25mþði 1Þ0:5mÞ=N

ð0:25mþðj 1Þ0:5mÞ=N

0:02 m

; i ¼ 1;...;N

; j ¼ 1;...;N

;

ð7Þ

that form a grid of N

 N

points on the upper side of the plate.

Simulating the deformation ﬁeld caused by these weights allows

to compute the resulting surface strain at sensor points on the

lower side of the plate. The corresponding equidistant sensor posi-

tions are

i;j

ð0:25mþði1Þ0:5mÞ=M

ð0:25mþðj 1Þ0:5mÞ=M

0:00m

; i ¼ 1;...;M

; j ¼ 1;...;M

ð8Þ

Fig. 9. Simulation Framework with a database approach: Multi-Agent Simulator SeSAm, MATLAB, and other utility programs are exchanging data and synchronizing using a

SQL database server, which provides a RPC interface for synchronization, too.

22 S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

This way of simulating the reaction of the plate under loading is

motivated by the experimental set up presented in [1].

We emphasize that our ﬁnite element discretization does nei-

ther model the embedded sensors nor any communication infras-

tructures in between these sensors. Thus, the resulting simulated

sensor value are merely accurate for sensors of small size that do

not interact strongly with the plate; arguably, this inaccuracy is

negligible to test the ability of a sensor network in connection with

a mobile agent platform to monitor loads.

Note that the grid of weight points w

i,j

and of sensor points m

i,j

yield a natural surface quadrangulation of the upper and lower sur-

face of the plate, respectively, that we will use later on to image

applied and reconstructed loads.

Due to the chosen model of linear elasticity, the relation

between applied load and simulated strain is linear and hence

gives rise to a linear function mapping loads to surface strain.

Moreover, due to discretization, this mapping is ﬁnite dimensional

and can hence be represented by a real-valued matrix T with 2M

rows and N columns. (Since we assume that sensors measure sur-

face strain in x- and y-direction, the dimension of the image space

equals 2M, i.e., twice the number of sensors.)

This so-called load–strain matrix T maps vectors modelling dis-

cretized loads to surface strains at the sensor positions. Since we

will later on monitor loads by stably inverting this matrix, this pro-

cedure of assembling the load–strain matrix obviously introduces a

further discretization error for any load that cannot be represented

as a linear combination of the above-mentioned cylindrical

weights.

If l 2 R

is a vector modeling loads applied to the upper surface,

the resulting strain s 2 R

hence equals the matrix–vector

product

s ¼ Tl: ð9Þ

Thus, in contrast to the preceding sections where loads or stains

were considered as matrices l or s

x,y

, we start from now on to

consider them as vectors to be able to use the latter matrix

operation in between them. Both points of view are of course

equivalent if we agree on the following one-to-one correspon-

dence: The entry l(i, j) of a load matrix l corresponding to the

weight point w

i,j

is the (N

 1)i + jth entry of the vector l. Further,

the entry s

(i, j) of a strain matrix s

is the (M

 1)i + jth entry of

the vector s and the entry s

(i, j)ofs

is the M +(M

 1)i + jth entry

of the vector s.

To compute the load–strain matrix T we used the C++-based

and open-source ﬁnite-element software FreeFem++[23]. In detail,

we set up a uniform and regular tetrahedral volume mesh of the

plate with a mesh width of 0.11 mm and used globally continuous

and piece wise quadratic basis functions (P2 elements) for each of

the three components of the deformation ﬁeld. The dimension of

the resulting linear system for each of the M loads is about 11.5

million. Note that the system matrix needs to be set up merely

once for all forward computations as the columns of T correspond

to different loadings due to the N weights at the points w

i,j

from Eq.

(7), i.e., to different right-hand sides of the ﬁnite-element system.

Using a parallel solver on a workstation with eight cores and

32 GB RAM it took about two days to do all simulations.

Note that the standard theory of ﬁnite element methods implies

that the approximate solutions converge to the exact in the energy

norm as the mesh width tends to zero. When the approximation

error is measured in the quadratic mean (i.e., in the L

-norm), then

a convergence rate in between one and two is achieved, and if the

exact solution is sufﬁciently smooth (which is not always the case

in our examples), then the convergence rate of the deformation

ﬁeld is higher than quadratic.

However, we are ultimately interested in the surface strains,

that is, in derivatives of the deformation ﬁeld, which converge in

L1 L2 L3 L4 L5

Fig. 10. Agent population of the SoMAS- and event-based sensor data distribution in the sensor network used in the following Section 6.3 (L

: i-th load case data set).

S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

the quadratic mean with a rate that is one order smaller than the

one of the deformation ﬁeld itself.

As the solution of the N linear systems to compute the load–

strain matrix T is part of the pre-computations and does inﬂuences

the inversion technique merely by the accuracy of the simulated

strains, we did not opt to speed up this process by, e.g., resorting

to simpler two-dimensional models for the deformation ﬁeld or

the strain tensor (as, e.g., KirchhoffLove plate theory) but simply

tackled the full three-dimensional problem directly and ensured

that the results are sufﬁciently accurate by taking a small mesh

width. (The pre-computations took about two days on a modern

workstation, using parallel computations.) Note further that we

compared the computed surface strains against corresponding

results for smaller mesh widths and obtained in all experiments

presented below a relative error in the strain data of less than

one percent.

The plot of the entries of such a load–strain-matrix on the right

of Fig. 11 for N = 400 weights and M = 64 sensors shows in each

column the absolute values of 128 surface strains computed from

one ﬁnite-element computation; strains in x and y-direction are

contained in the upper and lower half of the plotted matrix, respec-

tively. As the plate is ﬁxed at one side parallel to the x-axis, strain

in x-directions is generally smaller (due to darker colours in the

plot) than strain in y-direction. The singular values of that load–

strain matrix are plotted on the left of Fig. 11 and indicate a rela-

tive noise level of about 0.002.

After computing the load–strain matrix T the inversion task

required for load monitoring is to stably compute load vectors l

that satisfy the equation Tl = s

for given inaccurate strain mea-

surements s

. This task is intrinsically difﬁcult since the matrix T

is ill-conditioned:

As Fig. 11 shows, the singular values of T for M

= M

= 8 and

= N

= 20 decrease rapidly, which implies that small errors in

the data make an accurate load reconstruction impossible. Already

a relative error in the data of 1% implies that in general merely less

than twenty singular values will remain accurate; for relative noise

levels of more than 10%, less than ﬁve singular values remain

accurate.

Since the number of columns of T equals the number of weight

positions N that is in general different from the number of strain

measurements, the load–strain matrix T is in general not square

and cannot be inverted – even if the matrix was square, one should

refrain from inverting it due to ill-conditioning.

A possible remedy is to consider the following least-squares

problem for l 2 R



Tl ¼ T



; ð10Þ

that is derived from the linear system Tl = s

. (As above, T

⁄

is the

transpose matrix of T).

One can indeed show that a vector l solving Eq. (10) minimizes

the functional l!kTl-s

, where we recall that kk

denotes the

2-norm (or the Euclidean norm), see Eq. (2). The linear system in

Eq. (10) features a quadratic matrix that is however even more

ill-conditioned than before and, for this reason, should not be

inverted directly, i.e., the system is under determined. Instead,

we advertise to stabilize the computation of an approximate load

vector l using so-called inverse (aka. regularization or inversion)

methods. We refer to [9,19] for an introduction to such methods.

6.2. Inverse methods

In this section, we will introduce two inversion methods that

we afterwards compare in view of their applicability in the frame-

work of load monitoring using multi-agent systems in an embed-

ded sensor network as introduced in Section 4. As discussed in

the ﬁrst part of this paper, propagating sensor measurements by

a Self-organizing Multi-Agent system to the four computation

nodes (see Fig. 4) introduces signiﬁcant errors in the measured

data arriving at the computation node due to different arrival times

or broken network connections.

Thus, the strain vector s

available for computations is in

general incomplete and contains a very high level of noise. This fact

causes severe difﬁculties to any inverse method; nevertheless,

even for such a difﬁcult setting with incomplete data and a

drastically under-determined inversion problem, we will see later

on that such methods are still able to provide some meaningful

information.

Note that the proceedings paper [18] contains several numeri-

cal example of loads reconstructed from sensor network data

where the computation node is aware of all strain measurements

without data corruption due to data propagation. In such an ideal-

ized setting, on can study the dependence of the reconstruction

quality on the number of sensors and the noise level in the data

after adding artiﬁcial noise to the simulated load–strain matrix T

and the simulated strain vectors s

. We refer to [18] for results

in this direction.

-4

-3

-2

-1

0 20 40 60 80 100 120 50 100 150 200 250 300 350 400

100

120

-3

-2

-1

Fig. 11. On the left: 128 non-zero singular values of load–strain matrix T 2 R

2MN

for M = 64 simulated sensors M

= M

=8 and N = 400 simulated weights (N

= N

= 20). On

the right: Absolute values of the entries of the load–strain matrix T. Since the steel plate is ﬁxed at one vertical side parallel to the x-axis, strain in x-direction is generally

smaller than strain in y-direction.

24 S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

As a ﬁrst technique, we consider the classical Tikhonov regular-

ization, where one stabilizes the inversion by requiring that l does

not minimize the 2-norm of the residual Tl-s

as in Eq. (10) but the

stabilized functional

l # kTl  s

klk

; ð11Þ

where kk

denotes the 2-norm (or Euclidean norm) of a vector. The

positive and small parameter

a should to be chosen in dependence

of the (expected) noise level in the measured data and the mod-

elling and computation error in the load–strain matrix T, see, e.g.,

[9,19].

It is not difﬁcult to compute that the minimizer of this quadratic

minimization problem solves the linear equation

ðT



T þ

Þl ¼ T



: ð12Þ

An issue of this inverse method that might sometimes be criti-

cal for its application in a sensor network is the inversion of a

dense linear system. However, in our context the matrix T must

anyway be pre-computed before the monitoring device is

launched, and hence one can directly pre-compute a singular value

decomposition of T, boiling down the solution of the linear system

to matrix multiplications:

Assume that (U, D, V) is a singular value decomposition of the

matrix T, such that the three matrices U, D, and V allow to

decompose T as

T ¼ UDV



: ð13Þ

Moreover, D is a diagonal matrix of size M  N, U and V are

orthogonal matrices of size M  M and N  N, respectively (i.e.,

⁄

U = I

and V

⁄

V = I

where I

is the unit matrix of size N  N).

We denote the diagonal elements of the matrix D by d

, i =1, ...,

min(N, M), and can hence write D = diag(d

). The d

are the

so-called singular values of T. Together with the orthogonality of

the matrices U and V, they allow to write to the Tikhonov

regularization l, solution to Eq. (12) as

l ¼ Vdiagðd

=ðd

ÞÞU



: ð14Þ

This inversion method hence multiplies the k-th strain value

(i.e., the k-th entry of s

) with the k-th column of the matrix

K = V diag(d

/(d

))U

⁄

and sums up all resulting column vectors

to obtain l. Note that the matrix–vector multiplication in Eq. (14)

is the only higher-order operation that has to be executed by the

computation node to compute l. Since the matrix K is of size

N  M, this requires M scalar products of the rows of K with s

and hence MN scalar multiplications and (N  1)M additions of

binary numbers with a ﬁxed number of digits.

A disadvantage of Tikhonov regularization is the smoothing

property of the scheme. For accurate data, i.e., at noise levels below

1%, loads with small spatial support or discontinuous loads typi-

cally will not be reconstructed with high accuracy but result in

smoothed and smeared-out computational results (see [18]). This

makes a precise location of the support of a load difﬁcult, in

particular when several loads act simultaneously on the structure.

However, the advantage of the Tikhonov regularization scheme

described in Eq. (14) is the stability of the technique for high noise

level and even incomplete data.

The second technique we consider for load monitoring is the

conjugate gradient (cg) iteration applied to the normal equation

⁄

Tl = T

⁄

s, an iterative technique where the k-th iterate l

mini-

mizes the discrepancy kTl  sk

in the so-called Krylov subspace

spanned by the vectors



s; ðT



TÞT



s; ðT



TÞ



s; ...; ðT



TÞ

k1



s: ð15Þ

Algorithm 1. The cg-algorithm applied to the linear system Tl = s

with starting vector l

(pseudo-notation)

Due to the ill-conditioning of the load–strain matrix T, the

cg-iteration applied to noisy data s

with relative noise level

d ¼ks

 s

exact

=ks

exact

k has to be stopped whenever the discrep-

ancy of the actual iterate reaches the noise level d of the sensor sig-

nals. Of course, for measured data, this noise level can only be

guessed, since it is composed of measurement errors, modelling

errors, discretization errors and data propagation errors. A standard

way how to proceed with measured data is to test the cg-iteration

for several measurements and several guesses of



when the true

load is known and to choose a guess for



in dependence of the qual-

ity of the results. For small noise level, i.e., for accurate data, the

experiments in [18] show that the conjugate gradient iteration usu-

ally outperforms Tikhonov regularization when reconstruction

loads with small support. The advantage of this method is its speed

as it is for instance known to compute iterates reaching a given dis-

crepancy earliest among all Krylov subspace methods. We will how-

ever note in the experiments presented in the next section that a

disadvantage of the cg-iteration is its sensitivity to lacking strain

data. Further, the method shows less stability than Tikhonov regu-

larization at high noise levels in the particular context of our setting.

Estimating the required work load for the cg-iteration is more

difﬁcult than the Tikhonov regularization, since the number of

times the while-loop in Algorithm 1 is repeated is variable. Gener-

ally, more accurate data implies a higher number of repetitions. In

numerical experiments with 20% relative synthetic white noise

added to the data, the loop was repeated up to nine times and about

7.5 times in average. In each loop, two matrix–vector multiplica-

tions must be computed, once with T and once with T

⁄

; these

require NM scalar multiplications each, plus (N  1)M and (M  1)

N additions for T and T

⁄

, respectively. This shows a disadvantage

of the cg-method for load monitoring in a sensor network: The

resulting vector l cannot be expressed via one matrix–vector product

and pre-computation strategies for this method are not obvious.

6.3. Numerical examples

The simulated experiments we present in the rest of this section

follow the setting we already outlined in Section 6.1: To pre-

compute the load–strain matrix T, we use a conforming ﬁnite ele-

ment method with P2 elements and simulate static loading of a

0.02 m thick quadratic building steel plate

with side lengths of

0.5 m that is ﬁxed at one of its four vertical sides. As material

parameters of the homogeneous and isotropic plate we ﬁx the elas-

tic modulus E of 210 kN/mm

and the Poisson’s ration

of 0.3. Fur-

ther, we use the equations of static linear elasticity as a model for

S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

the deformation ﬁeld u =(u

, u

)

(see Eq. (6)). As mentioned

above, the deformation ﬁeld u is governed by Eq. (6) and the strain

measurements are simulated as point values of the derivatives of

and u

at the sensor nodes.

When pre-computing the load–strain matrix the simulated

loads are cylindrical weights placed at N = 400 weight positions

from an equidistant rectangular grid (the grid points are deﬁned

in Eq. (7) for N

= N

= 20). The force on the upper surface of the

upper horizontal plate due to the loading hence vanishes outside

the circle covered by the weight; inside this circle the force points

in direction z and equals 1 N/cm

. As discussed in Section 6.1,

after computing the deformation ﬁeld, we compute the surface

strain in x and y direction at the sensor points given in Eq. (8)

where M = 64 (since M

= M

= 8). By computing the deformation

ﬁeld and the extracted surface strain for a sequence of reﬁned

meshes, we checked that the relative error of the strain data used

in the examples below is below one percent.

Apart from the cylindrical loads to compute the load–strain

matrix T we also simulated ﬁve pairwise different loads l

(1)

, ...,

(5)

with different characteristics and acting on different parts of

the steel plate, see Fig. 12.

The simulated strain values are then converted into integer val-

ues in between 1 and 1024, a zero signal corresponding to the

value 512; if



denotes a simulated strain value, this conversion

is done using the formula s

= b512 + 10000

⁄



c,16 i 6 2M.(bac

denotes the largest integer smaller than or equal to a2 R.) Thus,

ﬁve strain measurement vectors s

(1)

, ..., s

(5)

are computed. We

use these ﬁve data sets and feed them consecutively as sensor val-

ues into the simulation framework for the sensor network shown

in Fig. 4: Choosing a ﬁxed intermediate time interval of 500 simu-

0 10 20 30 40 50

Fig. 12. From (a) to (e): The ﬁve loads l

(1)

, ..., l

(5)

. (f) The positions of the 400 weight points w{i,j} are indicated using blue dots; red crosses indicate the positions of the 64

sensors. (For interpretation of the references to colour in this ﬁgure legend, the reader is referred to the web version of this article.)

26 S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

lation steps, we start by stimulating the sensor network using the

sensor data s

; during the next 500 simulation steps, the network

identiﬁes the load and propagates the sensor data to the computa-

tional nodes. After 500 time steps we stimulate the network by

inserting the sensor data s

, and wait again 500 time steps until

we stimulate again relying on s

, and so on. In an intact network,

the multi-agent system requires about 100 time steps to identify

an activated region and to send out event agents to the

computational nodes. In a defective network where some connec-

tions between sensor nodes are broken, this procedure takes more

time; the more connections are defect, the more time is required to

propagate information through the network.

The identiﬁcation of a loading event and the distribution of sen-

sor data works as explained in Section 4: If a sensor node notes a

signiﬁcant change of one of its sensor values (i.e., strain in x-or

y-direction), he sends out explorer agents.

In case that the agent system detects an activated region (see Sec-

tion 4.2), each sensor node in the boundary of this region sends out

four event agents in the four directions of the network. Each event

agent tries to propagate the sensor values of its creating node and

of all nodes passed on its way through the network to one of the four

computation nodes in the four corners of the network. For simplicity,

we name these four computation nodes according to their position

in the network (see Fig. 4): The computation node in the upper left

and right corner is called NW (north west) and NE (north east),

respectively, and the one in the lower left corner and lower right cor-

ner is called SW (south west) and SE (south east), respectively. Note

that event agents coming from different nodes will arrive at different

times at the computational nodes, in particular, if some of the net-

work connections are broken. The computation nodes collect the

incoming sensor values and back-transform them into ﬂoating point

number via s

m,i

=(s

 512)/10000. If no event agents arrive at a

computation node, the node computes a reconstruction of the load

causing the event agents using either Tikhonov regularization (see

Eq. (14)) or the cg-method (see Algorithm 1). This implies that

possibly not all sensor values from the individual sensors are prop-

agated, that not all sensor nodes know all values from the complete

strain data vector s

, that several values might arrive too late at a

computation node and either erroneously cause a further load com-

putation or perturb the computation of the next load.

Whenever a computation node starts a computation with

incomplete sensor data (which is rather common than an excep-

tion in our experimental setting), then the missing values in s

are set to 0. It is at this point obvious that the noise level in s

usually enormous, typically way beyond 15%. Due to possibly late

arrival of sensor data, the noise level of the data moreover becomes

time-dependent and the entire monitoring process also becomes a

time-dependent inversion problem.

Fig. 13 shows the successively monitored loads of the computa-

tion node NE during the simulation time of an intact sensor net-

Fig. 13. Loads inverted by the NE computation node of the self-organizing sensor network based on mobile agents. All connections in the network are intact. (a)–(d): Loads

(1)

, ..., l

(4)

, Tikhonov regularization Eq. (14), a =6 10

5

. (e)–(h): Loads l

(1)

, ..., l

(4)

, cg method (Algorithm 1), d ¼ 0:2.

S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

work as sketched in Fig. 4, i.e., all connections in the network are

faultless. Both methods generally detect the correct position of a

load, however, a precise shape detection is impossible given the

quality of the data. The third loading l

(3)

poses problems to both

algorithms; the Tikhonov regularization detects a load on the

lower left side of the plate while the cg-method over-estimates

the magnitude of the load. (The latter behaviour is a typical feature

of this method in our setting.)

The ﬁfth load l

(5)

consists of three point-like loadings with rel-

atively high magnitude (see Fig. 12(e)). Both inverse methods have

signiﬁcant difﬁculties to cope with this situation: Fig. 14 shows

reconstructions using both methods by two different computation

nodes (NE, SW). While NE is via Tikhonov regularization able to

detect the three loads, the cg-method merely indicates the pres-

ence of the highest load at the left side of plate (both estimated

magnitude are wrong). The data arriving at SW is not sufﬁcient

to reasonably determine any feature of the load. However, Fig. 14

shows another typical feature of the cg-method: If there is not

enough sensor data available to reasonably reconstruct at least

parts of the load, then the method produces highly oscillating

results with very high amplitudes that are obviously wrong. We

will see later that such output of the method can reliably be ﬁl-

tered by rejecting monitored loads with high amplitudes.

Since the sensor network is self-organizing via the multi-agent

system, the strain data are not arriving at the same time at the com-

putation nodes. As discussed above, it might hence happen that a

computation node reconstructs a load before all relevant strain data

has arrived. Independently of the chosen inverse method, an

updated computation is in this case often signiﬁcantly better than

the result gained from incomplete data, as Fig. 15 indicates.

A typical phenomenon of the sensing system appears in Fig. 15

(e) and (g): The reconstruction of l

(5)

in Fig. 15(e) by the

north-western computation node NW using Tikhonov regulariza-

tion is perturbed by data stemming from the strain data s

corresponding to l

(4)

. The analogous observation holds for the

cg-method applied to the same data sets (see Fig. 15(e)–(h)).

We already noted above that the magnitudes of the recon-

structed loads are in some cases roughly speaking more sensitive

than the overall position of the loads. To this end, we plot in

Fig. 16(a) the maximal force of a reconstructed load for 52 compu-

tations (26 Tikhonov and 26 cg reconstructions) by the four com-

putation nodes during the above-described test of the sensing

system. In 10 cases, the maximal loading of a cg reconstruction is

signiﬁcantly larger than the corresponding result of the Tikhonov

regularization; in all these cases, the corresponding monitored

load is unusable and should be rejected. We emphasize that this

is a good feature of the method since it allows to easily identify

incorrectly reconstructed loads. Note that Fig. 16(a) further indi-

cates that the magnitudes of the loads computed by the Tikhonov

regularization are rather good compared to the exact magnitude

(given the accuracy of the data) and, except for the point-like load

(5)

, rather robust against noise. This is obviously different for the

cg method that does not show the same stability in this setting.

Fig. 16(b) moreover indicates that checking the normalized cross-

correlation between the two reconstructions given by the two

inverse methods can be used as an indicator for their reconstruc-

tion quality: If cross correlation factor above 0.8 is in all examples

a good indicator for a reasonable reconstruction quality.

In the last part of this section we consider the same test simu-

lation for the sensor network as above, but perturb 30% of all net-

work connections. The agents of the multi-agent system can hence

no longer propagate between all neighboring nodes (and they no a

priori knowledge which connections are defect). Apart from this

change of the network topology, the setting of the simulation is

precisely the same as above. Thus, compared to the experiments

discussed above, sensor data is in this new setting likely to arrive

later at computation nodes than before and might, in some cases,

not arrive at all. The data quality hence is worse than before. Nev-

ertheless, the monitored loads shown in Fig. 17 are (in the visual

norm) of a similar same quality as the corresponding ones from

Fig. 13. At several of the plots, the incorrectly appearing yellow

regions are somewhat extended.

Fig. 14. Load l

(5)

inverted by the NE and SW computation nodes of the self-organizing sensor network based on mobile agents. All connections in the network are intact. (a)

NE node, Tikhonov regularization Eq. (14),

a ¼ 6  10

5

. (b) NE node, cg method (Algorithm 1), d ¼ 0:2. (c) SW node, Tikhonov regularization Eq. (14), a ¼ 6  10

5

. (d) SW

node, cg-method (Algorithm 1), d ¼ 0:2.

28 S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

Fig. 15. When sensor data arrives at a computation node after a load has already monitored, the node re-computes the load. All indicated pairs of plots show two consecutive

reconstructions of a load due to late sensor data arrival; the network is intact. (a) and (b) Two reconstructions of l

(3)

by SE node; Tikhonov regularization Eq. (14), a=610

5

(3)

by SE node; cg method (Algorithm 1), d ¼ 0:2. (e) and (f) Two reconstructions of l

(5)

by NW node; Tikhonov regularization Eq. (14),

a ¼ 6  10

5

. (g) and (h) Two reconstructions of l

(5)

by NW node; cg-method (Algorithm 1), d ¼ 0:2.

0 5 10 15 20 25

Intact network: Maximum of monitored loads

Reconstruction Nr.

Load [N/cm

]

0 5 10 15 20 25

0.2

0.4

0.6

0.8

Intact network: Normal. cross corr. between two rec. loads

Reconstruction Nr.

Fig. 16. (a) Maximum of the loads by an intact sensor network for 54 reconstructions computed by the four computation nodes NE, NW, SE, SW during the evolution of the

simulated system. If the maximum of a monitored load is larger than 5 N/cm

we plot the value 5. (Red triangles: Tikhonov regularization; blue dots: cg-method; black stars:

maximum of the exact load.) (b) Normalized cross correlation between the loads reconstructed by Tikhonov regularization and the cg-method for each of the 26

reconstruction events. (For interpretation of the references to colour in this ﬁgure legend, the reader is referred to the web version of this article.)

S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

Fig. 18 indicates that the phenomenon of sensor data arriving at

a computation node after the node already computed a ﬁrst recon-

struction becomes stronger:

In Fig. 18(a)–(d) one notes data from the surface strain s

corre-

sponding to l

(1)

appears in the reconstruction of l

(2)

; thus, data from

and s

is arriving at about the same type and both loads show up

in the same reconstruction.

Finally checking for the magnitudes of the reconstructed loads

and the cross-correlation between the results of the two different

inverse methods shown in Fig. 19 allows to draw similar conclu-

sions as above: The perturbed network reduces the data quality

and the cg-method accordingly yields results with too high ampli-

tude more frequently (13 out of 28 cases). However, the results

gained by Tikhonov regularization remain more stable, which indi-

cates another time the potential of this technique (and its reﬁne-

ments) for load monitoring in a substantially involved setting.

7. Conclusions and outlook

A novel sensor processing approach using mobile agents for

reliable distributed and parallel data processing in large scale net-

works of low-resource nodes was introduced and investigated,

leading to a sensor signal pre-processing at run-time inside the

sensor network by using a hybrid multi-agent system. Agent

mobility crossing different execution platforms in mesh-like net-

works and agent interaction by using tuple-space databases and

global signal propagation aid solving data distribution and syn-

chronization issues in the design of distributed sensor networks.

Event-based sensor data distribution and pre-computation with

agents reduces communication and overall network activity result-

ing in reduced energy consumption.

Off-line inverse numerical computation of pre-processed sensor

data allows the calculation of the unknown system response (i.e.,

the load) based on data from prior FEM simulations of the technical

structure.

Throughout this work, a multi-domain simulation was used

capable to simulate multi-agents systems deployed in large-scale

networks and numerical computation with a uniﬁed database

centric simulation environment.

A case study demonstrated the suitability of the proposed smart

sensor processing approach, using event-based sensor data

propagation, adaptive path ﬁnding, and feature extraction with

self-organizing exploration. The presented examples for load

monitoring show that both the classical Tikhonov regularization

method and the cg-method are suitable inverse algorithms for

structural load monitoring.

The self-organizing load monitoring system presented in this

paper shows a partly surprising robustness against missing or

Fig. 17. Loads inverted in a defective network by the NE computation node. 30% of all network connections are defective. Parameters for the reconstruction algorithms are the

same as for the intact network. (a)–(d): Loads l

(1)

, ..., l

(4)

, Tikhonov regularization Eq. (14), a ¼ 6  10

5

. (e)–(h): Loads l

(1)

, ..., l

(4)

, cg-method (Algorithm 1), d ¼ 0:2.

30 S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

incorrect data present at the computation nodes resulting, mainly a

result of 1. missing or defective communication links prohibiting sen-

sor data distribution and delivery to the computational nodes and 2.

the event-based partial delivery of sensor data. The incomplete sensor

data sets resulting from the event-based data distribution and the

SoMAS feature detection bases on two effects: 1. not fully covering

the stimulated region and 2. recognizing the wrong region, especially

in the case of a spatially smooth sensor stimuli distribution. The mis-

match of sensor distribution can be partially covered by the four

redundant but spatially distributed edge computational nodes at the

outside of the network, which performs the ﬁnal load computations.

As an outlook into future work, we mention two points: It

becomes apparent in the second part of the numerical experiments

that time-stamping sensor data would make the entire load

monitoring system more stable and accurate. This direction of

research will be investigated in future projects. Further, the detec-

tion of point-like loading (as l

(5)

) is currently insufﬁcient. We will

further investigate the possibility to improve the detection of

point-like loads and the correct estimation of their correct magni-

tudes, which is clearly a weak point of the monitoring system pre-

sented in this paper. The second work concerns the classiﬁcation of

the four mostly different load computations of the edge computers

using machine learning or fusion concepts to ﬁlter out the load

computation with the highest trust.

The multi-agent behaviour is composed of different agent

classes and speciﬁed using the agent-orientated programming lan-

guage AAPL based on the Dynamic ATG model, which provides

computational statements and statements for agent creation,

Fig. 18. Changing reconstructions of loads in a defective sensor network due to late arrival of data. 30% of all network connections are defective. The plots (a) and (b) and (b)

and (c) show two consecutive reconstructions of l

(2)

by SE node, the update is due to additionally arriving sensor data. (a) and (b) Tikhonov regularization Eq. (14),

a ¼ 6  10

5

. (c) and (d) cg method (Algorithm 1), d ¼ 0:2.

0 5 10 15 20 25

Defective network: Max of monitored loads [N/cm

]

Reconstruction Nr.

Load [N/cm

]

0 5 10 15 20 25

0.2

0.4

0.6

0.8

Reconstruction Nr.

Defective network: Normal. cross corr.

between two rec. loads

Fig. 19. Left: Maximum of the loads monitored by a defective sensor network; 30% of all network connections are defective. The 28 reconstructions are computed by the four

computation nodes NE, NW, SE, SW during the evolution of the sensing system. If the maximum of a monitored load is larger than 5 N/cm

we plot the value 5. (Red triangles:

Tikhonov regularization; blue dots: cg-method; black stars: maximum of the exact load.) Right: Normalized cross correlation between the loads reconstructed by Tikhonov

regularization and the cg-method for each of the 28 reconstructions. (For interpretation of the references to colour in this ﬁgure legend, the reader is referred to the web

version of this article.)

S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

inheritance, mobility, interaction, reconﬁguration, and information

exchange, based on agent behaviour partitioning in an activity

graph. There are programmable and application-speciﬁc agent pro-

cessing platforms suitable for embedded sensor networks, and the

programmable platform can be deployed in the Internet domain,

too. In case of the programmable platform, the agent behaviour

is compiled to program code which is executed on a stack-based

virtual machine, which can be directly synthesized to the micro-

chip level by using a high-level synthesis approach. Furthermore,

the high-level synthesis tool enables the synthesis of different pro-

cessing platforms implementations from a common speciﬁcation

(programmable platform) or the AAPL sources (application-

speciﬁc platform), including standalone hardware and software

platforms, as well as simulation models offering functional and

behavioural testing. All platform implementations are compatible

on operational and communication level. The migration of an agent

to a neighbour node takes place by migrating the data and control

state encapsulated in the program code of an agent using message

transfers (programmable platform). Two different agent interac-

tion primitives are available: signals carrying data and tuple-

space database access with pattern templates. Conﬁguration and

(re-)composition of the activity graph offers agent behaviour adap-

tation (which can be inherited by child agents) at run-time and

relax communication and storage requirements. Additionally,

(re-) composition allows the derivation of agent sub-classes from

a super class, matching the requirements in SoMAS.

Fig. 20. Short notation of the AAPL agent behaviour programming language and some symbols.

32 S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

Appendix A. Algorithms

Algorithm 2. Agent behaviour of the Event agent class offering a

robust event-based and path tracking sensor data distribution

S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

Algorithm 3. Routing functions

34 S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

Algorithm 4. Agent behaviour of the Explorer agent class using a

SoS based feature recognition detecting the boundary of a spatially

correlated sensor stimuli region.

Appendix B. Notation

Fig. 20.

S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

References

[1] Pantke F, Bosse S, Lehmhus D, Lawo M. An artiﬁcial intelligence approach

towards sensorial materials. In: Future computing conference; 2011.

[2]

Farrar CR, Worden K. Structural health monitoring: a machine learning

perspective. Wiley-Interscience; 2013

[3]

Worden K, Manson G. The application of machine learning to structural health

monitoring. Phil Trans R Soc A 2007;365:515–37

[4]

Friswell M. Damage identiﬁcation using inverse methods. Phil Trans R Soc A

2007;365:393–410

[5] Friswell MI, Mottershead JE. Inverse methods in structural health monitoring.

In: DAMAS 2001: 4th international conference on damage assessment of

structures, Cardiff; June 2001. p. 201–10.

[6]

Carn C, Trivailo P. The inverse determination of aerodynamic loading from

structural response data using neural networks. Inverse Problems Sci Eng

2006;14:379–95

[7]

Huhtala A, Bossuyt S. A Bayesian approach to vibration based structural health

monitoring with experimental veriﬁcation. Rakenteiden Mekaniikka (J Struct

Mech) 2011;44:330–44

[8]

Giurgiutiu V. Structural health monitoring with piezoelectric wafer active

sensors. Elsevier; 2008

[9]

Engl HW, Hanke M, Neubauer A. Regularization of inverse problems. Dordrecht

(Netherlands): Kluwer Acad. Publ.; 1996

[10]

Daubechies I, Defrise M, De Mol C. An iterative thresholding algorithm for

linear inverse problems with a sparsity constraint. Commun Pure Appl Math

2004;57(11):1413–57

36 S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

[11] Guijarro M, Fuentes-fernández R, Pajares G. A multi-agent system architecture

for sensor networks. Multi-agent systems – modeling, control, programming,

simulations and applications; 2008.

[12] Zhao X, Yuan S, Yu Z, Ye W, Cao J. Designing strategy for multi-agent system

based large structural health monitoring. Expert Syst Appl; 34(2). doi:http://

dx.doi.org/10.1016/j.eswa.2006.12.022.

[13] Sansores C, Pavón J. An adaptive agent model for self-organizing MAS. In: Proc.

of 7th int. conf. on autonomous agents and multiagent systems (AAMAS 2008),

May 12–16, 2008, Estoril, Portugal; 2008. p. 1639–42.

[14] Yuan S, Lai X, Zhao X, Xu X, Zhang L. Distributed structural health monitoring

system based on smart wireless sensor and multi-agent technology. Smart

Mater Struct 2006;15(1):1–8

[15]

Liu J. Autonomous agents and multi-agent systems. World Scientiﬁc; 2001.

ISBN: 981-02-4282-4

[16] Bosse S. Distributed agent-based computing in material-embedded sensor

network systems with the agent-on-chip architecture. IEEE Sensors J, Special

issue on mateiral-integrated sensing, doi:http://dx.doi.org/10.1109/JSEN.2014.

2301938.

[17] Bosse S. Processing of mobile multi-agent systems with a code-based agent

platform in material-integrated distributed sensor networks. In: Proceedings

of the 1st int. electron. conf. sens. appl., 1-16 June 2014; 2014. p. 1–7, doi:

http://dx.doi.org/10.3390/ecsa-1-d010.

[18] Bosse S, Lechleiter A. Structural health and load monitoring with material-

embedded sensor networks and self-organizing multi-agent systems. Proc

Technol 2014;15(0):669–91. http://dx.doi.org/10.1016/j.protcy.2014.09.039

[19]

Kirsch A. An introduction to the mathematical theory of inverse

problems. Springer; 1996

[20] Bosse S. Design of material-integrated distributed data processing platforms

with mobile multi-agent systems in heterogeneous networks. In: Proc. of the

6th international conference on agents and artiﬁcial intelligence ICAART 2014.

doi:http://dx.doi.org/10.5220/0004817500690080.

[21]

Klügel F. SeSAm: visual programming and participatory simulation for agent-

based models. In: Uhrmacher AM, Weyns D, editors. Multi-agent systems –

simulation and applications. CRC Press; 2009

[22]

Lehmhus D, Bosse S. Sensorial materials. In: Lehmhus D, Busse M, Herrmann

AS, Kayvantash K, editors. Structural materials and processes in

transportation. Wiley-VCH; 2013. p. 517–48. ISBN: 9783527327874

[23]

Hecht F. New development in FreeFem++. J Numer Math 2012(3–4):251–65.

65Y15.

S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37