From 778072331d2d93ef2e3f7800ca300257deb29e65 Mon Sep 17 00:00:00 2001
From: Federico Igne <federico.igne@cs.ox.ac.uk>
Date: Mon, 16 May 2022 19:14:37 +0100
Subject: Make ACQuA query reasoner depend on RSAComb query reasoner

---
 .../ox/cs/acqua/reasoner/AcquaQueryReasoner.scala  | 16 +++---
 .../cs/acqua/reasoner/RSACombQueryReasoner.scala   | 60 +++++++++++++++++-----
 2 files changed, 52 insertions(+), 24 deletions(-)

(limited to 'src/main/scala/uk/ac/ox')

diff --git a/src/main/scala/uk/ac/ox/cs/acqua/reasoner/AcquaQueryReasoner.scala b/src/main/scala/uk/ac/ox/cs/acqua/reasoner/AcquaQueryReasoner.scala
index 0aa5ff2..de6e87c 100644
--- a/src/main/scala/uk/ac/ox/cs/acqua/reasoner/AcquaQueryReasoner.scala
+++ b/src/main/scala/uk/ac/ox/cs/acqua/reasoner/AcquaQueryReasoner.scala
@@ -74,8 +74,8 @@ class AcquaQueryReasoner(val ontology: Ontology)
 
   private val rlLowerStore: BasicQueryEngine = new BasicQueryEngine("rl-lower-bound")
   private val elLowerStore: KarmaQueryEngine = new KarmaQueryEngine("elho-lower-bound")
-  private lazy val lowerRSAOntology = ontology approximate (new Lowerbound)
-  private lazy val upperRSAOntology = ontology approximate (new Upperbound)
+  private lazy val lowerRSAEngine = new RSACombQueryReasoner(ontology, new Lowerbound)
+  private lazy val upperRSAEngine = new RSACombQueryReasoner(ontology, new Upperbound)
 
   private val trackingStore = new MultiStageQueryEngine("tracking", false);
 
@@ -172,8 +172,8 @@ class AcquaQueryReasoner(val ontology: Ontology)
     /* Force computation of lower RSA approximations and its canonical
      * model. We wait to process the upperbound since it might not be
      * necessary after all. */
-    lowerRSAOntology.computeCanonicalModel()
-    //upperRSAOntology.computeCanonicalModel()
+    lowerRSAEngine.preprocess()
+    //upperRSAEngine.preprocess()
 
     true
   }
@@ -387,9 +387,7 @@ class AcquaQueryReasoner(val ontology: Ontology)
     * @returns true if the query is fully answered.
     */
   private def queryRSALowerBound(query: QueryRecord): Boolean = {
-    import uk.ac.ox.cs.acqua.implicits.RSACombAnswerTuples._
-    val answers = lowerRSAOntology ask query
-    query updateLowerBoundAnswers answers
+    lowerRSAEngine evaluate query
     query.isProcessed
   }
 
@@ -399,9 +397,7 @@ class AcquaQueryReasoner(val ontology: Ontology)
     * @returns true if the query is fully answered.
     */
   private def queryRSAUpperBound(query: QueryRecord): Boolean = {
-    import uk.ac.ox.cs.acqua.implicits.RSACombAnswerTuples._
-    val answers = upperRSAOntology ask query
-    query updateUpperBoundAnswers answers
+    upperRSAEngine evaluate query
     query.isProcessed
   }
 
diff --git a/src/main/scala/uk/ac/ox/cs/acqua/reasoner/RSACombQueryReasoner.scala b/src/main/scala/uk/ac/ox/cs/acqua/reasoner/RSACombQueryReasoner.scala
index 6d89b7b..5acc7cd 100644
--- a/src/main/scala/uk/ac/ox/cs/acqua/reasoner/RSACombQueryReasoner.scala
+++ b/src/main/scala/uk/ac/ox/cs/acqua/reasoner/RSACombQueryReasoner.scala
@@ -44,14 +44,15 @@ class RSACombQueryReasoner(
     /* Nothing to do */
   }
 
-  /** Check consistency and returns whether the ontology is RSA.
+  /** Force computation of canonical model for combined approach in RSA.
     *
-    * Preprocessing is performed on instance creation, so no actual work
-    * is being done here.
+    * @returns whether the original ontolgy is RSA.
     *
-    * @note Implemented for compatibility with other reasoners.
+    * @note that it is not necessary to call this method since the
+    * preprocessing is performed "on demand" when evaluating a query.
    */
   def preprocess(): Boolean = {
+    rsa.computeCanonicalModel()
     origin.isRSA
   }
 
@@ -73,12 +74,12 @@ class RSACombQueryReasoner(
     *
     * TODO: perform logging of answers
     */
-  override def evaluate(queries: Collection[QueryRecord]): Unit = {
-    val answers = rsa ask queries
-    /* Perform logging */
-    // Logger write answers
-    // Logger.generateSimulationScripts(datapath, queries)
-  }
+  //override def evaluate(queries: Collection[QueryRecord]): Unit = {
+  //  val answers = rsa ask queries
+  //  /* Perform logging */
+  //  // Logger write answers
+  //  // Logger.generateSimulationScripts(datapath, queries)
+  //}
 
   /** Evaluates a single query.
     *
@@ -88,11 +89,42 @@ class RSACombQueryReasoner(
     * TODO: perform logging of answers
     */
   def evaluate(query: QueryRecord): Unit = {
+    import uk.ac.ox.cs.acqua.implicits.RSACombAnswerTuples._
     val answers = rsa ask query
-    /* Perform logging */
-    // Logger write answers
-    // Logger.generateSimulationScripts(datapath, queries)
+    query updateLowerBoundAnswers answers
+    if (toRSA == Noop) {
+      /* Perform logging
+       * In this case the engine is used as a standalone engine, meaning
+       * that it is time to print out query answers and other related
+       * logging routines.
+       */
+      //Logger write answers
+      //Logger.generateSimulationScripts(datapath, queries)
+    }
   }
 
-  def evaluateUpper(record: QueryRecord): Unit= ???
+  /** Evaluates a single query.
+    *
+    * Uses RSAComb internally to reuse part of the computation of
+    * multiple calls to [[uk.ac.ox.cs.rsacomb.RSAOntology.ask]].
+    *
+    * @note the result of the computation is saved in the "upper bound"
+    * of the input query record.
+    *
+    * TODO: perform logging of answers
+    */
+  def evaluateUpper(query: QueryRecord): Unit = {
+    import uk.ac.ox.cs.acqua.implicits.RSACombAnswerTuples._
+    val answers = rsa ask query
+    query updateUpperBoundAnswers answers
+    if (toRSA == Noop) {
+      /* Perform logging
+       * In this case the engine is used as a standalone engine, meaning
+       * that it is time to print out query answers and other related
+       * logging routines.
+       */
+      //Logger write answers
+      //Logger.generateSimulationScripts(datapath, queries)
+    }
+  }
 }
-- 
cgit v1.2.3