REASONING ON DATA STREAMS FOR SITUATION AWARENESS

∗

Norbert Baumgartner

, Wolfgang Gottesheim

, Stefan Mitsch

, Werner Retschitzegger

and Wieland Schwinger

Team Communication Tech. Mgt. GmbH, Goethegasse 3, 1010 Vienna, Austria

Johannes Kepler University Linz, Altenbergerstr. 69, 4040 Linz, Austria

Keywords:

Stream reasoning, Situation awareness.

Abstract:

Information overload is a severe problem for human operators of large-scale control systems, for instance,

in road trafﬁc management. In order to determine a complete and coherent view of the overall situation

(i. e., gain situation awareness), an operator of such a system must consider various heterogeneous sources

providing streams of information about a large number of real-world objects. Since the usage of ontologies has

been regarded to be beneﬁcial for achieving situation awareness, various ontology-driven situation awareness

systems have been proposed. Coping with evolving and volatile individuals in ontologies, however, has not

been their focus up to now. In this paper, we describe how concepts from data stream management systems and

stream reasoning, such as sliding windows, continuous queries, and incremental reasoning, can be adjusted

to support reasoning over highly dynamic ontologies for situation awareness. We conclude our paper with a

prototypical implementation and a discussion of lessons learned, pointing to directions of future work.

1 INTRODUCTION

Gaining Situation Awareness in Data Streams. In-

formation overload is a severe problem for operators

of large-scale control systems, such as encountered

in the domain of road trafﬁc management (RTM). In

order to determine a complete and coherent view of

the overall (trafﬁc) situation, an operator of such a

system must consider heterogeneous sources, such as

trafﬁc jam detectors and trafﬁc incident reports, pro-

viding information streams about a large number of

objects. In order to reduce information overload, sit-

uation awareness (SAW) systems, according to End-

sley (Endsley, 2000), support operators by pointing

them to relevant information during (i) perception of

objects (e. g., a trafﬁc jam), (ii) comprehension of cur-

rent situations (e. g., a wrong-way driver approaches a

trafﬁc jam), and (iii) projection of situation evolution

(e. g., a wrong-way driver may cause an accident).

Ontology-driven Situation Awareness Systems.

Since the usage of ontologies is beneﬁcial for SAW

(Llinas et al., 2004), various ontology-driven SAW

systems representing data streams in ontologies, for

∗

This work has been funded by the Austrian Fed-

eral Ministry of Transport, Innovation and Technology

(BMVIT) under grant FIT-IT 829598.

instance (Baumgartner et al., 2010), (Kokar et al.,

2009) have been proposed. In contrast to tradi-

tional ontology-driven information systems focusing

on query answering (cf. (Buccella et al., 2009) for

a recent survey), SAW systems often operate on data

streams resulting from constantly monitoring the en-

vironment under control. This entails, that reason-

ing components, such as a situation assessor deter-

mining the current situation, must process a highly

dynamic ontology comprising evolving (e. g., a grow-

ing trafﬁc jam) and volatile individuals (e. g., an ac-

cident). Although ontology-driven approaches in the

area of situation awareness exist, coping with evolv-

ing and volatile individuals in ontologies has not been

the focus up to now

. In this paper, we describe how

concepts from data stream management systems and

stream reasoning, such as sliding windows, contin-

uous queries, and incremental reasoning, can be ad-

justed to support reasoning for SAW.

Challenges of Highly Dynamic Ontologies. In or-

der to establish a basis for describing the challenges

of highly dynamic ontologies in situation awareness,

Note, that the research ﬁeld of ontology evolution (Har-

tung et al., 2011) focuses on a different problem, namely the

evolution of the schema level of ontologies.

407

Baumgartner N., Gottesheim W., Mitsch S., Retschitzegger W. and Schwinger W..

REASONING ON DATA STREAMS FOR SITUATION AWARENESS.

DOI: 10.5220/0003656704070412

In Proceedings of the International Conference on Knowledge Engineering and Ontology Development (KEOD-2011), pages 407-412

ISBN: 978-989-8425-80-5

 2011 SCITEPRESS (Science and Technology Publications, Lda.)

in the following a brief overview of major reason-

ing components of an SAW framework (Baumgartner

et al., 2010) is given. As part of applying this frame-

work to a particular domain, adaptors and domain

mappers resolve structural and semantic heterogene-

ity by representing information from a data stream

ﬁrst as individuals of a domain ontology, which is

then mapped into a core ontology. This core ontol-

ogy characterizes objects by attributes (e. g., loca-

tion). The history of an object is described in terms

of changes to their attributes, assigning to each at-

tribute value a temporal validity and a direct prede-

cessor. Due to frequent updates in the underlying data

streams, the core ontology comprises highly dynamic

individuals. Framework components must cope with

these dynamic individuals as detailed below.

First, on the perception level a chronologically

consistent ordering of attribute values in the face

of arbitrary update sequences across multiple data

streams must be established. For example, a trafﬁc

jam detector may report a trafﬁc jam without delay,

possibly resulting in a radio station report arriving

later in time, but actually describing the jam’s state

that was valid before. During this ordering, a change

collector avoids propagating undeterministic update

frequencies of underlying data streams to components

on higher levels by collecting updates into batches.

Second, on the comprehension level attribute values

determine relations between objects, which are fur-

ther aggregated to situations (task of a situation as-

sessor, cf. (Baumgartner et al., 2010) for details).

Hence, the challenge in data streams is to handle rea-

soning complexity by appropriately chosing the size

of sliding windows providing a view on data streams.

Structure of the Paper. Section 2 discusses related

work from data stream management and stream rea-

soning, as a basis for Sect. 3 and Sect. 4 applying con-

cepts from these research communities to SAW. Sec-

tion 5 describes a prototypical implementation, and

Sect. 6 lessons learned and further research directions.

2 RELATED WORK

In this section, we discuss concepts from data stream

management systems forming the basis for closely re-

lated work from the area of stream reasoning. In data

stream management systems (DSMS), various con-

cepts for handling the dynamic nature of data streams

have been described (cf. (Golab and Ozsu, 2003) for

a comprehensive overview of these concepts): Fixed,

landmark, and sliding windows

constrain the size of

an ever increasing data stream to those elements being

relevant for query execution. Common practice is to

deﬁne the size either in terms of time or information

item count (Golab and Ozsu, 2003). DSMS either sup-

port continuous queries over such sliding windows in

a monotonic fashion (i. e., assume that newly arrived

information do not affect previous query results), or

in a non-monotonic manner (i. e., may need to re-

evaluate previous results). Such concepts are success-

fully applied, e. g., in context aware systems for con-

tinuous spatial queries (Farrell et al., 2011). Focusing,

however, on information processing without consider-

ing rich background knowledge, DSMS are utilized for

querying rather than reasoning. In constrast, existing

semantic technologies supporting reasoning assume

static knowledge (Stuckenschmidt et al., 2010). The

exploitation of concepts from both worlds is the focus

in stream reasoning (Stuckenschmidt et al., 2010).

In stream reasoning, as part of the LarKC project,

various concepts have been proposed on the basis of

DSMS (Barbieri et al., 2010), (Stuckenschmidt et al.,

2010), (Valle et al., 2009). Della Valle et al. (Valle

et al., 2009) describe two complementary stream rea-

soning frameworks: (i) combining data stream man-

agement systems with standard reasoners and (ii) ex-

tending existing query languages, such as SPARQL.

In our work, we follow the ﬁrst approach by using

adaptors for resolving structural heterogeneity be-

tween data streams and applying standard reasoners

in SAW reasoning components. In the terminology

of Della Valle et al, these adaptors and SAW rea-

soning components are called transcoders and pre-

reasoners, respectively. Besides the basic task of at-

taching timestamps to RDF triples (Barbieri et al.,

2010), (Valle et al., 2009), these approaches, however,

do not focus on sorting those triples describing object

attributes into a chronologically consistent manner.

Concerning comprehension-level challenges, Barbi-

eri et al. (Barbieri et al., 2010) handle updates to ma-

terialized deductions whenever new information en-

ters the sliding window. Exceeding their ﬁxed win-

dow sizes, we additionally present concepts for dy-

namically adjusting windows. For non-monotonic

continuous queries, which are necessary in the pres-

ence of deleted and changed facts, we utilize prove-

nance information in our ontology for tracking deduc-

tions back to the facts they base upon and re-evaluate

deductions only when necessary.

In summary, current stream reasoning approaches,

although taking a ﬁrst step by utilizing general DSMS

Fixed windows have two ﬁxed ends, landmark win-

dows have one ﬁxed and one sliding end, and sliding win-

dows have two sliding ends (Golab and Ozsu, 2003).

KEOD 2011 - International Conference on Knowledge Engineering and Ontology Development

408

concepts, have not yet focused on major challenges

in situation awareness, in particular, (i) handling of

arbitrary update sequences, and (ii) adjusting sliding

window sizes. In the following sections, we describe

stream approaches to SAW, focusing these challenges

on the perception and comprehension level.

3 STREAM PERCEPTION

Adjusting Update Frequency. Since the underly-

ing data streams in road trafﬁc management are inde-

pendently maintained and highly dynamic, frequent

data updates at arbitrary times can occur. Each of

these updates may cause subsequent processing steps

of further components on the perception, comprehen-

sion, and projection level. In order to avoid high

performance overhead caused by consecutive, tem-

porally close updates, a change collector aggregrates

incoming updates from the underlying data streams

(in a similar manner as, for instance, context aggre-

gators (Dey, 2000)). Thereby, the change collector

moves forward a sliding window at conﬁgurable time

intervals, allowing the execution of subsequent com-

ponents on batch updates. As an additional task, the

change collector marks updated objects, thus enabling

subsequent components to work incrementally.

Chronologically Sorting Attribute Value Changes.

As a result of arbitrary update sequences, the temporal

intervals describing validity of attribute values may be

in arbitrary order as well. To achieve a chronologi-

cally correct ordering of attribute values, the topolog-

ical relationship between such temporal intervals is of

major importance. We utilize Allen’s interval algebra

(Allen, 1983), being perhaps the most established top-

logical temporal calculus, in order to describe topo-

logical relations between attribute valid time inter-

vals. Following Allen’s interval algebra, the data

source update sequences of the valid time of a previ-

ous and a current attribute value result in 13 possible

update cases (e. g., attribute valid times may overlap,

or one may be contained in another). In case multiple

attribute values are in conﬂict, strategies developed

in the data integration community can be used to re-

solve such conﬂicts. A detailed discussion of possible

strategies can be found in (Bleiholder and Naumann,

2008), two sample strategies are depicted in Table 1.

In this example those cases making fusion necessary

are shown (i. e., the valid time of previous informa-

tion and that of an update start or ﬁnish at the same

time, one is during the other, or both are equal to each

other). By applying the strategy Take the Information

(Bleiholder and Naumann, 2008), information newly

Table 1: Comparison of sample fusion strategies.

Relation Illustration Take the Information Trust your Friends

Starts |------| |------|

|------------| |------| |------------|

During |------| |------|

|------------| |---| |--| |------------|

Finishes |------| |------|

|------------| |------| |------------|

Equal |------| |------|

|------| |------|

added to the sliding window (top bar) is preferred over

previously added information (bottom bar), whereas

by applying the strategy Trust your Friends (Blei-

holder and Naumann, 2008), information of a partic-

ular data stream (bottom bar) is preferred over infor-

mation of another stream (top bar).

After consolidating incremental information from

data streams into an integrated ontology, comprehen-

sion of current situations can take place.

4 STREAM COMPREHENSION

In order to support human operators in their com-

prehension of current situations, especially relevant

is the description of relations between objects (e. g.,

close to) (Barwise and Perry, 1983). In SAW sys-

tems, this task is the responsibility of situation as-

sessment algorithms, which derive relations between

objects from object attributes and aggregate these re-

lations to situations (cf. (Baumgartner et al., 2010)

for details). In order to restrict situation assessment

to the most relevant types of situations only, many

SAW systems (e. g., (Kokar et al., 2009)) use rules for

deﬁning which types of relations must be derived be-

tween which types of objects. For example, the sit-

uation type AccidentNearTrafficJam could be de-

ﬁned as a rule stating that such a situation should be

reported, if an object of type Accident is in a rela-

tion of type Near with an object of type TrafficJam,

but only when the accident occurred During the life-

time of the trafﬁc jam. Such rules in an SAW system

represent reasoning goals for continuous processing

(Barbieri et al., 2010). Since satisfying these rules

involves pairwise comparison of objects for each pos-

sible relation (Baumgartner et al., 2010), sliding win-

dow size is of crucial importance to reduce compu-

tational effort. Sliding window size can be adjusted

either statically on the basis of situation and object

types or dynamically on the basis of current instances

thereof, as described in the following paragraphs.

Statically Adjusting Sliding Windows on the basis

of Situation Rules. A central question in reasoning

REASONING ON DATA STREAMS FOR SITUATION AWARENESS

409

Table 2: Relation types and relevant information about valid

time intervals.

Valid Time 2

Valid Time Relation Illustration

?------| |-----? Before |------|

|------|

|------? ?-----| After |------|

|------|

?------| |-----? Meets |------|

|------|

?------| |-----? Meets |------|

Inverse |------|

|------| |-----| Starts |------|

|------------|

|------| |-----| During |------|

|------------|

|------| |-----| Finishes |------|

|------------|

|------| |-----| Equal |-------|

|-------|

over data streams is concerned with ﬁnding the ap-

propriate size of the sliding window. A large window

size results in a large number of objects contained in

the sliding window, thereby lowering situation assess-

ment performance, whereas choosing a small win-

dow size results in the risk of missing relevant situ-

ations. The types of these situations, and in partic-

ular the rules deﬁning how such a situation can be

detected, however, provide valuable clues for deﬁn-

ing an appropriate window size. As a ﬁrst hint, types

of relations describing temporal distance between ob-

jects deﬁne upper bounds for the size of sliding win-

dows. Temporal relation types concerning the topol-

ogy of intervals (e. g., the relation type During used

above), however, do not deﬁne such clear-cut bound-

aries. Rather, they depend on valid times of the in-

volved objects. For adjusting sliding windows to ﬁt

such relation types, we can only provide experience-

based boundaries observed from real-world object

evolution (e. g., accidents are typically cleared within

two hours). Such experience-based boundaries, how-

ever, bear the risk of missing relevant situations. In

order to ﬁnd all relevant situations, we must dynami-

cally adjust sliding windows on the basis of both, sit-

uation rules and current objects, as discussed below.

Dynamically Adjusting Sliding Windows depend-

ing on Current Objects. Temporal relation types

without clear boundaries, such as topological rela-

tions between time intervals, make it necessary to de-

ﬁne sliding windows not in terms of statically ﬁxed

boundaries, but in terms of the objects contained in

them. Table 2 lists the information about valid time

intervals being relevant for deﬁning sliding window

sizes that are sufﬁciently large to satisfy Allen’s inter-

val algebra (Allen, 1983).

From this table showing Allen’s interval relations,

we see that the relation After should only be used in

combination with temporal distance relations. Other-

wise, objects can never be removed from the sliding

window, since at any time other objects occurring af-

ter them may be added to the sliding window.

5 PROTOTYPICAL

IMPLEMENTATION

In this section, we describe the software infrastructure

of our prototypical implementation and its application

in RTM on real-world information from the Austrian

highways agency

Software Infrastructure. Our infrastructure is

largely based on Java and the Jena Semantic Web

Framework

. For OWL reasoning within Jena, we use

the Pellet OWL Reasoner

offering reasonable perfor-

mance. For situation assessment, which accesses ob-

ject information extensively, we additionally use the

RDF triple store AllegroGraph

for its in-server rea-

soning capabilities (Baumgartner et al., 2010). Alle-

groGraph is a client-server system that integrates with

Jena and Pellet on the client side. On the server side,

AllegroGraph provides a Prolog and Common Lisp

environment which both are employed for developing

the algorithms of our SAW framework.

Arrange Reasoning Components in a Pipeline.

Employing the described software infrastructure, in

this paragraph we discuss the application of the well-

known software architectural style pipes-and-ﬁlters

(Buschmann et al., 1998) with respect to data stream

processing. In this architectural style (cf. Fig. 1),

processing components—ﬁlters implementing parts

of the three levels of SAW, e. g., a situation asses-

sor supporting comprehension—are arranged in a

consecutive manner by connecting them with pipes

(e. g., implemented using plain method calls or Java

RMI communication), forming altogether a process-

ing pipeline. In such a pipeline, ﬁlters depend only

on the results of their direct predecessors, and hence,

processing of elements in a data stream can be paral-

lelized. Let us discuss the design of these ﬁlters mak-

ing them pluggable components in detail. Each ﬁlter

contains its own volatile, A-box and a pipe connect-

ing the ﬁlter to the A-box(es) of the succeeding ﬁl-

ters(s) (cf. (Baumgartner et al., 2008)). A ﬁlter listens

for updates to this input A-box, computes inferences

upon these updates using a local OWL DL and rule

reasoner, and writes the results into its output A-box

http://www.asﬁnag.at

http://jena.sourceforge.net

http://pellet.owldl.com

http://agraph.franz.com

KEOD 2011 - International Conference on Knowledge Engineering and Ontology Development

410

Situation Assessor

Local A-box

Input Output

OWL-DL

Reasoner

Rule

Reasoner

Core Situation T-box

Situation

Relation

DisrelatedEquals

Domain Mapper

Rule Reasoner

Local A-box

Input

Output

Local A-box

Custom Data

Source Access

Adaptor

Road Maintenance T-box

Roadworks

BridgeWork Mowing

Core Object T-box

Object

Attribute

Lifespan

Location

Pipe

Filter

Data Flow

Legend

subClassOf

object

property

instanceOf

Business Logic Layer

Persistence Layer

Presentation Layer

Figure 1: Components in a pipes-and-ﬁlters architectural

style.

and the referenced succeeding A-box(es). Thereby,

just the A-box statements that are relevant for the fol-

lowing ﬁlter(s) are handed over via pipes, resulting in

mutually shared A-box(es). The individuals in these

shared A-boxes are consistent with the concepts in

a shared T-box: Each ﬁlter deﬁnes the expected in-

put vocabulary (i. e., individuals written to its input

A-box must be consistent with respect to the input

T-box), as well as the output vocabulary it complies

with (i. e., each ﬁlter guarantees to produce only indi-

viduals that are consistent with respect to the output

T-box). As a result, ﬁlters in a processing pipeline can

be arranged in an arbitrary manner, as long as neigh-

boring ﬁlters agree on a shared T-box. In case such an

agreement cannot be established, additional domain

mappers must be inserted between them, which medi-

ate between ﬁlters by mapping the concepts of a pre-

ceding ﬁlter to concepts understood by a succeeding

one.

Preliminary Performance Results. We obtained

preliminary performance test results describing the

performance of the situation assessor component,

since this component is the slowest ﬁlter in our pro-

cessing pipe due to pairwise object comparisons be-

ing performed between all objects in its sliding win-

dow. Note, that in our current prototypical imple-

mentation, sliding windows are only adjusted stati-

cally, while the implementation and evaluation of dy-

namically adjusting sliding windows is part of our

future work. The performance tests were run upon

real-world trafﬁc data recorded centrally for Austrian

highways over a period of four weeks. These data

are reported by multiple heterogeneous sources, com-

prising (i) a roadworks management system that pro-

vides information about scheduled roadworks, trafﬁc

restrictions, and expected trafﬁc jams, (ii) a trafﬁc jam

detection system that reports trafﬁc jams which are

automatically detected, (iii) an incident management

system that provides manually entered trafﬁc-related

incident data, and (iv) a nation-wide broadcasting sta-

tion that provides diverse trafﬁc information, ranging

from incidents and trafﬁc jams to poor driving condi-

tions. The recorded data set used for this evaluation

consists of 28,616 distinct trafﬁc objects, comprising

25,269 trafﬁc jams, 820 road works, 1,803 other ob-

structions, 614 accidents, 46 wrong-way drivers, and

64 severe environmental conditions, such as snow or

ice on the road. Currently, a rather small number of

approximately 250 trafﬁc objects and their associated

information are active at the same time (i. e., should

be part of the statically adjusted sliding window).

The test case design is inﬂuenced mainly by (i)

the number of objects to be compared, i. e., the size

of the sliding window, ranging from 10 to 500 objects

(N10, N50, N100, N500), and (ii) the focus of situa-

tion types: a low focus means that a situation type is

rather general and therefore results in many matches,

whereas a high focus means that a situation type is

very speciﬁc (F1: low focus, F2: high focus). We

measured two performance indicators, being indepen-

dent of the execution environment: (i) the number of

direct object comparisons (CMP), and (ii) the number

of derived relations (REL). Fig. 2 summarizes the test

results. Unsurprisingly, the size of the sliding window

Ch t Titl

100000

Titl

1000

10000

100

1000

CMP

REL

N50 N100 N500 N50 N100 N500

F1 F2

Figure 2: Evaluation test results.

dramatically inﬂuences the performance of the situa-

tion assessor, since it compares objects within its slid-

ing window in a pairwise manner. However, the effect

on runtime performance can be counteracted with cor-

rectly focused situation types (i. e., by conﬁguration

of the situation assessor): low-focused situation types

(cf. F1) lead to a more than tenfold increase of pair-

wise object comparisons compared to F2 (just to give

a runtime estimation, the 184 comparisons of N50 in

F1 take up 16.8 seconds on our test machine—AMD

Athlon 64 3500+ with 1.8 GB RAM).

6 CONCLUSIONS

In this section, we present lessons learned from im-

plementing and evaluating the framework in RTM and

indicate directions for future work.

REASONING ON DATA STREAMS FOR SITUATION AWARENESS

411

Knowledge about Window Size Boundaries makes

issuing Warnings Possible. In order to comply

with real-time constraints for situation assessment

(e. g., report critical situations to human operators

within one minute), during intervals of extensive traf-

ﬁc, such as beginnings of holidays or periods of heavy

snow fall, it may be necessary to reduce the sliding

window size. With knowledge from relation types

used in particular situation rules, however, in such a

case we are at least able to issue warnings to human

operators, bringing to their attentation that particular

types of situations will potentially be missed.

Pipes mediate between Filters with Different Push-

pull Processing Characteristics. Reasoning com-

ponents in an SAW system may exhibit different data

stream processing characteristics, such as pro-actively

pulling information from a pipe (e. g., upon execution

of a user query) or re-actively waiting for the pipe to

push new information into the component (e. g., when

new information is reported by an automated system).

Different kinds of pipes, such as pipes buffering the

results of a preceding ﬁlter for being pulled from it

later, are therefore necessary to bridge between adja-

cent reasoning components with different processing

characteristics. Such buffering pipes may also ﬂatten

data stream peaks, allowing a slower ﬁlter to catch up

with a faster one during intervals of reduced load.

REFERENCES

Allen, J. F. (1983). Maintaining knowledge about temporal

intervals. Communications of the ACM, 26(11):832–

843.

Barbieri, D., Braga, D., Ceri, S., Valle, E. D., and Gross-

niklaus, M. (2010). Stream reasoning: Where we got

so far. In Proc. of 4th Int. Workshop on New Forms

of Reasoning for the Semantic Web: Scalable and Dy-

namic.

Barwise, J. and Perry, J. (1983). Situations and Attitudes.

MIT Press.

Baumgartner, N., Gottesheim, W., Mitsch, S., Retschitzeg-

ger, W., and Schwinger, W. (2010). BeAware!—

situation awareness, the ontology-driven way. Inter-

national Journal of Data and Knowledge Engineer-

ing, 69(11):1181–1193.

Baumgartner, N., Retschitzegger, W., and Schwinger, W.

(2008). A software architecture for ontology-driven

situation awareness. In Proc. of 23rd Annual Symp.

on Applied Computing. ACM.

Bleiholder, J. and Naumann, F. (2008). Data fusion. ACM

Comp. Surveys, 41(1).

Buccella, A., Cechich, A., and Fillottrani, P. (2009).

Ontology-driven geographic information integration:

A survey of current approaches. Computers and Geo-

sciences, 35(4):710–723.

Buschmann, F., Meunier, R., Rohnert, H., Sommerlad,

P., and Stal, M. (1998). Pattern-Oriented Software

Architecture—A System of Patterns. Addison-Wesley.

Dey, A. K. (2000). Providing Architectural Support for

Building Context-Aware Applications. PhD thesis,

Georgia Institute of Technology.

Endsley, M. (2000). Situation Awareness Analysis and Mea-

surement, chapter Theoretical Underpinnings of Sit-

uation Awareness: A Critical Review, pages 3–33.

Lawrence Erlbaum Associates, New Jersey, USA.

Farrell, T., Rothermel, K., and Cheng, R. (2011). Process-

ing Continuous Range Queries with Spatiotemporal

Tolerance. IEEE Transactions on Mobile Computing,

10(3):320–334.

Golab, L. and Ozsu, M. (2003). Issues in data stream man-

agement. SIGMOD Rec., 32(2):5–14.

Hartung, M., Terwilliger, J., and Rahm, E. (2011). Schema

Matching and Mapping, chapter Recent advances in

schema and ontology evolution. Springer.

Kokar, M. M., Matheusb, C. J., and Baclawski, K. (2009).

Ontology-based situation awareness. International

Journal of Information Fusion, 10(1):83–98.

Llinas, J., Bowman, C., Rogova, G., and Steinberg, A.

(2004). Revisiting the JDL data fusion model II. In

Proc. of 7th Int. Conf. on Information Fusion.

Stuckenschmidt, H., Ceri, S., Valle, E. D., and van Harme-

len, F. (2010). Towards Expressive Stream Reasoning.

In Semantic Challenges in Sensor Networks, Dagstuhl

Seminar Proceedings.

Valle, E., Ceri, S., Barbieri, D. F., Braga, D., and Campi,

A. (2009). A ﬁrst step towards stream reasoning. In

Domingue, J., Fensel, D., and Traverso, P., editors,

Future Internet—FIS 2008: Revised Selected Papers.

Springer.

KEOD 2011 - International Conference on Knowledge Engineering and Ontology Development

412