NEMO Technical Document 2012-05011-1
Nathan Dunn
NEMO Portal Ontology Integration
Created: 5/11/2012
Last Updated: 5/14/2012 (ND)
1. INTRODUCTION
Goals
This is a proposal for improvements to NEMO. Aims are split into short (~2 months) and long (~2 year).
1. Access RDF files and run the queries/reasoning through web-based GUI.
2. Store both RDF contents and classification results in database in such a way that data can later be
queried.
3. Integrate the toolkit within the web Portal such that ERF’s can be submitted directly to the Portal
and processed without direct interaction with Matlab.
4. Enhance query engine performance.
Aims 1 and 2 are both to be done in the short-term with an estimated timeframe of 2 months with a
0.3 FTE.
Aim 3 is a longer-term goal that integrates the Portal with the Matlab backend. This will be a 1-2 year
project and is not feature complete. Aim 4 may possibly be resolved in course of one of the other
aims.
1
2. Short-Term Goals
To meet short-term goals, we will create another server that will be built upon an ontology framework,
most likely OWL. It will pull RDF’s from the Portal (or have them pushed to it) (4). As it is built upon a
common framework, we can run a pre-built reasoner over the ontology tree. Those should be
integrated to the Portal via web services (5) in order to create a seamless interface. Clients can then
query the Ontology Server (6) directly. To the client, this should appear to be the same server as the
Portal and return a result from the reasoner that can be downloaded.
I would suggest implementing the Ontology Server in Roo or Grails, which are both rapid application
development (RAD) Java platforms and most of the ontology reasoner libraries are written in Java.
Other possible design decisions:
1 – querying (6) could be done directly through the Portal, using exposed REST web services in the
Ontology Server. However, if we decide to provide a richer front-end, such as GWT, it would be easier
to do so in the server directly, which is already Java.
New Work
(3) Dump RDF into
Database
Toolkit
(Matlab)
(4) Synchronize Raw RDF's
Portal
(Ruby + DB)
(1) Push ERP's to portal
(5) web services
integrate
Ontology
Server
(6) Query Server using (5)
(2) Push ERP's to tookit
External Clients
2
Short-term Estimates:
 Create a development version of the Portal with a valid database dump (1-3 days) Create OWL
server:
o Stub server and integrate with OWL (2-5 days)
o Create accessible web services:
 Push RDF’s (2-4 days)
 Query / Download RDF’s (2-4 days)
 Reason RDF’s (2-4 days)
o Create simple view interface for RDF (1 week)
o Create query engine interface (1-2 weeks)
 Portal changes:
o Integrate download with web services (if necessary) (2-3 days)
o Create web service for having Ontology Server pull content from portal on startup (2-4
days)
4.5-8.5 weeks ~1-2 months at 1.0 FTE
~ 2.5-5.3 months at 0.3 FTE
3
3. Long-term Goals
Assumes the completion of the short-term goals. The long-term goal is to eliminate the need for users
to download and run the Matlab Toolkit separately. In this step, the Matlab Toolkit is hid behind the
Portal, which accepts submitted ERF data (1), processes it, storing it locally, and sending it to the
Toolkit (2) to create RDF’s. The Toolkit then pushes the processed RDF’s to the Portal (3) to be stored
in the database. The Portal then synchronizes with the Ontology Server (4) via an exposed web service.
At this point, processing is done and external clients can query the Portal, which uses a web service to
query the Ontology Server.
An important piece of this work is that the Portal should be rewritten in Java since most of the major
reasoner’s and API’s are also written in Java. Additionally, the integration opportunities with Matlab
are far greater with Java then with Ruby.
Other possible design decisions:
 The Portal could launch Toolkit instances on-demand in the cloud
 Querying (6) could be done directly on the Ontology Sever as in the short-term goals
 If the memory footprint is sufficiently small, the Ontology Server could be integrated into the
Portal
 Once converted into Java, the provenance pieces can easily be added, as well. This piece
integrates with GWT in order to provide a richer application and faster workflow
New Work
Toolkit
(Matlab)
(3) Push RDF into
Database
(2) Launch Toolkit
with ERP's
(4) synchronize server
Ontology
Server
Portal
(Java + DB)
(5) web services
integrate
(6) Query Server via (5)
(1) Push ERP
External Clients
4
Long-term Estimates:
 Convert Portal to Java (8-20 weeks)
 Integrate Toolkit with Portal:
o Allow Portal to automate Matlab Toolkit spawning (2 weeks)
o Modify Toolkit to Dump RDF back into Portal (1 week)
 Add Provenance:
o Integrate GWT with Portal (1 week)
o Update schema to reflect Provenance requirements (2 weeks)
o Update interface for Provenance requirements (4 weeks)
Some estimates include requirement gathering and architecture changes.
18-38 weeks ~4-9 months at 1.0 FTE
13 – 30 months at 0.3 FTE
5