ENGINEERING

TIME IN AN ONTOLOGY FOR POWER SYSTEMS

THROUGH THE ASSEMBLING OF MODULAR ONTOLOGIES

Jorge Santos, Lu

ıs Braga

Departamento de Engenharia Inform

atica, Instituto Superior de Engenharia, Porto, Portugal

Anthony G. Cohn

School of Computing, Leeds University, Leeds, U.K.

Keywords:

Power Systems, Ontologies, Knowledge Engineering, Temporal/Spatial Reasoning and Representation.

Abstract:

In this paper we investigate how timeless ontologies such as DFault, an ontology for fault diagnosis in power

transmission networks can be re-engineered to include temporal entities. We propose a methodology, FONTE

(Factorising ONTology Engineering complexity), that allows this complex process to be factored by dividing

the problem into parts: modelling the domain concepts ontology (atemporal and aspatial), modelling or ac-

quiring the temporal and /or spatial ontology, and ﬁnally producing the target ontology by assembling these

modular ontologies via a semi-automated process.

1 INTRODUCTION

In recent years many technologies have been de-

veloped allowing the capture and transmission

(e.g., smart sensors networks and wireless communi-

cations) of information about the state of a wide range

of devices connected to networks scattered over large

geographical areas (e.g., power transmission grids).

The emergence of technology standards lowered the

prices for these devices/technologies and eased its in-

tegration with existing systems. The result is that

the data owners are overloaded with large quantities

of heterogeneous information. One major challenge

therefore consists of developing applications able to

provide end-users with a system overview in a hu-

man readable, relevant and consistent manner, so as

to interpret and manage the system being monitored.

There are at least two issues obstructing this goal: the

information heterogeneity and the requirement for ap-

propriate models for spatial and temporal knowledge

(STK). The modelling of STK in intelligent systems

is a complex process. This work proposes a semi-

automatic method, FONTE (Factorising ONTology

Engineering complexity), based on the assembling of

multiple ontologies in order to obtain the target on-

tology. This method tackles both the above problem-

atic issues: information heterogeneity and modelling

STK. The ﬁrst is addressed through the use of on-

tologies as building blocks, given that ontologies are

shared and common agreed models about a speciﬁc

domain. The second issue is addressed through the

use of a set of rules that drives the process of assem-

bling orthogonal categories, like space and time, in

a semi-automatic way, releasing the knowledge en-

gineer and the experts from the rendering of intri-

cate concepts related to complex theories of time and

space.

2 FONTE METHODOLOGY

In order to illustrate the assembly process two

ontologies will be used as building blocks

for the target ontology, a temporal ontol-

ogy and the timeless domain ontology DFault

(www.dei.isep.ipp.pt/∼jsantos/F2C/DFault) for fault

diagnosis in power transmission networks.

Modular Ontologies. The assembly process can

be used either for the development of ontologies

with time from scratch, or for re-engineering exist-

ing atemporal ontologies in order to include time. For

our case study we have used the time-less DFault on-

tology that captures the main concepts related to the

characterisation of the Portugese National Electricity

Transmission Grid (RNT) (www.ren.pt), and concepts

related to fault diagnosis in power transmission net-

works (previously used to develop the SPARSE sys-

255

Santos J., Braga L. and G. Cohn A. (2010).

ENGINEERING TIME IN AN ONTOLOGY FOR POWER SYSTEMS THROUGH THE ASSEMBLING OF MODULAR ONTOLOGIES.

In Proceedings of the 7th International Conference on Informatics in Control, Automation and Robotics, pages 255-258

DOI: 10.5220/0002952502550258

 SciTePress

tem (Vale et al., 2002)).

The DFault ontology (OWL version)includes 92

classes, 30 properties and 30 restrictions. The hi-

erarchy is divided in four sub hierarchies, with root

concepts: Event, Entity, Local and Object. The Event

class includes the different type of events that may oc-

cur in the electric network, such as breaker tripping or

power lines going out of service. The Entity class in-

cludes the organisations (e.g., suppliers, clients) and

persons involved in the management/exploration of

the network. The Object class is divided into phys-

ical objects, which include the electric network de-

vices and facilities, and abstract objects, which in-

clude the faults diagnosis and messages acquired from

the SCADA (Supervisory Control And Data Acquisi-

tion) system. The Local class represents a hierarchy of

physical locations, which are used to spatially charac-

terise the network devices and facilities.

Tripping

Breaker

Technician Device

hasBreaker

isA

operates

operatedBy

Figure 1: Excerpt of the DFault Ontology.

Fig. 1 presents an excerpt of the DFault ontol-

ogy that was used in order to elucidate the FONTE

method and the Protg plug-in that supports it. A cir-

cuit breaker is an electrical device designed to protect

a circuit from damage caused by an electrical event

such as overload or short circuit. Its basic function is

to detect a fault condition and, by interrupting conti-

nuity (tripping), to immediately discontinue electrical

ﬂow. A circuit breaker can be reset (either manually

or automatically) to resume normal operation.

The temporal ontology used in our case study

(see Fig. 2 for the UML-like depiction of an

excerpt) embodies many concepts such as Instant

or Period found in ‘standard’ ontologies such as

OWL-Time (www.w3.org/TR/owltime/) or SUMO

(www.ontologyportal.org/) and assumes a standard

interpretation, mapping time points and intervals to

real numbers and intervals on the real line respec-

tively. A temporal representation requires the char-

acterisation of time itself and temporal incidence,

which are represented in our temporal ontology by

TemporalEntity and Eventuality, respectively. A fur-

ther notion, TimedThing, which is used during the as-

sembly process, bridges between temporal concepts

and domain concepts .

Temporal Entities. In the temporal ontology we

used for the case study there are two subclasses of

TemporalEntity: Instant and Period. The relations

before, after and equality can hold between Instants,

TimeRoot

TemporalEntity Eventuality TimedThing

Process

startedBy:Event

finishedBy:Event

duringAt:Period

Event

startes:Process

finishesBy:Process

atTime:Instant

Instant

starts:Interval

finishes:Interval

Period

startedBy:Instant

finishedBy:Instant

TimedConcept

TimedRelation

IntervalThing

PeriodThing

Figure 2: Excerpt of the Temporal Ontology.

respectively represented by the symbols:≺, Â, =, al-

lowing an algebra based on points to be deﬁned(Vilain

et al., 1989). It is assumed that the before and after are

strict linear, i.e. irreﬂexive, asymmetric, transitive and

linear. The thirteen binary relations proposed in the

Allen’s interval algebra (Allen, 1983) can be deﬁned

easily from ≺, Â, and =. The starts and ﬁnishes are

relations from TemporalEntity to Instant. Also, there

are no null duration periods and each period is unique.

Processes and Events. There are two subclasses of

Eventuality, Process and Event, in order to be possible

to express continuous and instantaneous eventualities,

respectively. Event has a relation atTime to Instant

while Process has a relation duringAt to Period. The

relations starts and ﬁnishes can be used to state what

can start or ﬁnish a process.

The Assembly Method. FONTE (Santos and Staab,

2003) allows the targeted complex ontology to be

built by factorising concepts into their temporal, spa-

tial and domain (atemporal and aspatial) aspects, and

then assembling the temporally/spatially situated en-

tity from these primitive concepts. This is more sim-

ilar to a Cartesian Product than a union of ontolo-

gies. Each of these component ontologies can be

built/acquired independently, allowing a factorisation

of complexity. The ontologies assembly is performed

through an iterative and interactive process that com-

bines two types of inputs: i) human assembly ac-

tions between the component ontologies; and ii) auto-

matic assembly proposals obtained from semantic and

structural analysis of the ontologies. This process is

propelled by a set of rules and a set of constraints. The

set of rules drives a semi-automatic process proposing

assembly actions; the set of constraints allows to as-

sess which of the generated proposals are valid.

The proposed methodology divides the task of

building a temporalised ontology for power network

control and monitoring into the task of constructing

simpler sub-ontologies which can be built indepen-

dently, factorising the problem complexity. The do-

main concepts ontology DFault (DO) and the tempo-

ral ontology (TO) (both described in the previous sec-

tion) will be used to illustrate the assembly process.

ICINCO 2010 - 7th International Conference on Informatics in Control, Automation and Robotics

256

The methodology hence proposes to obtain the

target ontology (power network control and monitor-

ing with a temporal) through a semi-automatic pro-

cess of assembling. The concept DO.Device.Breaker

will be linked with TO.TemporalEntity, while the

property DO.Device.Breaker.triggering will be linked

with TO.Process. In this way the instances of

DO.Device.Breaker concept will have a time span

of use. Instances of DO.Device.Breaker.triggering

process have a time span in which they occur

and additionally the user will be asked to assem-

ble the events that deﬁne the beginning and end-

ing of this process (e.g., DO.Device.Breaker.opening

and DO.Device.Breaker.closing). After this step,

related concepts, properties and axioms are pro-

posed for assembling, through a cascade process:

e.g. sibling concepts of DO.Device.Breaker such

as DO.Device.Line or DO.Device.Transformer will be

proposed for the assembly process; properties and

axioms related to DO.Device.Breaker.triggering like

. . . .triggering.monophasic or . . . .triggering.triphasic

would be proposed for assembly depending on their

characteristic event sequence.

Protg Plug-in. In order to support the iterative and in-

teractive process used in FONTE, a Protg plug-in was

developed. An assembly task consists of the deﬁni-

tion of the actions to be performed in the target on-

tology after the performance of an assembly action

(e.g., creation of a relation isA between a domain and

a temporal concept). Due to the characteristics of the

platform (Protg), two types of tasks were deﬁned:

Internal Tasks, which allow basic operations to ma-

nipulate the ontologies to be performed (e.g., create,

delete and modify classes or properties), and provide

access to the API functionalities of the Protg platform

in a transparent mode;

External Tasks. (also called assembly rules), which

are procedures written in a pseudo-code language

that includes common program language instructions

(e.g., if, then, else) and special keywords (e.g., do,

propose, check) whose semantics has been previously

provided. In order to facilitate the edition/creation of

these tasks, a speciﬁc tool supported in a graphic in-

terface was developed (see below).

The FONTE plug-in architecture (see Fig. 3) has

different abstraction levels which present several ad-

vantages for the knowledge engineer: i) the knowl-

edge engineer does not need to know the speciﬁcs

of the Protg API to manipulate the ontologies. In

addition, the Internal Tasks provide an abstraction

level between External Tasks and Protg API assur-

ing independency between the External Tasks and the

Protg API version; ii) the External Tasks may be cre-

ated/edited during the execution time and do not re-

quire the alteration of the application and consequent

compilation; iii) Different rules set (stored in distinct

ﬁles) allow different temporal/spatial theories in the

assembly process to be used in a ﬂexible way.

Internal Task

Task

isA

External Task

uses

isA

Protégé API

uses

FONTE plug-in

provides

Rule Editor

create/edit

Figure 3: FONTE plug-in architecture.

The plug-in provides a set of functionalities, such

as: linking concepts of the domain and tempo-

ral/spatial ontology; accepting, rejecting or even de-

laying the execution of a task; and visualising statis-

tics of the assembly process. As depicted in Fig. 4,

the plug-in has two panels for the manipulation of on-

tologies (on the left-hand side) and a list of propos-

als (on the right-hand side). The panel further to the

left contains the domain ontology (DFault, which is

timeless and spaceless); from this panel it is possible

to access the classes and properties hierarchies. The

other panel contains the temporal/spatial ontologies

to be used as construction blocks for the production

of the target ontology. The list of proposals contains

the records of the task instances generated by the sys-

tem. Details of this list are presented below.

To promote the assembly process the knowledge

engineer needs to select the ontologies that will par-

ticipate in the assembly process as well as the ﬁles

containing the assembly rules for each ontology;

these can be selected using the setup window (trig-

gered by the setup button shown in Fig. 4).

All the tasks that are successfully performed (ei-

ther triggered manually by user-driven action or auto-

matically by the structural analysis module) are added

to a list containing the instance tasks historic. Associ-

ated with each task instance proposal there is: a trig-

ger list (the elements that triggered the proposal); the

task weight (an indication of the importance of each

proposal, which inﬂuences the likelhood of proposal

acceptance during the assembly process); and a ques-

tion in natural language (a phrase that summarises

the proposal objective, instantiated with the elements

contained in the instance task).

As the assembly process progresses, more propos-

als are generated. If different concepts happen to pro-

pose the same task instance, all the elements that have

triggered that proposal are included in the trigger list

and the proposal weight is increased.

All the proposed task instances are stored in the

list of proposals, which can be sorted by different

criteria (e.g., id, trigger or weight). The user can

then accept, reject, or even delay for later analysis,

ENGINEERING TIME IN AN ONTOLOGY FOR POWER SYSTEMS THROUGH THE ASSEMBLING OF MODULAR

ONTOLOGIES

257

Figure 4: FONTE plug-in for Protg.

each of the proposals. In order to avoid overload-

ing the knowledge engineer with useless proposals,

rejected proposals are never automatically proposed

again(though they may be manually retrieved).

In addition to the functionalities described above,

the plug-in also provides statistics about the assembly

process (results of the tool performance, including the

initial and current status of the domain ontology, the

number of tasks that has been initiated by the user and

how many proposals have been accepted or rejected).

A facility for saving a sequence of performed tasks

as a script ﬁle is also provided to allow a knowledge

engineer to easily totally or partially repeat a certain

set of tasks.

An application was developed to facilitate the cre-

ation of external ﬁles of rules. This supports the

knowledge engineer through a simple and interactive

graphic interface. The ﬁle management system pro-

vides a graphic visualisation of the rules included in

each ﬁle and offers various functionalities, such as:

sorting the list through different criteria; modifying

the order in which the rules are interpreted during

the assembly process; visualising the rules in XML

or pseudo-code; removing, editing or creating new

assembly rules. The knowledge engineer is alerted

about potential consistency errors (e.g., non declared

variables) or warnings (e.g., to declaring a variable

that is not used).

3 CONCLUSIONS AND FUTURE

WORK

In this paper we discussed the engineering of time in

DFault, an ontology for fault diagnosis in power trans-

mission networks. We proposed FONTE, a method

that supports the engineering of complex ontologies

including temporal and/or spatial knowledge that al-

lows process complexity to be factored by dividing

the problem in parts: modelling the domain concepts

ontology (atemporal and aspatial), modelling or ac-

quiring the temporal and/or spatial ontology, and ﬁ-

nally producing the target ontology by assembling

these modular ontologies through a semi-automated

rule based approach.

A Protg plug-in developed to support method

FONTE, which allows FONTE to be used in an in-

tegrated form in the development of ontologies, was

also described. The FONTE methodology works in-

dependently of the temporal/spatial theory since it

allows different sets of assembly rules to be used

for each speciﬁc theory. A tool to support the cre-

ation/edition of these rule sets was also summarised.

Future work includes: i) evaluating the generic

characteristics of the proposed method with differ-

ent spatial/temporal ontologies (including 4D ontolo-

gies); ii) developing a functionality to predict the im-

pact of the acceptance of a particular proposal; iii) im-

proving the generation of automatic proposals during

the assembly process; (ii) and (iii) may be achieved

through the use of semantic analysis, previously suc-

cessfully used in diverse processes of ontology engi-

neering (e.g., merging, mapping and alignment).

REFERENCES

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

intervals. Communication ACM, 26(11):832–843.

Santos, J. and Staab, S. (2003). FONTE - Factorizing ON-

Tology Engineering complexity. In The 2nd Int. Conf.

on Knowledge Capture (K-Cap’03), pages 146–153.

Vale, Z., Ramos, C., Faria, L., Malheiro, N., Marques,

A., and Rosado, C. (2002). Real-time inference for

knowledge-based applications in power system con-

trol centers. Journal on Systems Analysis Modelling

Simulation (SAMS), Taylor&Francis, 42:961–973.

Vilain, M., Kautz, H., and Beek, P. (1989). Constraint

propagation algorithms: a revised report. Readings

in Qualitative Reasoning about Physical Systems.

ICINCO 2010 - 7th International Conference on Informatics in Control, Automation and Robotics

258