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 unified multi-domain simulation framework
is used to profile and validate the proposed approach.
Ó 2015 Elsevier Ltd. All rights reserved.
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 reflects 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 significantly, 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 fixed 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 signifi-
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
0957-4158/Ó 2015 Elsevier Ltd. All rights reserved.
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 difficult to distribute efficiently 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 profit from
artificial intelligence, which is usually based on classification 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 (first-hand)
observation, which makes it difficult 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 first 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 find 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 find 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
kk
2
2
þ
a
l
kk
2
2
; ð1Þ
where a > 0 and kk
2
is the 2-norm of a vector defined by Eq.
(2), but different and more complicated variants exist and might
also be convenient choices. The latter vector norm is defined for
any dimension n 2 N and any vector
v ¼ðv
1
; ...; v
n
Þ
>
2 R
n
by
k
v
k
2
¼
X
n
j¼1
j
v
j
j
2
!
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 first class is the Tikhonov regularization mini-
mizing the quadratic functional (Eq. (1)) by solving the equivalent
linear system (T
T +
a
)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 definitely 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 finally 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 finally inverse numerical methods compute an approximation l’ to the
applied load.
S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37
13
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]. Artificial intelligence and machine learning can be used in
sensorial materials without a predictive mechanical model at hand
[1], which is a definite 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 modified 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 modifications,
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 flow includ-
ing functional behavioural simulation. For material-integration,
there is an application specific 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 sufficiently 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
l
as solution to the linear system
ðT
T þ
a
Þl ¼ T
s þ
a
l
0
; ð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 difficult. 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 specific 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
unified 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 profiled 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 finite-state machine model, which simplifies the
hardware implementation, but still enabling efficient 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 specific
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
specific 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 specific 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
15
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-
nificant decrease of network processing and communication activity
and a significant 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 finding (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 final 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 significant change
of specific 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 specified 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-defined 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-defined 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 final 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)
significantly 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 find 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 find 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 significant 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 specific node with the coordinate (i, j) is given by Eq. (4).
Hði; jÞ¼
X
R
u¼R
X
R
v ¼R
f sði þ u; j þ
v
Þsði; jÞ
jj
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, configuration (control state), and data
Migration: code transfer
Application-specific approach
Platform is application-specific
Activities of the ATG are mapped to processes
Token-based agent processing
ATG reconfiguration by switching token channel paths
Migration: data and control state transfer (including configuration
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 modification)
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 configuration matrix approach for ATG reconfiguration
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-specific simulation model
ATG activity processes are simulated with agents
S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37
17
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 +
v
)
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 @
¼½
0
;
1
, 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 specified 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
x
/s
y
). 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 significant 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 figure 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
R
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 @
¼½
0
;
1
. 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 first data set related with a specific load case has a signifi-
cant increase of sensor values at the east side of the network. The
boundary feature detection SoMAS reliable finds 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 flat
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 finds 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 find 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
19
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
1
,
s
2
, ..., s
n
} by adding noise d (e.g., common distributed) to the orig-
inal input data, i.e., s’ ={s
1
+d
1
, s
2
+ d
2
, ..., s
n
+ d
n
}, creating multiple
simulation experiments with sets s’
1
, s’
2
, ... of different artificially
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
l
1
: Fðs þ d
1
; E
1
Þ; l
2
: Fðs þ d
2
; E
2
Þ; ...
fg
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 specific 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
i
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 file system
pipes. This approach has the advantage to require only a native file
system interface to connect a heterogeneous program environ-
ment, supported basically by all programs. No program modifica-
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
i
is implemented with a SeSAm agent
class SC
i
.
Each AAPL sub-class AC
i,j
is implemented with a SeSAm agent
class SC
j
. 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 figure 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
i
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
i
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
i
) {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 profil-
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 first 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 defined 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 figure legend, the reader is referred to the web version of this
article.)
S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37
21
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 fixed 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
m
. Moreover, any (spartially variable) load on
the structure is assumed act constantly in time during a certain
time interval, such that the deformation field u =(u
1
, u
2
, u
3
)
>
is
static during this time interval and can be described by the equa-
tions of static linear elasticity,
ðk þ
l
Þ
r
divu þ
lD
u ¼ 0inX; ð6Þ
where k and
l
are Lame parameters defined by
k ¼
mE=½ð1 þ mÞð1 2mÞ and
l
¼ E=ð2 þ 2mÞ. The deformation field
vanishes at the boundary where the plate is fixed and satisfies 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 field 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
x
M
y
sensor positions in a grid of sensors of size M
x
M
y
.
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 finite element discretization we simulate a finite num-
ber of loads caused by cylindrical weights with (cross-section)
radius of 0.0125 m placed at N = N
x
N
y
equidistant grid points
w
i;j
¼
ð0:25mþði 1Þ0:5mÞ=N
x
ð0:25mþðj 1Þ0:5mÞ=N
y
0:02 m
0
B
@
1
C
A
; i ¼ 1;...;N
x
; j ¼ 1;...;N
y
;
ð7Þ
that form a grid of N
x
N
y
points on the upper side of the plate.
Simulating the deformation field 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
m
i;j
¼
ð0:25mþði1Þ0:5mÞ=M
x
ð0:25mþðj 1Þ0:5mÞ=M
y
0:00m
0
B
@
1
C
A
; i ¼ 1;...;M
x
; j ¼ 1;...;M
y
:
ð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 finite 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 finite 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
N
is a vector modeling loads applied to the upper surface,
the resulting strain s 2 R
2M
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
y
1)i + jth entry of the vector l. Further,
the entry s
x
(i, j) of a strain matrix s
x
is the (M
y
1)i + jth entry of
the vector s and the entry s
y
(i, j)ofs
y
is the M +(M
y
1)i + jth entry
of the vector s.
To compute the load–strain matrix T we used the C++-based
and open-source finite-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 field. 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 finite-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 finite 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
2
-norm), then
a convergence rate in between one and two is achieved, and if the
exact solution is sufficiently smooth (which is not always the case
in our examples), then the convergence rate of the deformation
field is higher than quadratic.
However, we are ultimately interested in the surface strains,
that is, in derivatives of the deformation field, 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
: i-th load case data set).
S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37
23
the quadratic mean with a rate that is one order smaller than the
one of the deformation field itself.
As the solution of the N linear systems to compute the load–
strain matrix T is part of the pre-computations and does influences
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 field or
the strain tensor (as, e.g., KirchhoffLove plate theory) but simply
tackled the full three-dimensional problem directly and ensured
that the results are sufficiently 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 finite-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 fixed 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
m
for given inaccurate strain mea-
surements s
m
. This task is intrinsically difficult since the matrix T
is ill-conditioned:
As Fig. 11 shows, the singular values of T for M
x
= M
y
= 8 and
N
x
= N
y
= 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 five 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
N
,
T
Tl ¼ T
s
m
; ð10Þ
that is derived from the linear system Tl = s
m
. (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
m
k
2
, where we recall that kk
2
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 first part of this paper, propagating sensor measurements by
a Self-organizing Multi-Agent system to the four computation
nodes (see Fig. 4) introduces significant errors in the measured
data arriving at the computation node due to different arrival times
or broken network connections.
Thus, the strain vector s
m
available for computations is in
general incomplete and contains a very high level of noise. This fact
causes severe difficulties to any inverse method; nevertheless,
even for such a difficult 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 artificial noise to the simulated load–strain matrix T
and the simulated strain vectors s
m
. We refer to [18] for results
in this direction.
10
-4
10
-3
10
-2
10
-1
0 20 40 60 80 100 120 50 100 150 200 250 300 350 400
20
40
60
80
100
120
10
-3
-2
-1
0
1
2
3
4
5
6
7
Fig. 11. On the left: 128 non-zero singular values of load–strain matrix T 2 R
2MN
for M = 64 simulated sensors M
x
= M
y
=8 and N = 400 simulated weights (N
x
= N
y
= 20). On
the right: Absolute values of the entries of the load–strain matrix T. Since the steel plate is fixed 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 first 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
m
as in Eq. (10) but the
stabilized functional
l # kTl s
m
k
2
2
þ
a
klk
2
2
; ð11Þ
where kk
2
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 difficult to compute that the minimizer of this quadratic
minimization problem solves the linear equation
ðT
T þ
a
Þl ¼ T
s
m
: ð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
U = I
M
and V
V = I
N
where I
N
is the unit matrix of size N N).
We denote the diagonal elements of the matrix D by d
i
, i =1, ...,
min(N, M), and can hence write D = diag(d
i
). The d
i
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
i
=ðd
2
i
þ
a
ÞÞU
s
m
: ð14Þ
This inversion method hence multiplies the k-th strain value
(i.e., the k-th entry of s
m
) with the k-th column of the matrix
K = V diag(d
i
/(d
i
2
+
a
))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
m
and hence MN scalar multiplications and (N 1)M additions of
binary numbers with a fixed 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 difficult, 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
T
Tl = T
s, an iterative technique where the k-th iterate l
k
mini-
mizes the discrepancy kTl sk
2
in the so-called Krylov subspace
spanned by the vectors
T
s; ðT
TÞT
s; ðT
TÞ
2
T
s; ...; ðT
TÞ
k1
T
s: ð15Þ
Algorithm 1. The cg-algorithm applied to the linear system Tl = s
with starting vector l
0
(pseudo-notation)
Due to the ill-conditioning of the load–strain matrix T, the
cg-iteration applied to noisy data s
m
with relative noise level
d ¼ks
m
s
exact
k
2
=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
difficult 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 finite ele-
ment method with P2 elements and simulate static loading of a
0.02 m thick quadratic building steel plate
X
with side lengths of
0.5 m that is fixed at one of its four vertical sides. As material
parameters of the homogeneous and isotropic plate we fix the elas-
tic modulus E of 210 kN/mm
2
and the Poisson’s ration
m
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
25
the deformation field u =(u
1
, u
2
, u
3
)
>
(see Eq. (6)). As mentioned
above, the deformation field u is governed by Eq. (6) and the strain
measurements are simulated as point values of the derivatives of
u
1
and u
2
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 defined
in Eq. (7) for N
x
= N
y
= 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
2
. As discussed in Section 6.1,
after computing the deformation field, we compute the surface
strain in x and y direction at the sensor points given in Eq. (8)
where M = 64 (since M
x
= M
y
= 8). By computing the deformation
field and the extracted surface strain for a sequence of refined
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 five pairwise different loads l
(1)
, ...,
l
(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
i
denotes a simulated strain value, this conversion
is done using the formula s
i
= b512 + 10000
i
c,16 i 6 2M.(bac
denotes the largest integer smaller than or equal to a2 R.) Thus,
five strain measurement vectors s
(1)
, ..., s
(5)
are computed. We
use these five data sets and feed them consecutively as sensor val-
ues into the simulation framework for the sensor network shown
in Fig. 4: Choosing a fixed intermediate time interval of 500 simu-
0 10 20 30 40 50
0
5
10
15
20
25
30
35
40
45
50
Fig. 12. From (a) to (e): The five 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 figure 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
1
; during the next 500 simulation steps, the network
identifies 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
2
, and wait again 500 time steps until
we stimulate again relying on s
3
, 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 identification of a loading event and the distribution of sen-
sor data works as explained in Section 4: If a sensor node notes a
significant 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 floating point
number via s
m,i
=(s
i
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
m
, 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
m
are set to 0. It is at this point obvious that the noise level in s
m
is
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
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.
S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37
27
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 fifth load l
(5)
consists of three point-like loadings with rel-
atively high magnitude (see Fig. 12(e)). Both inverse methods have
significant difficulties 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 sufficient
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 fil-
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 significantly 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
4
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
significantly 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
l
(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=610
5
.
(c) and (d) Two reconstructions of l
(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
0
1
2
3
4
5
Intact network: Maximum of monitored loads
Reconstruction Nr.
Load [N/cm
2
]
0 5 10 15 20 25
0
0.2
0.4
0.6
0.8
1
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
2
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 figure legend, the reader is referred to the web version of this article.)
S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37
29
Fig. 18 indicates that the phenomenon of sensor data arriving at
a computation node after the node already computed a first recon-
struction becomes stronger:
In Fig. 18(a)–(d) one notes data from the surface strain s
1
corre-
sponding to l
(1)
appears in the reconstruction of l
(2)
; thus, data from
s
1
and s
2
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 refine-
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 unified 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 finding, 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 insufficient. 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 classification of
the four mostly different load computations of the edge computers
using machine learning or fusion concepts to filter out the load
computation with the highest trust.
The multi-agent behaviour is composed of different agent
classes and specified 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
0
1
2
3
4
5
Defective network: Max of monitored loads [N/cm
2
]
Reconstruction Nr.
Load [N/cm
2
]
0 5 10 15 20 25
0
0.2
0.4
0.6
0.8
1
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
2
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 figure legend, the reader is referred to the web
version of this article.)
S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37
31
inheritance, mobility, interaction, reconfiguration, and information
exchange, based on agent behaviour partitioning in an activity
graph. There are programmable and application-specific 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 specification
(programmable platform) or the AAPL sources (application-
specific 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. Configuration 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
33
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
35
References
[1] Pantke F, Bosse S, Lehmhus D, Lawo M. An artificial 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 identification 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 verification. 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 Scientific; 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 artificial 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
37