/*
* 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 "CSatisfiableTaskPossibleAssertionCollectingAnalyser.h"
namespace Konclude {
namespace Reasoner {
namespace Kernel {
namespace Algorithm {
CSatisfiableTaskPossibleAssertionCollectingAnalyser::CSatisfiableTaskPossibleAssertionCollectingAnalyser() {
}
bool CSatisfiableTaskPossibleAssertionCollectingAnalyser::readCalculationConfig(CCalculationConfigurationExtension *config) {
if (config) {
return true;
}
return false;
}
CIndividualProcessNode* CSatisfiableTaskPossibleAssertionCollectingAnalyser::getCorrectedIndividualNode(cint64 baseIndiID, CIndividualProcessNodeVector* indiNodeVec) {
CIndividualProcessNode* indi = indiNodeVec->getData(baseIndiID);
while (indi->hasMergedIntoIndividualNodeID()) {
indi = indiNodeVec->getData(indi->getMergedIntoIndividualNodeID());
}
return indi;
}
bool CSatisfiableTaskPossibleAssertionCollectingAnalyser::analyseSatisfiableTask(CSatisfiableCalculationTask* statCalcTask, CCalculationAlgorithmContext* calcAlgContext) {
CSatisfiableTaskRealizationPossibleAssertionCollectingAdapter* possAssCollAdapter = statCalcTask->getPossibleAssertionCollectionAdapter();
if (possAssCollAdapter) {
CPossibleAssertionsCollectionSet* possAssCollSet = possAssCollAdapter->getPossibleAssertionsCollectionSet();
CConcreteOntology* ontology = possAssCollAdapter->getTestingOntology();
if (possAssCollSet) {
CSatisfiableCalculationTask* cachedDetTask = getCachedDeterministicCompletionGraphTask(calcAlgContext);
CIndividualProcessNodeVector* detCachedIndiNodeVec = nullptr;
if (cachedDetTask) {
detCachedIndiNodeVec = cachedDetTask->getProcessingDataBox()->getIndividualProcessNodeVector();
}
CBOXSET* eqNonCanSet = ontology->getTBox()->getEquivalentConceptNonCandidateSet(false);
QSet< QPair > possConAssSet;
cint64 maxDetBranchTag = statCalcTask->getProcessingDataBox()->getMaximumDeterministicBranchTag();
CProcessingDataBox* procDataBox = calcAlgContext->getProcessingDataBox();
CIndividualProcessNodeVector* indiNodeVec = procDataBox->getIndividualProcessNodeVector();
CIndividualVector* indiVec = procDataBox->getOntology()->getABox()->getIndividualVector();
cint64 indiMinIdx = indiNodeVec->getItemMinIndex();
for (cint64 i = indiMinIdx; i <= 0; ++i) {
CIndividualProcessNode* indiNode = indiNodeVec->getData(i);
CIndividualProcessNode* cachedDetIndiNode = nullptr;
if (detCachedIndiNodeVec) {
cachedDetIndiNode = detCachedIndiNodeVec->getData(i);
}
if (indiNode && indiNode != cachedDetIndiNode && indiNode->getNominalIndividual()) {
if (!cachedDetIndiNode || !indiNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHED) || indiNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHINGINVALID | CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHINGINVALIDATED)) {
CReapplyConceptLabelSet* conLabelSet = indiNode->getReapplyConceptLabelSet(false);
if (conLabelSet) {
CIndividual* individual = indiNode->getNominalIndividual();
for (CConceptDescriptor* conDesIt = conLabelSet->getAddingSortedConceptDescriptionLinker(); conDesIt; conDesIt = conDesIt->getNext()) {
CDependencyTrackPoint* depTrackPoint = conDesIt->getDependencyTrackPoint();
CConcept* concept = conDesIt->getConcept();
bool conNegation = conDesIt->isNegated();
if (!depTrackPoint || depTrackPoint->getBranchingTag() > maxDetBranchTag) {
if (!conNegation && concept && concept->hasClassName()) {
possConAssSet.insert( QPair(individual,concept) );
}
}
if (concept->getOperatorCode() == CCEQCAND) {
CConcept* eqConcept = concept->getOperandList()->getData();
bool negation = false;
if (!conLabelSet->containsConcept(eqConcept,negation)) {
possConAssSet.insert( QPair(individual,eqConcept) );
}
}
}
if (eqNonCanSet) {
for (CBOXSET::const_iterator it = eqNonCanSet->constBegin(), itEnd = eqNonCanSet->constEnd(); it != itEnd; ++it) {
CConcept* eqConcept(*it);
bool negation = false;
if (!conLabelSet->containsConcept(eqConcept,negation)) {
possConAssSet.insert( QPair(individual,eqConcept) );
}
}
}
CIndividualMergingHash* indiMergingHash = indiNode->getIndividualMergingHash(false);
if (indiMergingHash) {
for (CIndividualMergingHash::const_iterator indiIt = indiMergingHash->constBegin(), indiItEnd = indiMergingHash->constEnd(); indiIt != indiItEnd; ++indiIt) {
if (indiIt.value().isMergedWithIndividual()) {
cint64 indiIDIt = indiIt.key();
CIndividual* mergedIndividual = indiVec->getData(indiIDIt);
CDependencyTrackPoint* mergeDepTrackPoint = indiIt.value().getDependencyTrackPoint();
bool nonDetMerged = true;
if (mergeDepTrackPoint && mergeDepTrackPoint->getBranchingTag() <= maxDetBranchTag) {
nonDetMerged = false;
}
for (CConceptDescriptor* conDesIt = conLabelSet->getAddingSortedConceptDescriptionLinker(); conDesIt; conDesIt = conDesIt->getNext()) {
CDependencyTrackPoint* depTrackPoint = conDesIt->getDependencyTrackPoint();
CConcept* concept = conDesIt->getConcept();
bool conNegation = conDesIt->isNegated();
if (nonDetMerged || !depTrackPoint || depTrackPoint->getBranchingTag() > maxDetBranchTag) {
if (!conNegation && concept && concept->hasClassName()) {
possConAssSet.insert(QPair(mergedIndividual, concept));
}
}
if (concept->getOperatorCode() == CCEQCAND) {
CConcept* eqConcept = concept->getOperandList()->getData();
bool negation = false;
if (!conLabelSet->containsConcept(eqConcept, negation)) {
possConAssSet.insert(QPair(mergedIndividual, eqConcept));
}
}
}
if (eqNonCanSet) {
for (CBOXSET::const_iterator it = eqNonCanSet->constBegin(), itEnd = eqNonCanSet->constEnd(); it != itEnd; ++it) {
CConcept* eqConcept(*it);
bool negation = false;
if (!conLabelSet->containsConcept(eqConcept, negation)) {
possConAssSet.insert(QPair(mergedIndividual, eqConcept));
}
}
}
}
}
}
}
}
}
}
if (!possConAssSet.isEmpty()) {
possAssCollSet->acquireSynchronisationLock();
for (QSet< QPair >::const_iterator it = possConAssSet.constBegin(), itEnd = possConAssSet.constEnd(); it != itEnd; ++it) {
const QPair& indiConPair(*it);
possAssCollSet->addPossibleAssertion(indiConPair.first,indiConPair.second);
}
possAssCollSet->releaseSynchronisationLock();
}
}
}
return false;
}
CSatisfiableCalculationTask* CSatisfiableTaskPossibleAssertionCollectingAnalyser::getCachedDeterministicCompletionGraphTask(CCalculationAlgorithmContext* calcAlgContext) {
CConcreteOntology* consOntology = calcAlgContext->getProcessingDataBox()->getOntology();
if (consOntology) {
CConsistence* consistence = consOntology->getConsistence();
if (consistence) {
CConsistenceData* consData = consistence->getConsistenceModelData();
if (consData) {
CConsistenceTaskData* consTaskData = dynamic_cast(consData);
if (consTaskData) {
CSatisfiableCalculationTask* compGraphCalcTask = consTaskData->getDeterministicSatisfiableTask();
return compGraphCalcTask;
}
}
}
}
return nullptr;
}
}; // end namespace Algorithm
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude