comparison src/org/qmul/eecs/c4dm/sia/SiaTecMain.java @ 44:d1fed3d54a82

organised imports

changed various public/private static final Strings

no longer uses Pellet - now uses a basic jena ontology model

reads/writes model to/from an external TDB dataset instead of flat files

performs sparql updates (inserts) when creating the vector table instead of sparql constructs followed by adding new triples to the model

removed unnecessary sparql select and ask queries

the whole procedure is now timed

in printSetOfTranslators, now uses compareToIgnoreDatapoints instead of compareTo

 package org.qmul.eecs.c4dm.sia;
 
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-import org.mindswap.pellet.jena.PelletReasonerFactory;
 import org.qmul.eecs.c4dm.sia.exceptions.DimensionException;
 import org.qmul.eecs.c4dm.sia.model.Datapoint;
 import org.qmul.eecs.c4dm.sia.model.NDimensionalObject;
 import org.qmul.eecs.c4dm.sia.model.SiatecX;
 import org.qmul.eecs.c4dm.sia.model.VectorTable;
 import org.qmul.eecs.c4dm.sia.model.VectorTableElement;
-import org.qmul.eecs.c4dm.sia.rdf.Namespaces;
 import org.qmul.eecs.c4dm.sia.utilities.Display;
-import org.qmul.eecs.c4dm.sparql.utilities.SparqlWrapperMethods;
 
 import com.hp.hpl.jena.ontology.OntModel;
+import com.hp.hpl.jena.ontology.OntModelSpec;
+import com.hp.hpl.jena.query.Dataset;
+import com.hp.hpl.jena.query.ReadWrite;
 import com.hp.hpl.jena.rdf.model.Model;
 import com.hp.hpl.jena.rdf.model.ModelFactory;
+import com.hp.hpl.jena.tdb.TDBFactory;
+import com.hp.hpl.jena.update.UpdateAction;
 
 /**
  * <p>
  * Title: SiaTecMain
  * </p>

  * 
  * @author Steve Hargreaves, C4DM, Queen Mary University of London
  */
 public class SiaTecMain {
 
-	// The ontology loaded as dataset
-	private static final String ontology = "file:src/rdf/siaDatapointOntology.n3";
-
-	// The final output file
-	private static final String finalModelFileName = "src/rdf/finalSiaTecModel";
-
-	// SPARQL queries
-	private static final String[] selectQueries = new String[] {
-		// A SPARQL-DL query
-		"file:src/sparql/select_all.sparql"
-		};
-
-	// CONSTRUCT queries
-	private static final String[] constructQueries = new String[] {
-		// SPARQL-DL CONSTRUCT queries
-		"file:src/sparql/construct_siatec_vector_table_bnodes.sparql",
-		"file:src/sparql/construct_vector_table_details.sparql" };
-
-	// ASK queries
-	private static final String[] askQueries = new String[] {
-		// A SPARQL-DL ASK query
-		};
-	
+	// UPDATE queries
+	private static final String insertSiatecVectorTableBNodesQuery = "file:src/sparql/insert_siatec_vector_table_bnodes.sparql";
+	private static final String insertVectorTableDetailsQuery = "file:src/sparql/insert_vector_table_details.sparql";
+
 	public void run() {
 
-		// First create a Jena ontology model backed by the Pellet reasoner
-		// (note, the Pellet reasoner is required)
-		OntModel ontModel = ModelFactory
-				.createOntologyModel(PelletReasonerFactory.THE_SPEC);
-
-		// Then read the data from the file into the ontology model
-		ontModel.read(ontology, "N3");
-		
-		// Set the value of SIA_NS_URI as the namespace for 'sia' found in
-		// the ontology
-		Namespaces.SIA_NS_URI = ontModel.getNsPrefixURI("sia");
+		// Obtain a dataset context
+		Dataset dataset = TDBFactory.assembleDataset(SiaMain.assemblerFile);
+
+		// Get the sia graph, as a model, from the dataset
+		Model siaModel = dataset.getNamedModel(SiaMain.graph);
+		
+		OntModel ontModel = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM, siaModel);
 
 		// Create custom sia Datapoint objects
 		List<Datapoint> datapoints = SiaDatapointFactory.create(ontModel);
 		
 		// STEP 1 - Order the datapoints
 		Collections.sort(datapoints);
 
 		// Add datapoint order info to model
 		SiaDatapointFactory.assertOrder(ontModel, datapoints);
 		
-		// STEP 2 - Compute the vector table W, and sort
-		// Run all the CONSTRUCT queries
-		for (int i = 0; i < constructQueries.length; i++) {
-			String constructQuery = constructQueries[i];
-
-			Model newModel = SparqlWrapperMethods.executeConstructQuery(constructQuery, ontModel);
-
-			// Add new triples to the current model
-			ontModel.add(newModel);
-		}
+        // STEP 2 - Compute the vector table
+		// Run all the UPDATE queries
+    	UpdateAction.readExecute(insertSiatecVectorTableBNodesQuery, ontModel);
+    	UpdateAction.readExecute(insertVectorTableDetailsQuery, ontModel);
+				
 		VectorTable vectorTableW = SiaVectorTableElementFactory.createW(ontModel, datapoints);
 
 		// STEP 3 - Create custom SIATEC VectorTableElement objects (V)
 		VectorTable vectorTableV = SiaVectorTableElementFactory.createV(ontModel, datapoints);
 		List<VectorTableElement> vteListV = vectorTableV.getVteList();

 			iq.setQ(q);
 			x.add(iq);
 			i = j;
 		}
 		
-		System.out.println("X");
-		printX(x);
-
 		// Sort the elements of x
 		Collections.sort(x);
 		
 		// Rename as y to match algorithm description in paper
 		ArrayList<SiatecX> y = (ArrayList<SiatecX>) x.clone();
-		
-		System.out.println("\nY = Sorted X");
-		printX(y);
 		
 		// Display results using algorithm figures 23, 24 and 25 of the research paper
 		int r = y.size();
 		m = vteListV.size();
 		i = 0;

 		{
 			do
 			{
 				int j = y.get(i).getI() - 1;
 				List<Integer> iList = new ArrayList<Integer>();
-				while (j < m && (vteListV.get(j).getVector().compareTo(vteListV.get(y.get(i).getI() - 1).getVector()) == 0))
+				while (j < m && (vteListV.get(j).compareToIgnoreDatapoints(vteListV.get(y.get(i).getI() - 1)) == 0))
 				{
 					iList.add(vteListV.get(j).getFromDatapoint().getOrderedIndex());					
 					j++;
 				}
 				System.out.print("<");

 				}
 			} while (i < r);
 		}
 		System.out.println("}");
 
-		// Run all the SELECT queries
-		for (i = 0; i < selectQueries.length; i++) {
-
-			String selectQuery = selectQueries[i];
-			SparqlWrapperMethods.queryTheModel(selectQuery, ontModel);
-
-		}
-
-		// Run all the ASK queries
-		for (i = 0; i < askQueries.length; i++) {
-
-			String askQuery = askQueries[i];
-			SparqlWrapperMethods.askTheModel(askQuery, ontModel);
-
-		}
-
-		// Write the model to a file
-		File outFileRdf = new File(finalModelFileName + ".rdf");
-		File outFileN3 = new File(finalModelFileName + ".n3");
-		FileOutputStream outFileOutputStreamRdf;
-		FileOutputStream outFileOutputStreamN3;
-
-		// RDF/XML version
-		try {
-			outFileOutputStreamRdf = new FileOutputStream(outFileRdf);
-			ontModel.writeAll(outFileOutputStreamRdf, "RDF/XML", null);
-		} catch (FileNotFoundException e) {
-			System.out.println("Unable to write to file: "
-					+ outFileRdf.getAbsolutePath());
-			e.printStackTrace();
-			System.exit(1);
-		}
-
-		// N3 version
-		try {
-			outFileOutputStreamN3 = new FileOutputStream(outFileN3);
-			ontModel.writeAll(outFileOutputStreamN3, "N3", null);
-		} catch (FileNotFoundException e) {
-			System.out.println("Unable to write to file: "
-					+ outFileN3.getAbsolutePath());
-			e.printStackTrace();
-			System.exit(1);
-		}
-
-		System.out.println("Model written to files: "
-				+ outFileRdf.getAbsolutePath() + " and " + outFileN3.getAbsolutePath());
+		// Write the model to the TDB dataset
+        dataset.begin(ReadWrite.WRITE) ;
+        try {
+        	dataset.replaceNamedModel(SiaMain.graph, ontModel);
+        	dataset.commit();
+        	System.out.println("dataset.commit() done");
+        } finally {
+        	dataset.end();
+        	System.out.println("dataset.end() done");
+        }
+
+		dataset.close();
+    	System.out.println("dataset.close() done");
+		
+    	System.out.println("Number of Datapoints (n) = " + 		datapoints.size() + ", k = 3");
 	}
 
 	private void printSetOfTranslators(List<Integer> iList, List<Datapoint> datapoints, VectorTable vectorTableW) {
 		int p = iList.size();
 		int n = datapoints.size();

 				{
 					jList.set(k, jList.get(k - 1) + 1);
 				}
 				
 				while (jList.get(k) <= (n - p + k + 1)
-						&& (vectorTableW.getVector(iList.get(k), jList.get(k)).compareTo(vectorTableW.getVector(iList.get(k - 1), jList.get(k - 1))) < 0))
+						&& (((VectorTableElement)vectorTableW.getVector(iList.get(k), jList.get(k))).compareToIgnoreDatapoints(((VectorTableElement)vectorTableW.getVector(iList.get(k - 1), jList.get(k - 1)))) < 0))
 				{
 					jList.set(k, jList.get(k) + 1);
 				}
 				
 				if (jList.get(k) > n - p + k + 1)
 				{
 					finished = true;
 				}
-				else if (vectorTableW.getVector(iList.get(k), jList.get(k)).compareTo(vectorTableW.getVector(iList.get(k - 1), jList.get(k - 1))) > 0)
+				else if (((VectorTableElement)vectorTableW.getVector(iList.get(k), jList.get(k))).compareToIgnoreDatapoints(((VectorTableElement)vectorTableW.getVector(iList.get(k - 1), jList.get(k - 1)))) > 0)
 				{
 					k = 1;
 					jList.set(0, jList.get(0) + 1);
 					if (jList.get(0) > n - p + 1)
 					{

 
 	/**
 	 * @param args
 	 */
 	public static void main(String[] args) {
+		long startTime = System.currentTimeMillis();
 		SiaTecMain app = new SiaTecMain();
 		app.run();
+		long endTime = System.currentTimeMillis();
+		long elapsedTime = endTime - startTime;
+		System.out.println("Completed in " + elapsedTime + " ms");
 	}
 
 }