/* * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team. * * This file is part of the reasoning system Konclude. * For details and support, see . * * Konclude is free software: you can redistribute it and/or modify * it under the terms of version 3 of the GNU Lesser General Public * License (LGPLv3) as published by the Free Software Foundation. * * Konclude is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU (Lesser) General Public License for more details. * * You should have received a copy of the GNU (Lesser) General Public * License along with Konclude. If not, see . * */ #include "CSatisfiableTaskIncrementalConsistencyPreyingAnalyser.h" namespace Konclude { namespace Reasoner { namespace Kernel { namespace Algorithm { CSatisfiableTaskIncrementalConsistencyPreyingAnalyser::CSatisfiableTaskIncrementalConsistencyPreyingAnalyser() { } CSatisfiableTaskIncrementalConsistencyPreyingAnalyser::~CSatisfiableTaskIncrementalConsistencyPreyingAnalyser() { } bool CSatisfiableTaskIncrementalConsistencyPreyingAnalyser::analyseSatisfiableTask(CSatisfiableCalculationTask* statCalcTask, CCalculationAlgorithmContext* calcAlgContext) { CSatisfiableTaskIncrementalConsistencyTestingAdapter* incConsAdapter = statCalcTask->getSatisfiableTaskIncrementalConsistencyTestingAdapter(); if (incConsAdapter) { CConsistenceObserver* consObs = nullptr; consObs = incConsAdapter->getConsistenceObserver(); if (consObs) { CConcreteOntology* prevConsOntology = incConsAdapter->getPreviousConsistentOntology(); CConsistenceTaskData* prevConsTaskData = nullptr; if (prevConsOntology) { CConsistence* prevConsistence = prevConsOntology->getConsistence(); if (prevConsistence) { CConsistenceData* prevConsData = prevConsistence->getConsistenceModelData(); if (prevConsData) { prevConsTaskData = dynamic_cast(prevConsData); } } } CSatisfiableCalculationTask* rootStatCalcTask = (CSatisfiableCalculationTask*)statCalcTask->getRootTask(); CIncrementalConsistenceTaskData* consTaskData = new CIncrementalConsistenceTaskData(rootStatCalcTask,statCalcTask,prevConsOntology,prevConsTaskData); analyseIncrementalChanges(statCalcTask,consTaskData,calcAlgContext); consObs->tellConsistenceData(consTaskData); return true; } } return false; } CIndividualProcessNode* CSatisfiableTaskIncrementalConsistencyPreyingAnalyser::getMergedIntoIndividualNode(CIndividualProcessNode* indiNode, CIndividualProcessNodeVector* indiNodeVec, CCalculationAlgorithmContext* calcAlgContext) { CIndividualProcessNode* mergedIntoIndiNode = indiNode; while (mergedIntoIndiNode && mergedIntoIndiNode->getMergedIntoIndividualNodeID() != mergedIntoIndiNode->getIndividualNodeID()) { mergedIntoIndiNode = indiNodeVec->getData(mergedIntoIndiNode->getMergedIntoIndividualNodeID()); } return mergedIntoIndiNode; } bool CSatisfiableTaskIncrementalConsistencyPreyingAnalyser::analyseIncrementalChanges(CSatisfiableCalculationTask* statCalcTask, CIncrementalConsistenceTaskData* incConsData, CCalculationAlgorithmContext* calcAlgContext) { CConcreteOntology* prevConsOntology = incConsData->getPreviousOntology(); CConsistenceTaskData* prevConsTaskData = incConsData->getPreviousConsistenceData(); QSet* indirectlyChangedNodeSet = incConsData->getIndirectlyChangedNodeSet(); QSet* deterministicallyChangedNodeSet = incConsData->getDeterministicallyChangedNodeSet(); QSet* changedCompatibleNodeSet = incConsData->getChangedCompatibleNodeSet(); if (prevConsTaskData) { CSatisfiableCalculationTask* prevCompGraphCalcTask = prevConsTaskData->getCompletionGraphCachedSatisfiableTask(); CIndividualProcessNodeVector* indiNodeVec = statCalcTask->getProcessingDataBox()->getIndividualProcessNodeVector(); CIndividualProcessNodeVector* prevIndiNodeVec = prevCompGraphCalcTask->getProcessingDataBox()->getIndividualProcessNodeVector(); cint64 incExpID = statCalcTask->getProcessingDataBox()->getIncrementalExpansionID(); cint64 indiNodeCount = indiNodeVec->getItemCount(); cint64 indiNodeStartIdx = indiNodeVec->getItemMinIndex(); cint64 addNodeCount = 0; cint64 totalNodeCount = 0; cint64 prevNodeCount = 0; statCalcTask->getProcessingDataBox()->setMaxIncrementalPreviousCompletionGraphNodeID(prevIndiNodeVec->getItemCount()); for (cint64 i = indiNodeStartIdx; i < indiNodeCount; ++i) { CIndividualProcessNode* indiNode = indiNodeVec->getData(i); CIndividualProcessNode* prevIndiNode = prevIndiNodeVec->getData(i); if (prevIndiNode) { ++prevNodeCount; } if (indiNode) { ++totalNodeCount; if (!prevIndiNode) { ++addNodeCount; } if (!indiNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFPURGEDBLOCKED) || prevIndiNode && !prevIndiNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFPURGEDBLOCKED) && prevIndiNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFSUCCESSORNOMINALCONNECTION)) { bool indirectlyChanged = false; bool deterministicallyChanged = false; if (prevIndiNode || indiNode->isNominalIndividualNode()) { if (indiNode != prevIndiNode) { indirectlyChangedNodeSet->insert(-i); indirectlyChanged = true; } if (indiNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFINCREMENTALEXPANDING)) { if (indiNode->getIncrementalExpansionID() == incExpID) { deterministicallyChangedNodeSet->insert(-i); deterministicallyChanged = true; } } } if (indirectlyChanged || deterministicallyChanged) { bool compatible = false; if (indiNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHED) && !indiNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHINGINVALID | CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHINGINVALIDATED)) { compatible = true; } else { CIndividualProcessNode* mergedIntoIndiNode = getMergedIntoIndividualNode(indiNode,indiNodeVec,calcAlgContext); if (prevIndiNode) { CIndividualProcessNode* prevMergedIntoIndiNode = getMergedIntoIndividualNode(prevIndiNode,prevIndiNodeVec,calcAlgContext); if (mergedIntoIndiNode->getIndividualNodeID() == prevMergedIntoIndiNode->getIndividualNodeID()) { CReapplyConceptLabelSet* conSet = mergedIntoIndiNode->getReapplyConceptLabelSet(false); if (conSet && prevMergedIntoIndiNode) { CReapplyConceptLabelSet* prevConSet = prevMergedIntoIndiNode->getReapplyConceptLabelSet(false); if (prevConSet && prevConSet->getConceptSignatureValue() == conSet->getConceptSignatureValue() && conSet->getConceptCount() == prevConSet->getConceptCount()) { CReapplyConceptLabelSetIterator prevConIt = prevConSet->getConceptLabelSetIterator(true); CReapplyConceptLabelSetIterator conIt = conSet->getConceptLabelSetIterator(true); bool identicalLabels = true; while (prevConIt.hasValue() && conIt.hasValue() && identicalLabels) { CConceptDescriptor* conDes = conIt.getConceptDescriptor(); CConceptDescriptor* prevConDes = prevConIt.getConceptDescriptor(); if (conDes && prevConDes) { if (conDes->getConcept() != prevConDes->getConcept()) { identicalLabels = false; } if (conDes->isNegated() != prevConDes->isNegated()) { identicalLabels = false; } } else if (conDes || prevConDes) { identicalLabels = false; } conIt.moveNext(); prevConIt.moveNext(); } if (conIt.hasNext() || prevConIt.hasNext()) { identicalLabels = false; } if (identicalLabels) { compatible = true; } } } } } } if (compatible) { // test for problematic at-most cardinality restrictions bool problematicConcepts = false; CReapplyConceptLabelSet* conSet = indiNode->getReapplyConceptLabelSet(false); for (CConceptDescriptor* conDesIt = conSet->getAddingSortedConceptDescriptionLinker(); conDesIt && !problematicConcepts; conDesIt = conDesIt->getNext()) { CConcept* concept = conDesIt->getConcept(); bool negation = conDesIt->isNegated(); cint64 opCode = concept->getOperatorCode(); if (!negation && opCode == CCATMOST || negation && opCode == CCATLEAST) { problematicConcepts = true; } } bool problematicNeighbour = false; if (problematicConcepts) { CSuccessorIterator succIt(indiNode->getSuccessorIterator()); while (succIt.hasNext() && !problematicNeighbour) { CIndividualLinkEdge* succLink = succIt.nextLink(); CIndividualProcessNode* succIndi = getSuccessorIndividual(indiNode,succLink,calcAlgContext); if (succIndi->isNominalIndividualNode()) { if (!prevIndiNode->hasRoleSuccessorToIndividual(succLink->getLinkRole(),succIndi->getIndividualNodeID(),false)) { problematicNeighbour = true; } } } CConnectionSuccessorSetIterator connIt(indiNode->getConnectionSuccessorIterator()); while (connIt.hasNext() && !problematicNeighbour) { cint64 connID = connIt.next(); CIndividualProcessNode* connIndiNode = indiNodeVec->getData(connID); if (connIndiNode->isNominalIndividualNode()) { CIndividualProcessNode* prevConnIndiNode = prevIndiNodeVec->getData(connID); if (prevConnIndiNode) { CSuccessorRoleIterator connRoleIt(connIndiNode->getSuccessorRoleIterator(indiNode)); while (connRoleIt.hasNext() && !problematicNeighbour) { CIndividualLinkEdge* connLink = connRoleIt.next(); if (!prevConnIndiNode->hasRoleSuccessorToIndividual(connLink->getLinkRole(),prevIndiNode,false)) { problematicNeighbour = true; } } } else { problematicNeighbour = true; } } } } if (!problematicConcepts || !problematicNeighbour) { changedCompatibleNodeSet->insert(-i); } } } } } } incConsData->setAddedNodeCount(addNodeCount); incConsData->setPreviousNodeCount(prevNodeCount); incConsData->setTotalNodeCount(totalNodeCount); } return true; } CIndividualProcessNode* CSatisfiableTaskIncrementalConsistencyPreyingAnalyser::getSuccessorIndividual(CIndividualProcessNode*& indi, CIndividualLinkEdge* link, CCalculationAlgorithmContext* calcAlgContext) { CIndividualProcessNode* succIndi = nullptr; if (link->isLocalizationTagUpToDate(calcAlgContext->getUsedProcessTagger()->getCurrentLocalizationTag())) { succIndi = link->getOppositeIndividual(indi); } else { STATINC(INDINODEUPDATELOADCOUNT,calcAlgContext); succIndi = link->getOppositeIndividual(indi); if (!succIndi->isLocalizationTagUpToDate(calcAlgContext->getUsedProcessTagger()->getCurrentLocalizationTag()) && succIndi->isRelocalized()) { cint64 succIndiId = link->getOppositeIndividualID(indi); CIndividualProcessNodeVector* indiProcNodeVec = calcAlgContext->getProcessingDataBox()->getIndividualProcessNodeVector(); succIndi = indiProcNodeVec->getData(succIndiId); } } return succIndi; } }; // end namespace Algorithm }; // end namespace Kernel }; // end namespace Reasoner }; // end namespace Konclude