1 files changed, 129 insertions, 101 deletions

diff --git a/src/main/scala/uk/ac/ox/cs/rsacomb/RSAOntology.scala b/src/main/scala/uk/ac/ox/cs/rsacomb/RSAOntology.scala
index 52d4905..87a2312 100644
--- a/src/main/scala/uk/ac/ox/cs/rsacomb/RSAOntology.scala
+++ b/src/main/scala/uk/ac/ox/cs/rsacomb/RSAOntology.scala
@@ -54,6 +54,7 @@ import uk.ac.ox.cs.rsacomb.converter._
 import uk.ac.ox.cs.rsacomb.suffix._
 import uk.ac.ox.cs.rsacomb.sparql._
 import uk.ac.ox.cs.rsacomb.util.{RDFoxUtil, RSA}
+import uk.ac.ox.cs.rsacomb.util.Logger
 
 object RSAOntology {
 
@@ -141,87 +142,91 @@ class RSAOntology(val ontology: OWLOntology) {
    *    why the ontology might not be RSA. This could help a second
    *    step of approximation of an Horn-ALCHOIQ to RSA
    */
-  lazy val isRSA: Boolean = {
-
-    val unsafe = this.unsafeRoles
-
-    /* DEBUG: print rules in DL syntax and unsafe roles */
-    //val renderer = new DLSyntaxObjectRenderer()
-    //println("\nDL rules:")
-    //axioms.foreach(x => println(renderer.render(x)))
-    //println("\nUnsafe roles:")
-    //println(unsafe)
-
-    object RSAConverter extends RDFoxConverter {
-
-      override def convert(
-          expr: OWLClassExpression,
-          term: Term,
-          unsafe: List[OWLObjectPropertyExpression],
-          skolem: SkolemStrategy,
-          suffix: RSASuffix
-      ): Shards =
-        (expr, skolem) match {
-
-          case (e: OWLObjectSomeValuesFrom, c: Constant)
-              if unsafe contains e.getProperty => {
-            val (res, ext) = super.convert(e, term, unsafe, skolem, suffix)
-            (RSA.PE(term, c.iri) :: RSA.U(c.iri) :: res, ext)
-          }
-
-          case (e: OWLDataSomeValuesFrom, c: Constant)
-              if unsafe contains e.getProperty => {
-            val (res, ext) = super.convert(e, term, unsafe, skolem, suffix)
-            (RSA.PE(term, c.iri) :: RSA.U(c.iri) :: res, ext)
+  lazy val isRSA: Boolean = Logger.timed(
+    {
+      val unsafe = this.unsafeRoles
+
+      // val renderer = new DLSyntaxObjectRenderer()
+      // println()
+      // println("Unsafe roles:")
+      // println(unsafe)
+      // println()
+      // println("DL rules:")
+      // tbox.foreach(x => println(renderer.render(x)))
+
+      object RSAConverter extends RDFoxConverter {
+
+        override def convert(
+            expr: OWLClassExpression,
+            term: Term,
+            unsafe: List[OWLObjectPropertyExpression],
+            skolem: SkolemStrategy,
+            suffix: RSASuffix
+        ): Shards =
+          (expr, skolem) match {
+
+            case (e: OWLObjectSomeValuesFrom, c: Constant)
+                if unsafe contains e.getProperty => {
+              val (res, ext) = super.convert(e, term, unsafe, skolem, suffix)
+              (RSA.PE(term, c.iri) :: RSA.U(c.iri) :: res, ext)
+            }
+
+            case (e: OWLDataSomeValuesFrom, c: Constant)
+                if unsafe contains e.getProperty => {
+              val (res, ext) = super.convert(e, term, unsafe, skolem, suffix)
+              (RSA.PE(term, c.iri) :: RSA.U(c.iri) :: res, ext)
+            }
+
+            case _ => super.convert(expr, term, unsafe, skolem, suffix)
           }
 
-          case _ => super.convert(expr, term, unsafe, skolem, suffix)
-        }
-
-    }
-
-    /* Ontology convertion into LP rules */
-    val term = RSAOntology.genFreshVariable()
-    val datalog = axioms
-      .map(a => RSAConverter.convert(a, term, unsafe, new Constant(a), Empty))
-      .unzip
-    val facts = datalog._1.flatten
-    val rules = datalog._2.flatten
-
-    /* DEBUG: print datalog rules */
-    //println("\nDatalog rules:")
-    //rules.foreach(println)
-
-    // Open connection with RDFox
-    val (server, data) = RDFoxUtil.openConnection("RSACheck")
-
-    /* Add built-in rules
-     * TODO: substitute with RDFoxUtil.addRules
-     */
-    data.importData(
-      UpdateType.ADDITION,
-      RSA.Prefixes,
-      "rsa:E[?X,?Y] :- rsa:PE[?X,?Y], rsa:U[?X], rsa:U[?Y] ."
-    )
-
-    /* Add ontology facts and rules */
-    RDFoxUtil.addFacts(data, facts)
-    RDFoxUtil.addRules(data, rules)
-
-    /* Build graph */
-    val graph = this.rsaGraph(data);
-    //println(graph)
-
-    // Close connection to RDFox
-    RDFoxUtil.closeConnection(server, data)
+      }
+
+      /* Ontology convertion into LP rules */
+      val term = RSAOntology.genFreshVariable()
+      val datalog = axioms
+        .map(a => RSAConverter.convert(a, term, unsafe, new Constant(a), Empty))
+        .unzip
+      val facts = datalog._1.flatten
+      val rules = datalog._2.flatten
+
+      //println("Datalog rules:")
+      //rules foreach println
+
+      // Open connection with RDFox
+      val (server, data) = RDFoxUtil.openConnection("RSACheck")
+
+      /* Add built-in rules
+       * TODO: substitute with RDFoxUtil.addRules
+       */
+      data.importData(
+        UpdateType.ADDITION,
+        RSA.Prefixes,
+        "rsa:E[?X,?Y] :- rsa:PE[?X,?Y], rsa:U[?X], rsa:U[?Y] ."
+      )
 
-    /* To check if the graph is tree-like we check for acyclicity in a
-     * undirected graph.
-     *
-     * TODO: Implement additional checks (taking into account equality)
-     */
-    graph.isAcyclic
-  }
+      /* Add ontology facts and rules */
+      RDFoxUtil.addFacts(data, facts)
+      RDFoxUtil.addRules(data, rules)
+
+      /* Build graph */
+      val graph = this.rsaGraph(data);
+      //println("Graph:")
+      //println(graph)
+
+      // Close connection to RDFox
+      RDFoxUtil.closeConnection(server, data)
+
+      /* To check if the graph is tree-like we check for acyclicity in a
+       * undirected graph.
+       *
+       * TODO: Implement additional checks (taking into account equality)
+       */
+      graph.isAcyclic
+    },
+    "RSA check",
+    Logger.DEBUG
+  )
 
   lazy val unsafeRoles: List[OWLObjectPropertyExpression] = {
 
@@ -288,9 +293,17 @@ class RSAOntology(val ontology: OWLOntology) {
   }
 
   def filteringProgram(query: ConjunctiveQuery): FilteringProgram =
-    new FilteringProgram(query, individuals)
+    Logger.timed(
+      new FilteringProgram(query, individuals),
+      "Generating filtering program",
+      Logger.DEBUG
+    )
 
-  lazy val canonicalModel = new CanonicalModel(this)
+  lazy val canonicalModel = Logger.timed(
+    new CanonicalModel(this),
+    "Generating canonical model program",
+    Logger.DEBUG
+  )
 
   // TODO: the following functions needs testing
   def confl(
@@ -321,27 +334,42 @@ class RSAOntology(val ontology: OWLOntology) {
     *  @param query query to execute
     *  @return a collection of answers
     */
-  def ask(query: ConjunctiveQuery): ConjunctiveQueryAnswers = {
-    import implicits.JavaCollections._
-    val (server, data) = RDFoxUtil.openConnection(RSAOntology.DataStore)
-    val filter = this.filteringProgram(query)
-    RDFoxUtil.addRules(data, this.canonicalModel.rules)
-    RDFoxUtil.addFacts(data, this.canonicalModel.facts)
-    RDFoxUtil.addRules(data, filter.rules)
-    RDFoxUtil.addFacts(data, filter.facts)
-    val answers = RDFoxUtil
-      .submitQuery(
-        data,
-        RDFoxUtil.buildDescriptionQuery("Ans", query.answer.size),
-        RSA.Prefixes
-      )
-      .map(
-        new ConjunctiveQueryAnswers(query.bcq, _)
-      )
-      .get
-    RDFoxUtil.closeConnection(server, data)
-    answers
-  }
+  def ask(query: ConjunctiveQuery): ConjunctiveQueryAnswers = Logger.timed(
+    {
+      import implicits.JavaCollections._
+      val (server, data) = RDFoxUtil.openConnection(RSAOntology.DataStore)
+      val canon = this.canonicalModel
+      val filter = this.filteringProgram(query)
+
+      Logger print s"Canonical model: ${canon.rules.length} rules"
+      RDFoxUtil.addRules(data, this.canonicalModel.rules)
+
+      Logger print s"Canonical model: ${canon.facts.length} facts"
+      RDFoxUtil.addFacts(data, this.canonicalModel.facts)
+
+      RDFoxUtil printStatisticsFor data
+
+      Logger print s"Filtering program: ${filter.rules.length} rules"
+      RDFoxUtil.addRules(data, filter.rules)
+
+      Logger print s"Filtering program: ${filter.facts.length} facts"
+      RDFoxUtil.addFacts(data, filter.facts)
+
+      RDFoxUtil printStatistics data
+
+      val answers = {
+        val ans = RDFoxUtil.buildDescriptionQuery("Ans", query.answer.size)
+        RDFoxUtil
+          .submitQuery(data, ans, RSA.Prefixes)
+          .map(new ConjunctiveQueryAnswers(query.bcq, query.variables, _))
+          .get
+      }
+      RDFoxUtil.closeConnection(server, data)
+      answers
+    },
+    "Answers computation",
+    Logger.DEBUG
+  )
 
   /** Query the RDFox data store used for query answering.
     *