From 9ce65c5a963b03ee97fe9cb6c5aa65a3c04a80a8 Mon Sep 17 00:00:00 2001 From: yzhou Date: Tue, 21 Apr 2015 10:34:27 +0100 Subject: initial version --- .../ac/ox/cs/pagoda/reasoner/MyQueryReasoner.java | 331 +++++++++++++++++++++ 1 file changed, 331 insertions(+) create mode 100644 src/uk/ac/ox/cs/pagoda/reasoner/MyQueryReasoner.java (limited to 'src/uk/ac/ox/cs/pagoda/reasoner/MyQueryReasoner.java') diff --git a/src/uk/ac/ox/cs/pagoda/reasoner/MyQueryReasoner.java b/src/uk/ac/ox/cs/pagoda/reasoner/MyQueryReasoner.java new file mode 100644 index 0000000..2c2feae --- /dev/null +++ b/src/uk/ac/ox/cs/pagoda/reasoner/MyQueryReasoner.java @@ -0,0 +1,331 @@ +package uk.ac.ox.cs.pagoda.reasoner; + +import java.util.Collection; + +import org.semanticweb.karma2.profile.ELHOProfile; +import org.semanticweb.owlapi.model.OWLOntology; + +import uk.ac.ox.cs.pagoda.multistage.*; +import uk.ac.ox.cs.pagoda.owl.EqualitiesEliminator; +import uk.ac.ox.cs.pagoda.owl.OWLHelper; +import uk.ac.ox.cs.pagoda.query.*; +import uk.ac.ox.cs.pagoda.query.QueryRecord.Step; +import uk.ac.ox.cs.pagoda.reasoner.full.Checker; +import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine; +import uk.ac.ox.cs.pagoda.reasoner.light.KarmaQueryEngine; +import uk.ac.ox.cs.pagoda.rules.DatalogProgram; +import uk.ac.ox.cs.pagoda.summary.HermitSummaryFilter; +import uk.ac.ox.cs.pagoda.tracking.*; +import uk.ac.ox.cs.pagoda.util.Timer; +import uk.ac.ox.cs.pagoda.util.Utility; + +public class MyQueryReasoner extends QueryReasoner { + + OWLOntology ontology; + +// String additonalDataFile; + + DatalogProgram program; + + BasicQueryEngine rlLowerStore = null; + BasicQueryEngine lazyUpperStore = null; +// boolean[] namedIndividuals_lazyUpper; + + OWLOntology elho_ontology; + KarmaQueryEngine elLowerStore = null; + + BasicQueryEngine trackingStore = null; +// boolean[] namedIndividuals_tracking; + + boolean equalityTag; + boolean multiStageTag; + + public MyQueryReasoner() { + setup(true, true); + } + + public MyQueryReasoner(boolean multiStageTag, boolean considerEqualities) { + setup(multiStageTag, considerEqualities); + } + + private BasicQueryEngine getUpperStore(String name, boolean checkValidity) { + if (multiStageTag) + return new MultiStageQueryEngine(name, checkValidity); +// return new TwoStageQueryEngine(name, checkValidity); + else + return new BasicQueryEngine(name); + } + + public void setup(boolean multiStageTag, boolean considerEqualities) { + satisfiable = null; + this.multiStageTag = multiStageTag; + this.equalityTag = considerEqualities; + + rlLowerStore = new BasicQueryEngine("rl-lower-bound"); + elLowerStore = new KarmaQueryEngine("elho-lower-bound"); + + trackingStore = getUpperStore("tracking", false); + } + + protected void internal_importDataFile(String name, String datafile) { +// addDataFile(datafile); + rlLowerStore.importRDFData(name, datafile); + if (lazyUpperStore != null) + lazyUpperStore.importRDFData(name, datafile); + elLowerStore.importRDFData(name, datafile); + trackingStore.importRDFData(name, datafile); + } + + @Override + public void loadOntology(OWLOntology o) { + if (!equalityTag) { + EqualitiesEliminator eliminator = new EqualitiesEliminator(o); + o = eliminator.getOutputOntology(); + eliminator.save(); + } + + ontology = o; + program = new DatalogProgram(ontology, !forSemFacet); +// program.getLower().save(); +// program.getUpper().save(); +// program.getGeneral().save(); + + if (multiStageTag && !program.getGeneral().isHorn()) { + lazyUpperStore = getUpperStore("lazy-upper-bound", true); // new MultiStageQueryEngine("lazy-upper-bound", true); // + } + + importData(program.getAdditionalDataFile()); + + elho_ontology = new ELHOProfile().getFragment(ontology); + elLowerStore.processOntology(elho_ontology); + } + + private Collection predicatesWithGap = null; + + public Collection getPredicatesWithGap() { + return predicatesWithGap; + } + + @Override + public boolean preprocess() { + t.reset(); + Utility.logInfo("Preprocessing ... checking satisfiability ... "); + + String name = "data", datafile = importedData.toString(); + rlLowerStore.importRDFData(name, datafile); + rlLowerStore.materialise("lower program", program.getLower().toString()); +// program.getLower().save(); + if (!consistency.checkRLLowerBound()) return false; + Utility.logInfo("The number of sameAs assertions in RL lower store: " + rlLowerStore.getSameAsNumber()); + + String originalMarkProgram = OWLHelper.getOriginalMarkProgram(ontology); + + elLowerStore.importRDFData(name, datafile); + elLowerStore.materialise("saturate named individuals", originalMarkProgram); + elLowerStore.materialise("lower program", program.getLower().toString()); + elLowerStore.initialiseKarma(); + if (!consistency.checkELLowerBound()) return false; + + if (lazyUpperStore != null) { + lazyUpperStore.importRDFData(name, datafile); + lazyUpperStore.materialise("saturate named individuals", originalMarkProgram); + int tag = lazyUpperStore.materialiseRestrictedly(program, null); + if (tag != 1) { + lazyUpperStore.dispose(); + lazyUpperStore = null; + } + if (tag == -1) return false; + } + if (consistency.checkLazyUpper()) { + satisfiable = true; + Utility.logInfo("time for satisfiability checking: " + t.duration()); + } + + trackingStore.importRDFData(name, datafile); + trackingStore.materialise("saturate named individuals", originalMarkProgram); + +// materialiseFullUpper(); + GapByStore4ID gap = new GapByStore4ID(trackingStore); + trackingStore.materialiseFoldedly(program, gap); + predicatesWithGap = gap.getPredicatesWithGap(); + gap.clear(); + + if (program.getGeneral().isHorn()) + encoder = new TrackingRuleEncoderWithGap(program.getUpper(), trackingStore); + else + encoder = new TrackingRuleEncoderDisjVar1(program.getUpper(), trackingStore); +// encoder = new TrackingRuleEncoderDisj1(program.getUpper(), trackingStore); +// encoder = new TrackingRuleEncoderDisjVar2(program.getUpper(), trackingStore); +// encoder = new TrackingRuleEncoderDisj2(program.getUpper(), trackingStore); + + program.deleteABoxTurtleFile(); + + if (!isConsistent()) + return false; + + consistency.extractBottomFragment(); + return true; + } + + private Boolean satisfiable; + private ConsistencyManager consistency = new ConsistencyManager(this); + + TrackingRuleEncoder encoder; + + @Override + public boolean isConsistent() { + if (satisfiable == null) { + satisfiable = consistency.check(); + Utility.logInfo("time for satisfiability checking: " + t.duration()); + } + return satisfiable; + } + + Timer t = new Timer(); + + private OWLOntology relevantPart(QueryRecord queryRecord) { + AnswerTuples rlAnswer = null, elAnswer = null; + + t.reset(); + try { + rlAnswer = rlLowerStore.evaluate(queryRecord.getQueryText(), queryRecord.getAnswerVariables()); + Utility.logDebug(t.duration()); + queryRecord.updateLowerBoundAnswers(rlAnswer); + } finally { + if (rlAnswer != null) rlAnswer.dispose(); + } + queryRecord.addProcessingTime(Step.LowerBound, t.duration()); + rlAnswer = null; + + t.reset(); + BasicQueryEngine upperStore = queryRecord.isBottom() || lazyUpperStore == null ? trackingStore : lazyUpperStore; + + String[] extendedQuery = queryRecord.getExtendedQueryText(); + + queryUpperBound(upperStore, queryRecord, queryRecord.getQueryText(), queryRecord.getAnswerVariables()); + if (!queryRecord.processed() && !queryRecord.getQueryText().equals(extendedQuery[0])) + queryUpperBound(upperStore, queryRecord, extendedQuery[0], queryRecord.getAnswerVariables()); + if (!queryRecord.processed() && queryRecord.hasNonAnsDistinguishedVariables()) + queryUpperBound(upperStore, queryRecord, extendedQuery[1], queryRecord.getDistinguishedVariables()); + + queryRecord.addProcessingTime(Step.UpperBound, t.duration()); + if (queryRecord.processed()) { + queryRecord.setDifficulty(Step.UpperBound); + return null; + } + + t.reset(); + try { + elAnswer = elLowerStore.evaluate(extendedQuery[0], queryRecord.getAnswerVariables(), queryRecord.getLowerBoundAnswers()); + Utility.logDebug(t.duration()); + queryRecord.updateLowerBoundAnswers(elAnswer); + } finally { + if (elAnswer != null) elAnswer.dispose(); + } + queryRecord.addProcessingTime(Step.ELLowerBound, t.duration()); + + if (queryRecord.processed()) { + queryRecord.setDifficulty(Step.ELLowerBound); + return null; + } + + t.reset(); + + QueryTracker tracker = new QueryTracker(encoder, rlLowerStore, queryRecord); + + OWLOntology knowledgebase; + t.reset(); +// if (program.getGeneral().isHorn()) { +// knowledgebase = tracker.extract(lazyUpperStore, consistency.getQueryRecords(), true); +// queryRecord.addProcessingTime(Step.Fragment, t.duration()); +// return knowledgebase; +// } +// else { + knowledgebase = tracker.extract(trackingStore, consistency.getQueryRecords(), true); + queryRecord.addProcessingTime(Step.Fragment, t.duration()); +// } + + if (knowledgebase.isEmpty() || queryRecord.isBottom()) + return knowledgebase; + + if (program.getGeneral().isHorn()) return knowledgebase; + +// t.reset(); +// if (queryRecord.isHorn() && lazyUpperStore != null) { +//// knowledgebase = tracker.extract(lazyUpperStore, consistency.getQueryRecords(), true); +// } else if (queryRecord.getArity() < 3) { +// IterativeRefinement iterativeRefinement = new IterativeRefinement(queryRecord, tracker, trackingStore, consistency.getQueryRecords()); +// knowledgebase = iterativeRefinement.extractWithFullABox(importedData.toString(), program.getUpperBottomStrategy()); +// } +// +// queryRecord.addProcessingTime(Step.FragmentRefinement, t.duration()); +// +// if (knowledgebase == null) +// queryRecord.setDifficulty(Step.FragmentRefinement); + + return knowledgebase; + } + +// int counter = 0; + + private void queryUpperBound(BasicQueryEngine upperStore, QueryRecord queryRecord, String queryText, String[] answerVariables) { + AnswerTuples rlAnswer = null; + try { + Utility.logDebug(queryText); + rlAnswer = upperStore.evaluate(queryText, answerVariables); + Utility.logDebug(t.duration()); + queryRecord.updateUpperBoundAnswers(rlAnswer); + rlAnswer.dispose(); + } finally { + if (rlAnswer != null) rlAnswer.dispose(); + } + rlAnswer = null; + } + + @Override + public void evaluate(QueryRecord queryRecord) { + OWLOntology knowledgebase = relevantPart(queryRecord); + + if (knowledgebase == null) { + Utility.logDebug("Difficulty of this query: " + queryRecord.getDifficulty()); + return ; + } + + int aboxcount = knowledgebase.getABoxAxioms(true).size(); + Utility.logDebug("ABox axioms: " + aboxcount + " TBox axioms: " + (knowledgebase.getAxiomCount() - aboxcount)); +// queryRecord.saveRelevantOntology("fragment_query" + queryRecord.getQueryID() + ".owl"); + + Timer t = new Timer(); + Checker summarisedChecker = new HermitSummaryFilter(queryRecord); + int validNumber = summarisedChecker.check(queryRecord.getGapAnswers()); + summarisedChecker.dispose(); + Utility.logDebug("Total time for full reasoner: " + t.duration()); + if (!forSemFacet || validNumber == 0) { + queryRecord.markAsProcessed(); + Utility.logDebug("Difficulty of this query: " + queryRecord.getDifficulty()); + } + } + + @Override + public void evaluateUpper(QueryRecord queryRecord) { + AnswerTuples rlAnswer = null; + boolean useFull = queryRecord.isBottom() || lazyUpperStore == null; + try { + rlAnswer = (useFull ? trackingStore: lazyUpperStore).evaluate(queryRecord.getQueryText(), queryRecord.getAnswerVariables()); + queryRecord.updateUpperBoundAnswers(rlAnswer, true); + } finally { + if (rlAnswer != null) rlAnswer.dispose(); + } + } + + @Override + public void dispose() { + if (encoder != null) encoder.dispose(); + if (rlLowerStore != null) rlLowerStore.dispose(); + if (lazyUpperStore != null) lazyUpperStore.dispose(); + if (elLowerStore != null) elLowerStore.dispose(); + if (trackingStore != null) trackingStore.dispose(); + super.dispose(); + } + +} -- cgit v1.2.3