fixed some bugs

3 files changed, 51 insertions, 8 deletions

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<Atom> additionalAtoms = new HashSet<Atom>(); 
                 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<Atom> 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);