if (approximationResult != null) {
System.out.println("Creating Tbox approximation "+runCounter);
OWLOntology abox = null;
OWLOntology approximatedTbox = null;
OWLReasoner reasoner = null;
int newIndividualsToAdd = 0;
/* get the approximated Tbox */
approximatedTbox = approximationResult.approximatedOntology();
if (approximationResult.isOriginal()){
/* Last run. Use original Abox to compute the baseline run */
aboxPhysicalURI = originalAboxURI;
}
/* Load Abox into the manager */
abox = manager.loadOntologyFromPhysicalURI(aboxPhysicalURI);
int aboxIndividualAxiomsCount = abox.getIndividualAxioms().size();
if (measureApproximationTime) {
/* update time with the time it takes to build the Tbox based on the current vocabulary set */
approximationTime = timerApproximation.getTotal();
}
//OWLOntology currentTBox2 = approximationResult.approximatedOntology();
/* Create a new physical URI based on the current run */
URI tboxPhysicalURI = createNewURI(tmpTboxPhysicalURI, runCounter);
if (saveApproximatedTbox){
/* Save approximated Tbox to disk - for debugging purposes only */
saveOntologyToFile(approximatedTbox, tboxPhysicalURI);
}
/* Create the reasoner */
reasoner = reasonerFactory.createReasoner(manager);
logger.info("Using reasoner: "+reasonerFactory.getReasonerName());
Set<OWLOntology> ontologiesToLoad = new HashSet<OWLOntology>();
ontologiesToLoad.add(abox);
ontologiesToLoad.add(approximatedTbox);
/* Load approximated Tbox into the reasoner */
//reasoner.loadOntologies(ontologiesToLoad);
/* Load approximated Tbox into reasoner */
reasoner.loadOntologies(Collections.singleton(approximatedTbox));
/* Print statistics */
printStatistics(runCounter, approximation, approximatedTbox, abox, aboxPhysicalURI);
/* Classify ontology if needed */
double classificationTime = 0;
if ( !(reasoner.isClassified()) ){
logger.info("Classifying KB...");
Timer timerClassify = timers.startTimer( "classification" );
reasoner.classify();
timerClassify.stop();
classificationTime = timerClassify.getTotal();
}
/* Load Abox into reasoner */
reasoner.loadOntologies(Collections.singleton(abox));
/* In each run this variable maps classes to number of instances (direct and indirect) retrieved for that class */
HashMap<OWLClass, Integer> instancesPerClass = new HashMap<OWLClass, Integer>();
/* Maps classes to number of direct instances */
HashMap<OWLClass, Integer> directIndividualsCounts = new HashMap<OWLClass, Integer>();
/* Maps classes to number of indirect instances */
HashMap<OWLClass, Integer> indirectIndividualsCounts = new HashMap<OWLClass, Integer>();
/* Total number of direct instances retrieved (among all classes) in the current run */
int cumulativeDirectInstancesCnt = 0;
/* Total number of indirect instances retrieved (among all classes) in the current run */
int cumulativeIndirectInstancesCnt = 0;
logger.info("Iterating over "+concepts.size()+" atomic concept names (calculated from original tbox)");
/* Retrieve Instances from (T', A) */
for (OWLClass cc : concepts){
/* In each run this variable contains the instances (direct and indirect) retrieved from a given class */
Set<OWLIndividual> individuals = new HashSet<OWLIndividual>();
/* In each run this variable contains the instances (direct) retrieved from a given class */
Set<OWLIndividual> directIndividuals = new HashSet<OWLIndividual>();
/* get all individuals (direct and indirect) of class cc only if the class is defined in the ontology */
if (reasoner.isDefined(cc)){
timers.createTimer("retrieval");
Timer timerRetrieval = timers.startTimer( "retrieval" );
individuals = reasoner.getIndividuals(cc, false);
timerRetrieval.stop();
/* get direct individuals only */
directIndividuals = reasoner.getIndividuals(cc, true);
/* update instance retrieval time */
instanceRetrievalTime += timerRetrieval.getTotal();
if (individuals.size() > 0){
logger.info("");
logger.info("Instance relations found for class "+cc.getURI()+": "+individuals.size()+" (class's retrieval time:"+timerRetrieval.getTotal()+")");
for (OWLIndividual owli : individuals){
logger.info(individualCounter+": "+owli.getURI());
individualCounter++;
}
}
}else{
//System.out.println("Undefined Concept in Tbox: "+cc);
logger.info("Undefined Concept in Tbox: "+cc);
}
/* save the instance relations that were retrieved for the class */
classInstances.put(cc, individuals);
/* Update number of instances (including direct and indirect) of the current class */
instancesPerClass.put(cc, new Integer(individuals.size()));
/* save number of direct and indirect instances of each class */
directIndividualsCounts.put(cc, new Integer(directIndividuals.size()));
indirectIndividualsCounts.put(cc, new Integer(individuals.size()-directIndividuals.size()));
if (isInterruptible){
List<OWLOntologyChange> changesToMake = new Vector<OWLOntologyChange>();
/* Add instances retrieved in the current run to the current Abox */
OWLDataFactory factory = manager.getOWLDataFactory();
timers.createTimer("aboxupdate");
Timer timerAboxUpdate = timers.startTimer("aboxupdate");
for (OWLIndividual ci : individuals){
changesToMake.add(new AddAxiom(abox, factory.getOWLClassAssertionAxiom(ci, cc)));
}
List<OWLOntologyChange> actualChangesMade = manager.applyChanges(changesToMake);
timerAboxUpdate.stop();
newIndividualsToAdd += actualChangesMade.size();
aboxUpdateTime = timerAboxUpdate.getTotal();
}
/* Update total number of direct and indirect instances retrieved in the current run */
cumulativeDirectInstancesCnt += directIndividuals.size();
cumulativeIndirectInstancesCnt += (individuals.size()-directIndividuals.size());
}
time = approximationTime + classificationTime + instanceRetrievalTime + aboxUpdateTime;
/* Save the results of the run */
rr = new RunResult(instancesPerClass, time, approximation.getCurrentVocabularyConceptSize(), approximation.getCurrentVocabularyPropertySize());
rr.setIndirectIndividuals(indirectIndividualsCounts);
rr.setDirectIndividuals(directIndividualsCounts);
rr.setClassificationTime(classificationTime);
rr.setAboxUpdateTime(aboxUpdateTime);
rr.setInstanceRetrievalTime(instanceRetrievalTime);
rr.setApproximationTime(approximationTime);
rr.setInstances(classInstances);
rr.setAxiomRewriteTime(approximationResult.axiomRewriteTime());
rr.setVocabularySelectionTime(approximationResult.selectionTime());
rr.setRunNumber(runCounter);
results.addRun(rr);
if (isInterruptible){
/* Save the modified abox to disk so we can use it in the next iteration */
/* create the logical URI of the new Abox */
URI newAboxURI = createNewURI(abox.getURI().toString(), rr.getRunNumber());
/* create the physical URI of the new Abox */
URI newAboxPhysicalURI = createNewURI(tmpAboxURI, rr.getRunNumber());
/* Set up a mapping, which maps the ontology URI to the physical URI */
SimpleURIMapper mapper = new SimpleURIMapper(newAboxURI, newAboxPhysicalURI);
manager.addURIMapper(mapper);
/* Create a new Abox to store the newly inferred instance relations and the Abox used in the current run */
modifiedAbox = manager.createOntology(newAboxURI);
manager.addAxioms(modifiedAbox, abox.getAxioms());
/* Save the modified Abox */
manager.saveOntology(modifiedAbox, newAboxPhysicalURI);
/* update physical URI of the next Abox to use */
aboxPhysicalURI = newAboxPhysicalURI;
}
logger.info("");
logger.info("#direct instances retrieved in current run: "+cumulativeDirectInstancesCnt);
logger.info("#indirect instances retrieved in current run: "+cumulativeIndirectInstancesCnt);
logger.info("#individual axioms in Abox before adding new axioms (anytime): "+aboxIndividualAxiomsCount);
logger.info("#individual axioms added to the Abox (anytime): "+newIndividualsToAdd);
if (isInterruptible){
logger.info("#individual axioms in Abox after adding new axioms (anytime): "+modifiedAbox.getIndividualAxioms().size());
}
logger.info("Iteration runtime (ms): "+time);
logger.info("Instance Retrieval Time (ms): "+instanceRetrievalTime);
logger.info("Classification Time (ms): "+classificationTime);
logger.info("Approximation Time (includes axiom rewriting and vocabulary selection time) (ms): "+approximationTime);
logger.info("Axiom rewriting Time (ms): "+approximationResult.axiomRewriteTime());
logger.info("Vocabulary selection Time (ms): "+approximationResult.selectionTime());
logger.info("Abox Update Time (for incremental case only) (ms): "+aboxUpdateTime);
logger.info("Iteration runtime (runtime-approximationTime-aboxUpdateTime) (ms): "+(time-approximationTime-aboxUpdateTime));
logger.info("Tbox's Logical URI: "+approximatedTbox.getURI());
logger.info("Abox's Physical URI: "+aboxPhysicalURI);
logger.info("Abox's Logical URI: "+abox.getURI());
logger.info("======================================================");
logger.info("");
/* Remove approximated Tbox and Abox from reasoner */
reasoner.unloadOntologies(Collections.singleton(approximatedTbox));
reasoner.unloadOntologies(Collections.singleton(abox));
reasoner.dispose();
/* Remove Abox from manager */
manager.removeOntology(abox.getURI());
manager = null;
reasoner = null;