From 9ce65c5a963b03ee97fe9cb6c5aa65a3c04a80a8 Mon Sep 17 00:00:00 2001
From: yzhou <yujiao.zhou@gmail.com>
Date: Tue, 21 Apr 2015 10:34:27 +0100
Subject: initial version

---
 .../pagoda/tracking/TrackingRuleEncoderDisj2.java  | 124 +++++++++++++++++++++
 1 file changed, 124 insertions(+)
 create mode 100644 src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj2.java

(limited to 'src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj2.java')

diff --git a/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj2.java b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj2.java
new file mode 100644
index 0000000..6cf239f
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisj2.java
@@ -0,0 +1,124 @@
+package uk.ac.ox.cs.pagoda.tracking;
+
+import org.semanticweb.HermiT.model.AtLeastConcept;
+import org.semanticweb.HermiT.model.Atom;
+import org.semanticweb.HermiT.model.AtomicConcept;
+import org.semanticweb.HermiT.model.AtomicNegationConcept;
+import org.semanticweb.HermiT.model.AtomicRole;
+import org.semanticweb.HermiT.model.DLClause;
+import org.semanticweb.HermiT.model.DLPredicate;
+import org.semanticweb.HermiT.model.Individual;
+import org.semanticweb.HermiT.model.Inequality;
+import org.semanticweb.HermiT.model.InverseRole;
+import org.semanticweb.HermiT.model.Term;
+import org.semanticweb.HermiT.model.Variable;
+
+import uk.ac.ox.cs.pagoda.MyPrefixes;
+import uk.ac.ox.cs.pagoda.multistage.Normalisation;
+import uk.ac.ox.cs.pagoda.query.QueryRecord;
+import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
+import uk.ac.ox.cs.pagoda.rules.OverApproxExist;
+import uk.ac.ox.cs.pagoda.rules.UpperDatalogProgram;
+
+public class TrackingRuleEncoderDisj2 extends TrackingRuleEncoderDisj {
+
+	public TrackingRuleEncoderDisj2(UpperDatalogProgram program, BasicQueryEngine store) {
+		super(program, store);
+	}
+
+	@Override
+	public boolean encodingRules() {
+		if (ruleEncoded) return false;
+		ruleEncoded = true; 
+		
+		for (DLClause clause: program.getClauses()) {
+			encodingRule(clause);
+		}
+		
+		if (disjunctiveRules.isEmpty())
+			return true;
+		
+		processDisjunctiveRules(); 
+		return false; 
+	}
+	
+	@Override
+	protected DLPredicate generateAuxiliaryRule(AtomicConcept p) {
+		return getTrackingDLPredicate(p); 
+	}
+	
+	@Override
+	protected DLPredicate generateAuxiliaryRule(AtomicRole p) {
+		return getTrackingDLPredicate(p); 
+	}
+
+	private Variable X = Variable.create("X"); 
+	
+	@Override
+	protected DLPredicate generateAuxiliaryRule(AtLeastConcept p, DLClause original, Individual[] individuals) {
+		DLPredicate ret = AtomicConcept.create(getTrackingPredicate(Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p, individuals))); 
+		Atom[] headAtom = new Atom[] {Atom.create(ret, X)};
+		
+		AtomicRole role = p.getOnRole() instanceof AtomicRole ? 
+				(AtomicRole) p.getOnRole(): 
+					((InverseRole) p.getOnRole()).getInverseOf(); 
+			
+		AtomicConcept concept =	p.getToConcept() instanceof AtomicConcept ? 
+				(AtomicConcept) p.getToConcept() : 
+					OverApproxExist.getNegationConcept(((AtomicNegationConcept) p.getToConcept()).getNegatedAtomicConcept());
+						
+		Term[] roleArgs, conceptArg;
+		for (Individual i: individuals) {
+//		Variable i = Variable.create("Y"); 
+			if (p.getOnRole() instanceof AtomicRole) {
+				roleArgs = new Term[] {X, i};
+				conceptArg = new Term[] {i}; 
+			}
+			else {
+				roleArgs = new Term[] {i, X};
+				conceptArg = new Term[] {i}; 
+			}
+				
+			addTrackingClause(
+					DLClause.create(headAtom, 
+							new Atom[] {Atom.create(getTrackingDLPredicate(role), roleArgs)}));
+			
+			Atom guard = Atom.create(role, roleArgs);  
+					
+			if (!concept.equals(AtomicConcept.THING)) {
+				addTrackingClause(
+						DLClause.create(headAtom, 
+								new Atom[] {guard, Atom.create(getTrackingDLPredicate(concept), conceptArg)}));
+			}
+		}
+		
+		return ret;  
+	}
+	
+	@Override
+	protected void encodingRule(DLClause clause) {
+		DLClause original = program.getCorrespondingClause(clause);
+		if (original.getHeadLength() <= 1) {
+			super.encodingRule(clause);
+		}
+		else addDisjunctiveRule(original, clause);
+	}
+	
+	@Override
+	public String getTrackingProgram() {
+		StringBuilder sb = getTrackingProgramBody();
+		sb.insert(0, MyPrefixes.PAGOdAPrefixes.prefixesText()); 
+		return sb.toString(); 
+	}
+
+	@Override
+	protected void encodingAtomicQuery(QueryRecord[] botQuerRecords) {
+		super.encodingAtomicQuery(botQuerRecords, true);
+	}
+
+	@Override
+	protected DLPredicate generateAuxiliaryRule(Inequality instance) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+}
-- 
cgit v1.2.3