@Test
 public void testMinusInf() throws Exception {
   String input =
       "Prefix(xsd:=<http://www.w3.org/2001/XMLSchema#>)\n"
           + "Prefix(owl:=<http://www.w3.org/2002/07/owl#>)\n"
           + "Prefix(:=<http://test.org/test#>)\n"
           + "Ontology(\nDeclaration(NamedIndividual(:a))\n"
           + "Declaration(DataProperty(:dp))\n"
           + "Declaration(Class(:A))\n"
           + "SubClassOf(:A DataAllValuesFrom(:dp owl:real))"
           + "\nSubClassOf(:A \n"
           + "DataSomeValuesFrom(:dp DataOneOf(\"-INF\"^^xsd:float \"-0\"^^xsd:integer))"
           + "\n)"
           + "\n"
           + "ClassAssertion(:A :a)"
           + "\n)";
   StringDocumentSource in = new StringDocumentSource(input);
   OWLOntologyManager m = Factory.getManager();
   OWLOntology o = m.loadOntologyFromOntologyDocument(in);
   StringDocumentTarget t = new StringDocumentTarget();
   m.saveOntology(o, t);
   assertTrue(t.toString() + " should contain -INF", t.toString().contains("-INF"));
   OWLOntology o1 = m.loadOntologyFromOntologyDocument(new StringDocumentSource(t.toString()));
   assertEquals(
       "Obtologies were supposed to be the same", o.getLogicalAxioms(), o1.getLogicalAxioms());
 }
    @Override
    public void prepare() throws TaskException {
      // load positive and negative deltas via the OWL API
      try {
        OWLOntology additions = loadFromDisk(ADDITION_SUFFIX);
        OWLOntology deletions = loadFromDisk(DELETION_SUFFIX);

        applyToReasoner(additions.getLogicalAxioms(), true);
        applyToReasoner(deletions.getLogicalAxioms(), false);

        measureTime = additions.getLogicalAxiomCount() > 0 && deletions.getLogicalAxiomCount() > 0;

      } catch (OWLOntologyCreationException e) {
        throw new TaskException(e);
      }
    }
Пример #3
0
  private void getPelletIncrementalClassifierRunTime(String baseOnt, String ontDir)
      throws Exception {
    System.out.println("Using Pellet Incremental Classifier...");
    GregorianCalendar start = new GregorianCalendar();
    File ontFile = new File(baseOnt);
    IRI documentIRI = IRI.create(ontFile);
    OWLOntology baseOntology = OWL.manager.loadOntology(documentIRI);
    IncrementalClassifier classifier = new IncrementalClassifier(baseOntology);
    classifier.classify();
    System.out.println("Logical axioms: " + baseOntology.getLogicalAxiomCount());
    System.out.println("Time taken for base ontology (millis): " + Util.getElapsedTime(start));
    File ontDirPath = new File(ontDir);
    File[] allFiles = ontDirPath.listFiles();
    OWLOntologyManager manager = OWLManager.createOWLOntologyManager();
    addTripsBaseOntologies(manager);
    int count = 1;
    for (File owlFile : allFiles) {
      IRI owlDocumentIRI = IRI.create(owlFile);
      OWLOntology ontology = manager.loadOntologyFromOntologyDocument(owlDocumentIRI);
      Set<OWLLogicalAxiom> axioms = ontology.getLogicalAxioms();
      for (OWLLogicalAxiom axiom : axioms)
        OWL.manager.applyChange(new AddAxiom(baseOntology, axiom));

      System.out.println("\nLogical axioms: " + baseOntology.getLogicalAxiomCount());
      System.out.println(count + "  file: " + owlFile.getName());
      //			System.out.println("" + count + "  file: " + owlFile.getName());
      //			GregorianCalendar start2 = new GregorianCalendar();
      classifier.classify();
      //	        System.out.println("Time taken (millis): " +
      //					Util.getElapsedTime(start2));
      manager.removeOntology(ontology);
      count++;
    }
    System.out.println("\nTotal time taken (millis): " + Util.getElapsedTime(start));
  }
 public Integer visit(OWLOntology ontology) {
   int max = _0;
   for (OWLAxiom axiom : ontology.getLogicalAxioms()) {
     int depth = axiom.accept(this);
     if (depth > max) {
       max = depth;
     }
   }
   return max;
 }
Пример #5
0
  private OWLTheory loadTheory(OWLOntology ontology, String ontologyDir, String o1, String o2) {
    OWLTheory theory = getExtendTheory(ontology, false);

    LinkedHashSet<OWLLogicalAxiom> bx = new LinkedHashSet<OWLLogicalAxiom>();
    OWLOntology ontology1 = getOntologySimple(ontologyDir, o1 + ".owl");
    OWLOntology ontology2 = getOntologySimple(ontologyDir, o2 + ".owl");
    Set<OWLLogicalAxiom> onto1Axioms =
        createIntersection(ontology.getLogicalAxioms(), ontology1.getLogicalAxioms());
    Set<OWLLogicalAxiom> onto2Axioms =
        createIntersection(ontology.getLogicalAxioms(), ontology2.getLogicalAxioms());
    int modOnto1Size = onto1Axioms.size();
    int modOnto2Size = onto2Axioms.size();
    int modMappingSize = ontology.getLogicalAxioms().size() - modOnto1Size - modOnto2Size;
    bx.addAll(onto1Axioms);
    bx.addAll(onto2Axioms);
    theory.getKnowledgeBase().addBackgroundFormulas(bx);

    logger.info(
        "ontology axiom sizes: " + modOnto1Size + "," + modOnto2Size + "," + modMappingSize);
    return theory;
  }
Пример #6
0
 private List<Construct> getOrderedConstructs() {
   constructs.clear();
   constructs.add(AL);
   for (OWLOntology ont : ontologies) {
     for (OWLAxiom ax : ont.getLogicalAxioms()) {
       ax.accept(this);
     }
   }
   pruneConstructs();
   List<Construct> cons = new ArrayList<Construct>(constructs);
   Collections.sort(cons, new ConstructComparator());
   return cons;
 }
Пример #7
0
  public void getELKIncrementalRuntime(String baseOnt, String ontDir) throws Exception {
    GregorianCalendar start = new GregorianCalendar();
    OWLOntologyManager manager = OWLManager.createOWLOntologyManager();
    IRI documentIRI = IRI.create(new File(baseOnt));
    OWLOntology baseOntology = manager.loadOntology(documentIRI);
    System.out.println("Logical axioms: " + baseOntology.getLogicalAxiomCount());
    //		findDataHasValueAxiom(baseOntology.getAxioms(AxiomType.SUBCLASS_OF));

    OWLReasonerFactory reasonerFactory = new ElkReasonerFactory();
    OWLReasoner reasoner = reasonerFactory.createReasoner(baseOntology);
    reasoner.precomputeInferences(InferenceType.CLASS_HIERARCHY);
    File[] files = new File(ontDir).listFiles();
    int count = 0;
    OWLOntologyManager manager2 = OWLManager.createOWLOntologyManager();
    addTripsBaseOntologies(manager2);
    for (File file : files) {
      System.out.println("File name: " + file.getName());
      documentIRI = IRI.create(file);
      OWLOntology ontology = manager2.loadOntology(documentIRI);
      Set<OWLLogicalAxiom> axioms = ontology.getLogicalAxioms();
      //	    	findDataHasValueAxiom(ontology.getAxioms(AxiomType.SUBCLASS_OF));
      manager.addAxioms(baseOntology, axioms);
      reasoner.flush();
      System.out.println("Logical axioms: " + baseOntology.getLogicalAxiomCount());

      // From the ELK wiki, it seems ABox reasoning will trigger TBox reasoning
      reasoner.precomputeInferences(InferenceType.CLASS_ASSERTIONS);

      manager2.removeOntology(ontology);
      count++;
      System.out.println("Done with " + count);
      //	    	if(count == 5)
      //	    		break;
    }
    reasoner.dispose();
    System.out.println("Time taken (millis): " + Util.getElapsedTime(start));
  }
Пример #8
0
  public Set<OWLClass> getRootUnsatisfiableClasses() {
    //	    StructureBasedRootClassFinder srd = new StructureBasedRootClassFinder(this.baseReasoner);
    StructuralRootDerivedReasoner srd =
        new StructuralRootDerivedReasoner(this.manager, this.baseReasoner, this.reasonerFactory);
    Set<OWLClass> estimatedRoots = srd.getRootUnsatisfiableClasses();
    this.cls2JustificationMap = new HashMap<OWLClass, Set<Explanation>>();
    Set<OWLAxiom> allAxioms = new HashSet<OWLAxiom>();

    for (OWLOntology ont : this.baseReasoner.getRootOntology().getImportsClosure()) {
      allAxioms.addAll(ont.getLogicalAxioms());
    }

    for (OWLClass cls : estimatedRoots) {
      this.cls2JustificationMap.put(cls, new HashSet<Explanation>());
      System.out.println("POTENTIAL ROOT: " + cls);
    }
    System.out.println("Finding real roots from " + estimatedRoots.size() + " estimated roots");

    int done = 0;
    this.roots.addAll(estimatedRoots);
    for (OWLClass estimatedRoot : estimatedRoots) {
      try {
        PelletExplanationGenerator gen =
            new PelletExplanationGenerator(manager.createOntology(allAxioms));
        OWLDataFactory df = this.manager.getOWLDataFactory();
        Set<Explanation> expls =
            gen.getExplanations(df.getOWLSubClassOfAxiom(estimatedRoot, df.getOWLNothing()));
        cls2JustificationMap.get(estimatedRoot).addAll(expls);
        ++done;
        System.out.println("Done " + done);
      } catch (OWLOntologyCreationException e) {
        e.printStackTrace();
      }
    }
    for (OWLClass clsA : estimatedRoots) {
      for (OWLClass clsB : estimatedRoots)
        if (!clsA.equals(clsB)) {
          Set<Explanation> clsAExpls = cls2JustificationMap.get(clsA);
          Set<Explanation> clsBExpls = cls2JustificationMap.get(clsB);
          boolean clsARootForClsB = false;
          boolean clsBRootForClsA = false;

          for (Explanation clsAExpl : clsAExpls) {
            for (Explanation clsBExpl : clsBExpls)
              if (isRootFor(clsAExpl, clsBExpl)) {
                clsARootForClsB = true;
              } else if (isRootFor(clsBExpl, clsAExpl)) {
                clsBRootForClsA = true;
              }
          }

          Explanation clsAExpl;
          if ((!clsARootForClsB) || (!clsBRootForClsA))
            if (clsARootForClsB) {
              this.roots.remove(clsB);
            } else if (clsBRootForClsA) this.roots.remove(clsA);
        }
    }

    OWLClass clsA;
    return this.roots;
  }