use of fr.lirmm.graphik.graal.api.forward_chaining.ChaseException in project graal by graphik-team.
the class DefaultKnowledgeBase method semiSaturate.
@Override
public void semiSaturate() throws KnowledgeBaseException {
if (!this.isSemiSaturated) {
this.compileRule();
Chase chase = new BreadthFirstChase(this.ruleCompilation.getSaturation(), this.store);
chase.setProfiler(this.getProfiler());
try {
chase.next();
} catch (ChaseException e) {
throw new KnowledgeBaseException(e);
}
this.isSemiSaturated = true;
}
}
use of fr.lirmm.graphik.graal.api.forward_chaining.ChaseException in project graal by graphik-team.
the class ChaseWithGRDAndUnfiers method next.
// /////////////////////////////////////////////////////////////////////////
// METHODS
// /////////////////////////////////////////////////////////////////////////
@Override
public void next() throws ChaseException {
Rule rule, unifiedRule;
Substitution unificator;
Queue<Triple<Rule, Substitution, InMemoryAtomSet>> newQueue = new LinkedList<Triple<Rule, Substitution, InMemoryAtomSet>>();
InMemoryAtomSet newAtomSet = new DefaultInMemoryGraphStore();
try {
while (!queue.isEmpty()) {
Triple<Rule, Substitution, InMemoryAtomSet> pair = queue.poll();
if (pair != null) {
unificator = pair.getMiddle();
InMemoryAtomSet part = pair.getRight();
rule = pair.getLeft();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("\nExecute rule: {} with unificator {}", rule, unificator);
}
unifiedRule = DefaultUnifierAlgorithm.getTargetVariablesSubstitution().createImageOf(rule);
unifiedRule = unificator.createImageOf(unifiedRule);
unifiedRule.getBody().removeAll(part);
unificator = targetToSource(unificator);
ConjunctiveQuery query = DefaultConjunctiveQueryFactory.instance().create(unifiedRule.getBody(), new LinkedList<Term>(unifiedRule.getFrontier()));
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Rule to execute: {}", unifiedRule.toString());
LOGGER.debug(" -- Query: {}", query.toString());
}
// Get projections
List<Substitution> projections = Iterators.toList(SmartHomomorphism.instance().execute(query, atomSet));
try {
for (Substitution proj : projections) {
InMemoryAtomSet newFacts = proj.createImageOf(unifiedRule.getHead());
ConjunctiveQuery q = new DefaultConjunctiveQuery(newFacts);
if (!SmartHomomorphism.instance().execute(q, newAtomSet).hasNext()) {
// Existential variables instantiation added to proj
CloseableIterator<Atom> it = hc.apply(unifiedRule, proj, atomSet);
if (it.hasNext()) {
LinkedListAtomSet foundPart = new LinkedListAtomSet();
foundPart.addAll(it);
newAtomSet.addAll(foundPart);
// Makes the projection compatible with triggered rules unifiers
Substitution compatibleProj = targetToSource(proj);
for (Pair<Rule, Substitution> p : this.grd.getTriggeredRulesWithUnifiers(rule)) {
Rule triggeredRule = p.getKey();
Substitution u = p.getValue();
if (u != null) {
Substitution comp = unificator.compose(u);
Substitution aggreg = compatibleProj.aggregate(comp);
aggreg = forgetSource(aggreg);
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("-- -- Dependency: {}", triggeredRule);
LOGGER.debug("-- -- Substitution:{} ", compatibleProj);
LOGGER.debug("-- -- Unificator: {}", u);
LOGGER.debug("-- -- Aggregation: {}\n", aggreg);
}
if (aggreg != null) {
newQueue.add(new ImmutableTriple<Rule, Substitution, InMemoryAtomSet>(triggeredRule, aggreg, foundPart));
}
}
}
}
}
}
} catch (HomomorphismFactoryException e) {
throw new RuleApplicationException("Error during rule application", e);
} catch (HomomorphismException e) {
throw new RuleApplicationException("Error during rule application", e);
} catch (IteratorException e) {
throw new RuleApplicationException("Error during rule application", e);
}
}
}
queue = newQueue;
atomSet.addAll(newAtomSet);
} catch (Exception e) {
e.printStackTrace();
throw new ChaseException("An error occur pending saturation step.", e);
}
}
use of fr.lirmm.graphik.graal.api.forward_chaining.ChaseException in project graal by graphik-team.
the class BreadthFirstChase method dispatchNewData.
// /////////////////////////////////////////////////////////////////////////
// PRIVATE CLASS
// /////////////////////////////////////////////////////////////////////////
protected void dispatchNewData(Collection<Atom> newData) throws ChaseException {
for (Atom a : newData) {
Predicate p = a.getPredicate();
for (Rule r : ruleSet.getRulesByBodyPredicate(p)) {
if (linearRuleCheck(r)) {
AtomSet set = nextRulesToCheck.get(r);
if (set == null) {
set = new DefaultInMemoryGraphStore();
nextRulesToCheck.put(r, set);
}
try {
set.add(a);
} catch (AtomSetException e) {
throw new ChaseException("Exception while adding data into a tmp store", e);
}
} else {
nextRulesToCheck.put(r, atomSet);
}
}
}
}
Aggregations