src/uk/ac/ox/cs/pagoda/reasoner/ELHOQueryReasoner.java


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

package uk.ac.ox.cs.pagoda.reasoner;

import org.semanticweb.karma2.profile.ELHOProfile;
import org.semanticweb.owlapi.model.OWLOntology;
import uk.ac.ox.cs.pagoda.constraints.UnaryBottom;
import uk.ac.ox.cs.pagoda.query.AnswerTuples;
import uk.ac.ox.cs.pagoda.query.QueryRecord;
import uk.ac.ox.cs.pagoda.query.QueryRecord.Step;
import uk.ac.ox.cs.pagoda.reasoner.light.KarmaQueryEngine;
import uk.ac.ox.cs.pagoda.rules.LowerDatalogProgram;
import uk.ac.ox.cs.pagoda.util.Timer;
import uk.ac.ox.cs.pagoda.util.Utility;
import uk.ac.ox.cs.pagoda.util.disposable.DisposedException;

class ELHOQueryReasoner extends QueryReasoner {

    LowerDatalogProgram program;

    OWLOntology elho_ontology;
    KarmaQueryEngine elLowerStore = null;

    private Timer t = new Timer();

    public ELHOQueryReasoner() {
        elLowerStore = new KarmaQueryEngine("el");
    }

    @Override
    public void evaluate(QueryRecord queryRecord) {
        if(isDisposed()) throw new DisposedException();
        AnswerTuples elAnswer = null;
        t.reset();
        try {
            elAnswer = elLowerStore.evaluate(queryRecord.getQueryText(), queryRecord.getAnswerVariables());
            queryRecord.updateLowerBoundAnswers(elAnswer);
        } finally {
            if(elAnswer != null) elAnswer.dispose();
        }
        queryRecord.addProcessingTime(Step.EL_LOWER_BOUND, t.duration());

        queryRecord.setDifficulty(Step.EL_LOWER_BOUND);
        queryRecord.markAsProcessed();
    }

    @Override
    public void evaluateUpper(QueryRecord queryRecord) {
        if(isDisposed()) throw new DisposedException();
        evaluate(queryRecord);
    }

    @Override
    public void dispose() {
        super.dispose();
        if(elLowerStore != null) elLowerStore.dispose();
    }

    @Override
    public void loadOntology(OWLOntology ontology) {
        if(isDisposed()) throw new DisposedException();
        program = new LowerDatalogProgram(properties.getToClassify());
        program.load(ontology, new UnaryBottom());
        program.transform();

        importData(program.getAdditionalDataFile());

        elho_ontology = new ELHOProfile().getFragment(ontology);
        elLowerStore.processOntology(elho_ontology);
    }

    @Override
    public boolean preprocess() {
        if(isDisposed()) throw new DisposedException();
        elLowerStore.importRDFData("data", getImportedData());
        String rlLowerProgramText = program.toString();
//		program.save();
        elLowerStore.materialise("lower program", rlLowerProgramText);
        elLowerStore.initialiseKarma();

        if(!isConsistent()) {
            Utility.logDebug("The dataset is not consistent with the ontology.");
            return false;
        }
        return true;
    }

    @Override
    public boolean isConsistent() {
        if(isDisposed()) throw new DisposedException();
        String[] X = new String[]{"X"};
        AnswerTuples ans = null;
        try {
            ans = elLowerStore.evaluate(QueryRecord.botQueryText, X);
            if(ans.isValid()) return false;
        } finally {
            if(ans != null) ans.dispose();
        }

        return true;
    }

}