From d71035e6f10b3775191ad134d92f897044a592d8 Mon Sep 17 00:00:00 2001 From: yzhou Date: Fri, 1 May 2015 21:04:30 +0100 Subject: fixed some bugs --- .../ac/ox/cs/pagoda/multistage/Normalisation.java | 45 +++++++++++++++++++--- .../ox/cs/pagoda/tracking/TrackingRuleEncoder.java | 2 + .../tracking/TrackingRuleEncoderDisjVar1.java | 12 +++++- 3 files changed, 51 insertions(+), 8 deletions(-) (limited to 'src/uk/ac') diff --git a/src/uk/ac/ox/cs/pagoda/multistage/Normalisation.java b/src/uk/ac/ox/cs/pagoda/multistage/Normalisation.java index 316e6c2..d68d28e 100644 --- a/src/uk/ac/ox/cs/pagoda/multistage/Normalisation.java +++ b/src/uk/ac/ox/cs/pagoda/multistage/Normalisation.java @@ -3,6 +3,7 @@ package uk.ac.ox.cs.pagoda.multistage; import java.util.Collection; import java.util.HashMap; import java.util.HashSet; +import java.util.Iterator; import java.util.LinkedList; import java.util.Map; import java.util.Set; @@ -15,6 +16,7 @@ import org.semanticweb.HermiT.model.AtomicConcept; import org.semanticweb.HermiT.model.AtomicNegationConcept; import org.semanticweb.HermiT.model.AtomicRole; import org.semanticweb.HermiT.model.Constant; +import org.semanticweb.HermiT.model.ConstantEnumeration; import org.semanticweb.HermiT.model.DLClause; import org.semanticweb.HermiT.model.Individual; import org.semanticweb.HermiT.model.Inequality; @@ -85,6 +87,10 @@ public class Normalisation { } Atom headAtom = clause.getHeadAtom(0); + if (headAtom.getDLPredicate() instanceof AtLeastDataRange) { + m_normClauses.add(clause); + return ; + } AtLeastConcept alc = (AtLeastConcept) headAtom.getDLPredicate(); AtomicConcept ac = getRightAuxiliaryConcept(alc, OverApproxExist.getNewIndividual(clause, 0)); DLClause newClause; @@ -113,20 +119,44 @@ public class Normalisation { } Atom[] newHeadAtoms = new Atom[clause.getHeadLength()]; + Set additionalAtoms = new HashSet(); int index = 0; DLClause newClause; for (Atom headAtom: clause.getHeadAtoms()) { if (headAtom.getDLPredicate() instanceof AtLeast) { - AtLeastConcept alc = toAtLeastConcept((AtLeast) headAtom.getDLPredicate()); - AtomicConcept ac = getRightAuxiliaryConcept(alc, OverApproxExist.getNewIndividual(clause, 0)); - newHeadAtoms[index] = Atom.create(ac, headAtom.getArgument(0)); - m_normClauses.add(newClause = DLClause.create(new Atom[] {Atom.create(alc, headAtom.getArgument(0))}, new Atom[] {newHeadAtoms[index]})); - exist2original.put(newClause, clause); + AtLeast al = (AtLeast) headAtom.getDLPredicate(); + if (al instanceof AtLeastDataRange && ((AtLeastDataRange) al).getToDataRange() instanceof ConstantEnumeration) { + ConstantEnumeration ldr = (ConstantEnumeration) ((AtLeastDataRange) al).getToDataRange(); + newHeadAtoms[index] = null; + Atom newHeadAtom; + for (int i = 0; i < ldr.getNumberOfConstants(); ++i) { + newHeadAtom = Atom.create(AtomicRole.create(((AtomicRole) ((AtLeastDataRange) al).getOnRole()).getIRI()), headAtom.getArgument(0), ldr.getConstant(i)); + if (newHeadAtoms[index] == null) newHeadAtoms[index] = newHeadAtom; + else additionalAtoms.add(newHeadAtom); + } + } else { + AtLeastConcept alc = toAtLeastConcept((AtLeast) headAtom.getDLPredicate()); + AtomicConcept ac = getRightAuxiliaryConcept(alc, OverApproxExist.getNewIndividual(clause, 0)); + newHeadAtoms[index] = Atom.create(ac, headAtom.getArgument(0)); + m_normClauses.add(newClause = DLClause.create(new Atom[] {Atom.create(alc, headAtom.getArgument(0))}, new Atom[] {newHeadAtoms[index]})); + exist2original.put(newClause, clause); + } } else newHeadAtoms[index] = headAtom; ++index; } + + if (!additionalAtoms.isEmpty()) { + Atom[] tempHeadAtoms = newHeadAtoms; + newHeadAtoms = new Atom[newHeadAtoms.length + additionalAtoms.size()]; + for (int i = 0; i < tempHeadAtoms.length; ++i) + newHeadAtoms[i] = tempHeadAtoms[i]; + int tempI = tempHeadAtoms.length; + for (Iterator iter = additionalAtoms.iterator(); iter.hasNext(); ) + newHeadAtoms[tempI++] = iter.next(); + additionalAtoms.clear(); + } m_normClauses.add(newClause = DLClause.create(newHeadAtoms, clause.getBodyAtoms())); } @@ -313,7 +343,10 @@ public class Normalisation { if (individuals.length > 1) builder.append("_").append(getName(individuals[0].getIRI())); - builder.append("_exist"); + builder.append("_exist"); + + if (builder.toString().contains("Lens_mount_")) + System.out.println(builder.toString()); return builder.toString(); } diff --git a/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoder.java b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoder.java index 3a01e19..f3cc937 100644 --- a/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoder.java +++ b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoder.java @@ -239,6 +239,8 @@ public abstract class TrackingRuleEncoder { return AtomicRole.create(Namespace.EQUALITY + suffix); else if (p instanceof Inequality) return AtomicRole.create(Namespace.INEQUALITY + suffix); + else if (p instanceof DatatypeRestriction) + return AtomicConcept.create(((DatatypeRestriction) p).getDatatypeURI() + suffix); else { Utility.logDebug("strange DL predicate appeared ... " + p, "the program paused here in TrackingRuleEncoderDisj.java"); diff --git a/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar1.java b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar1.java index 8998051..0d6b0c6 100644 --- a/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar1.java +++ b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar1.java @@ -14,6 +14,7 @@ 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.DatatypeRestriction; import org.semanticweb.HermiT.model.Equality; import org.semanticweb.HermiT.model.Inequality; import org.semanticweb.HermiT.model.InverseRole; @@ -26,6 +27,7 @@ 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; import uk.ac.ox.cs.pagoda.util.Namespace; +import uk.ac.ox.cs.pagoda.util.Utility; public class TrackingRuleEncoderDisjVar1 extends TrackingRuleEncoderWithGap { @@ -119,7 +121,9 @@ public class TrackingRuleEncoderDisjVar1 extends TrackingRuleEncoderWithGap { return Atom.create(getGapDLPredicate(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1)); if (p instanceof Inequality) return Atom.create(getGapDLPredicate((Inequality) p), headAtom.getArgument(0), headAtom.getArgument(1)); - + if (p instanceof DatatypeRestriction) + return Atom.create(getGapDLPredicate((DatatypeRestriction) p), headAtom.getArgument(0)); + Utility.logError(p + " is not recognised."); return null; } @@ -423,7 +427,11 @@ public class TrackingRuleEncoderDisjVar1 extends TrackingRuleEncoderWithGap { for (int i = 0; i < clause.getBodyLength(); ++i) newBodyAtoms[index++] = selectBodyAtoms[selectIndex++] = clause.getBodyAtom(i); - + + for (int i = 0; i < newBodyAtoms.length; ++i) + if (newBodyAtoms[i] == null) { + System.out.println(clause); + } for (Atom atom: newHeadAtoms) { newClause = DLClause.create(new Atom[] {atom}, newBodyAtoms); trackingClauses.add(newClause); -- cgit v1.2.3