/*
* 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 "CSatisfiableTaskComplexAnsweringMessageAnalyser.h"
namespace Konclude {
namespace Reasoner {
namespace Kernel {
namespace Algorithm {
CSatisfiableTaskComplexAnsweringMessageAnalyser::CSatisfiableTaskComplexAnsweringMessageAnalyser() {
}
bool CSatisfiableTaskComplexAnsweringMessageAnalyser::readCalculationConfig(CCalculationConfigurationExtension *config) {
if (config) {
return true;
}
return false;
}
CIndividualProcessNode* CSatisfiableTaskComplexAnsweringMessageAnalyser::getCorrectedIndividualID(CIndividualProcessNode* baseIndiNode, CIndividualProcessNodeVector* indiNodeVec, bool* nondetMergedFlag) {
CIndividualProcessNode* indi = indiNodeVec->getData(baseIndiNode->getIndividualNodeID());
while (indi->hasMergedIntoIndividualNodeID()) {
if (nondetMergedFlag && *nondetMergedFlag == false) {
if (!indi->getMergedDependencyTrackPoint() || indi->getMergedDependencyTrackPoint()->getBranchingTag() > 0) {
*nondetMergedFlag = true;
}
}
indi = indiNodeVec->getData(indi->getMergedIntoIndividualNodeID());
}
return indi;
}
CAnsweringMessageData* CSatisfiableTaskComplexAnsweringMessageAnalyser::extractPossibleSubsumptionInformation(CConcept* testingConcept, bool testingConceptNegation, CIndividualProcessNode* indiNode, CReapplyConceptLabelSet* conSet, CCalculationAlgorithmContext* calcAlgContext) {
STATINC(ANALYSEPOSSIBLESUBSUMPTIONSCOUNT,calcAlgContext);
CAnsweringMessageData* messageDataLinker = nullptr;
// initialize possible subsumption list
CCLASSPOSSIBLESUBSUMPTIONMESSAGELIST* possSubsumerList = nullptr;
CReapplyConceptLabelSetIterator conSetIt = conSet->getConceptLabelSetIterator(true,true,false);
// create new initialization list for possible subsumers
while (conSetIt.hasNext()) {
CConceptDescriptor* conDes = conSetIt.getConceptDescriptor();
CConcept* concept = conDes->getConcept();
bool negated = conDes->getNegation();
if (!negated && concept->hasClassName()) {
if (!possSubsumerList) {
possSubsumerList = CObjectParameterizingAllocator< CCLASSPOSSIBLESUBSUMPTIONMESSAGELIST,CContext* >::allocateAndConstructAndParameterize(mTempMemAllocMan,mTmpContext);
}
CAnsweringMessageDataCalculationPossibleClassSubsumersData* possSubsumData = CObjectAllocator< CAnsweringMessageDataCalculationPossibleClassSubsumersData >::allocateAndConstruct(mTempMemAllocMan);
possSubsumData->initClassificationPossibleSubsumptionData(concept);
possSubsumerList->append(possSubsumData);
}
conSetIt.moveNext();
}
CAnsweringMessageDataCalculationPossibleClassSubsumers* possSubsumMessageData = CObjectAllocator::allocateAndConstruct(mTempMemAllocMan);
possSubsumMessageData->initAnsweringPossibleSubsumptionMessageData(testingConcept,testingConceptNegation,possSubsumerList);
messageDataLinker = possSubsumMessageData->append(messageDataLinker);
return messageDataLinker;
}
bool CSatisfiableTaskComplexAnsweringMessageAnalyser::analyseSatisfiableTask(CSatisfiableCalculationTask* statCalcTask, CCalculationAlgorithmContext* calcAlgContext) {
bool analysed = false;
mStatCalcTask = statCalcTask;
analysed |= analyseSatisfiableTaskMaterialization(mStatCalcTask, calcAlgContext);
analysed |= analyseSatisfiableTaskSubsumption(mStatCalcTask, calcAlgContext);
analysed |= analyseSatisfiableTaskInstancePropagation(mStatCalcTask, calcAlgContext);
return analysed;
}
bool CSatisfiableTaskComplexAnsweringMessageAnalyser::analyseSatisfiableTaskInstancePropagation(CSatisfiableCalculationTask* statCalcTask, CCalculationAlgorithmContext* calcAlgContext) {
mStatCalcTask = statCalcTask;
CSatisfiableTaskAnswererInstancePropagationMessageAdapter* answererInstancePropagationAdapter = statCalcTask->getSatisfiableAnswererInstancePropagationMessageAdapter();
if (answererInstancePropagationAdapter) {
CAnsweringMessageDataObserver* conceptMessClassObserver = answererInstancePropagationAdapter->getAnswererMessageDataObserver();
CAnsweringMessageData* propagatedIndiMessageDataLinker = nullptr;
CAnsweringMessageData* possiblePropagatedIndiMessageDataLinker = nullptr;
CTaskProcessorContext* taskProcessorContext = calcAlgContext->getUsedTaskProcessorContext();
CTaskHandleMemoryAllocationManager* taskMemMan = calcAlgContext->getTemporaryMemoryAllocationManager();
CConcept* testingConcept = answererInstancePropagationAdapter->getTestingConcept();
bool candidatePropagation = answererInstancePropagationAdapter->isCandidatePropagation();
bool testingConceptNegation = answererInstancePropagationAdapter->getTestingConceptNegation();
//QString iriClassNameString = CIRIName::getRecentIRIName(testingConcept->getClassNameLinker());
//if (iriClassNameString == "http://www.owllink.org/testsuite/galen#LowerLobeOfLeftLung") {
// bool bug = true;
//}
//}
//considerOtherNode = false;
CAnsweringHandler* answeringHandler = answererInstancePropagationAdapter->getAnsweringHandler();
CConcreteOntology* testOntology = answererInstancePropagationAdapter->getTestingOntology();
CProcessingDataBox* processingDataBox = statCalcTask->getProcessingDataBox();
CIndividualProcessNodeVector* indiNodeVec = processingDataBox->getIndividualProcessNodeVector();
cint64 maxDetBranchTag = processingDataBox->getMaximumDeterministicBranchTag();
if (testOntology && testingConcept) {
CMemoryPoolContainer memPoolCon;
CTaskMemoryPoolAllocationManager classMessMemManCreaterMemMan(&memPoolCon, calcAlgContext->getTemporaryMemoryAllocationManager());
mTempMemAllocMan = CObjectAllocator::allocateAndConstruct(&classMessMemManCreaterMemMan);
mTempMemAllocMan->initTaskMemoryPoolAllocationManager(&memPoolCon, calcAlgContext->getTemporaryMemoryAllocationManager());
mTmpContext = CObjectParameterizingAllocator< CContextBase, CMemoryAllocationManager* >::allocateAndConstructAndParameterize(mTempMemAllocMan, mTempMemAllocMan);
CProcessingDataBox* procDataBox = calcAlgContext->getProcessingDataBox();
CIndividualVector* indiVec = procDataBox->getIndividualVector();
CMarkerIndividualNodeHash* markerIndiNodeHash = procDataBox->getMarkerIndividualNodeHash(false);
bool hasMarkedPropagatedConceptIndis = false;
if (markerIndiNodeHash) {
for (CPROCESSHASH< CConcept*, CMarkerIndividualNodeData >::const_iterator it = markerIndiNodeHash->constBegin(), itEnd = markerIndiNodeHash->constEnd(); it != itEnd; ++it) {
CConcept* markerConcept = it.key();
CXLinker* detIndiCandLinker = nullptr;
CXLinker* ndetIndiCandLinker = nullptr;
CXNegLinker* candIndiLinker = it.value().getMarkerIndividualNodeLinker();
CCLASSSUBSUMPTIONMESSAGELIST* indiList = nullptr;
CCLASSSUBSUMPTIONMESSAGELIST* possIndiList = nullptr;
for (CXNegLinker* candIndiLinkerIt = candIndiLinker; candIndiLinkerIt; candIndiLinkerIt = candIndiLinkerIt->getNext()) {
CIndividualProcessNode* indiNode = candIndiLinkerIt->getData();
CIndividual* candIndividual = indiNode->getNominalIndividual();
if (candIndividual) {
hasMarkedPropagatedConceptIndis = true;
bool nondeterministicallyAdded = candIndiLinkerIt->isNegated();
if (nondeterministicallyAdded || candidatePropagation) {
addIndividualToReferenceList(possIndiList, candIndividual);
} else {
addIndividualToReferenceList(indiList, candIndividual);
}
CIndividualMergingHash* indiMergingHash = indiNode->getIndividualMergingHash(false);
if (indiMergingHash) {
for (CIndividualMergingHash::const_iterator indiIt = indiMergingHash->constBegin(), indiItEnd = indiMergingHash->constEnd(); indiIt != indiItEnd; ++indiIt) {
cint64 indiIDIt = indiIt.key();
if (indiIt.value().isMergedWithIndividual()) {
if (indiIDIt != candIndividual->getIndividualID()) {
CIndividual* mergedIndividual = indiVec->getData(indiIDIt);
CDependencyTrackPoint* mergeDepTrackPoint = indiIt.value().getDependencyTrackPoint();
bool nonDetMerged = true;
if (mergeDepTrackPoint && mergeDepTrackPoint->getBranchingTag() <= maxDetBranchTag) {
nonDetMerged = false;
}
if (nonDetMerged || candidatePropagation) {
addIndividualToReferenceList(possIndiList, mergedIndividual);
} else {
addIndividualToReferenceList(indiList, mergedIndividual);
}
}
}
}
}
}
}
if (possIndiList) {
CAnsweringMessageDataInstancePossiblePropagationsData* possInstancePropMessageData = CObjectAllocator::allocateAndConstruct(mTempMemAllocMan);
possInstancePropMessageData->initInstancePropagationsData(testingConcept, testingConceptNegation, markerConcept, possIndiList);
possiblePropagatedIndiMessageDataLinker = possInstancePropMessageData->append(possiblePropagatedIndiMessageDataLinker);
}
if (indiList) {
CAnsweringMessageDataInstanceCertainPropagationsData* certainInstancePropMessageData = CObjectAllocator::allocateAndConstruct(mTempMemAllocMan);
certainInstancePropMessageData->initInstancePropagationsData(testingConcept, testingConceptNegation, markerConcept, indiList);
propagatedIndiMessageDataLinker = certainInstancePropMessageData->append(propagatedIndiMessageDataLinker);
}
}
}
CAnsweringMessageData* messageDataLinker = possiblePropagatedIndiMessageDataLinker;
if (propagatedIndiMessageDataLinker) {
messageDataLinker = propagatedIndiMessageDataLinker->append(messageDataLinker);
}
if (messageDataLinker) {
conceptMessClassObserver->sendMessage(answeringHandler, messageDataLinker, memPoolCon.takeMemoryPools());
} else {
taskMemMan->releaseTemporaryMemoryPools(memPoolCon.takeMemoryPools());
}
return true;
}
}
return false;
}
bool CSatisfiableTaskComplexAnsweringMessageAnalyser::addIndividualToReferenceList(CCLASSSUBSUMPTIONMESSAGELIST*& indiRefList, CIndividual* candIndividual) {
if (!indiRefList) {
indiRefList = CObjectParameterizingAllocator< CCLASSSUBSUMPTIONMESSAGELIST, CContext* >::allocateAndConstructAndParameterize(mTempMemAllocMan, mTmpContext);
}
if (!candIndividual->isTemporaryIndividual()) {
indiRefList->append(CIndividualReference(candIndividual));
} else {
indiRefList->append(CIndividualReference(candIndividual->getIndividualID()));
}
return true;
}
bool CSatisfiableTaskComplexAnsweringMessageAnalyser::analyseSatisfiableTaskSubsumption(CSatisfiableCalculationTask* statCalcTask, CCalculationAlgorithmContext* calcAlgContext) {
mStatCalcTask = statCalcTask;
CSatisfiableTaskAnswererSubsumptionMessageAdapter* answererConceptMarkedAdapter = statCalcTask->getSatisfiableAnswererSubsumptionMessageAdapter();
if (answererConceptMarkedAdapter) {
CAnsweringMessageDataObserver* conceptMessClassObserver = answererConceptMarkedAdapter->getAnswererMessageDataObserver();
CAnsweringMessageData* subsumMessageDataLinker = nullptr;
CAnsweringMessageData* possSubsumMessageDataLinker = nullptr;
CTaskProcessorContext* taskProcessorContext = calcAlgContext->getUsedTaskProcessorContext();
CTaskHandleMemoryAllocationManager* taskMemMan = calcAlgContext->getTemporaryMemoryAllocationManager();
CConcept* testingConcept = answererConceptMarkedAdapter->getTestingConcept();
bool testingConceptNegation = answererConceptMarkedAdapter->getTestingConceptNegation();
CIndividualProcessNode* baseIndi = statCalcTask->getProcessingDataBox()->getConstructedIndividualNode();
//QString iriClassNameString = CIRIName::getRecentIRIName(testingConcept->getClassNameLinker());
//if (iriClassNameString == "http://www.owllink.org/testsuite/galen#LowerLobeOfLeftLung") {
// bool bug = true;
//}
//}
//considerOtherNode = false;
CAnsweringHandler* answeringHandler = answererConceptMarkedAdapter->getAnsweringHandler();
CConcreteOntology* testOntology = answererConceptMarkedAdapter->getTestingOntology();
CProcessingDataBox* processingDataBox = statCalcTask->getProcessingDataBox();
CIndividualProcessNodeVector* indiNodeVec = processingDataBox->getIndividualProcessNodeVector();
cint64 maxDetBranchTag = processingDataBox->getMaximumDeterministicBranchTag();
if (testOntology && testingConcept && baseIndi) {
cint64 baseIndiID = baseIndi->getIndividualNodeID();
CIndividualProcessNode* baseIndiNode = indiNodeVec->getData(baseIndiID);
bool nondetMerged = false;
baseIndiNode = getCorrectedIndividualID(baseIndiNode,indiNodeVec,&nondetMerged);
if (nondetMerged) {
maxDetBranchTag = 0;
}
CMemoryPoolContainer memPoolCon;
CTaskMemoryPoolAllocationManager classMessMemManCreaterMemMan(&memPoolCon,calcAlgContext->getTemporaryMemoryAllocationManager());
mTempMemAllocMan = CObjectAllocator::allocateAndConstruct(&classMessMemManCreaterMemMan);
mTempMemAllocMan->initTaskMemoryPoolAllocationManager(&memPoolCon,calcAlgContext->getTemporaryMemoryAllocationManager());
mTmpContext = CObjectParameterizingAllocator< CContextBase,CMemoryAllocationManager* >::allocateAndConstructAndParameterize(mTempMemAllocMan,mTempMemAllocMan);
CCLASSSUBSUMPTIONMESSAGELIST* subsumerList = nullptr;
CReapplyConceptLabelSet* conSet = baseIndiNode->getReapplyConceptLabelSet(false);
if (conSet) {
CReapplyConceptLabelSetIterator conSetIt = conSet->getConceptLabelSetIterator(true,true,true);
while (conSetIt.hasNext()) {
CConceptDescriptor* conDes = conSetIt.getConceptDescriptor();
if (conDes) {
CConcept* concept = conDes->getConcept();
bool negated = conDes->getNegation();
if (!negated && concept->hasClassName()) {
CDependencyTrackPoint* depTrackPoint = conSetIt.getDependencyTrackPoint();
bool deterministic = false;
if (depTrackPoint) {
if (depTrackPoint->getBranchingTag() <= maxDetBranchTag) {
deterministic = true;
}
}
if (deterministic) {
if (!subsumerList) {
subsumerList = CObjectParameterizingAllocator< CCLASSSUBSUMPTIONMESSAGELIST,CContext* >::allocateAndConstructAndParameterize(mTempMemAllocMan,mTmpContext);
}
subsumerList->append(concept);
}
}
}
conSetIt.moveNext();
}
CAnsweringMessageData* messageData = extractPossibleSubsumptionInformation(testingConcept, testingConceptNegation,baseIndiNode,conSet,calcAlgContext);
if (messageData) {
possSubsumMessageDataLinker = messageData->append(possSubsumMessageDataLinker);
}
}
CAnsweringMessageDataCalculationClassSubsumers* subsumMessageData = CObjectAllocator::allocateAndConstruct(mTempMemAllocMan);
subsumMessageData->initAnsweringSubsumptionMessageData(testingConcept,testingConceptNegation,subsumerList);
subsumMessageDataLinker = subsumMessageData->append(subsumMessageDataLinker);
subsumerList = nullptr;
CAnsweringMessageData* messageDataLinker = possSubsumMessageDataLinker;
if (subsumMessageDataLinker) {
messageDataLinker = subsumMessageDataLinker->append(messageDataLinker);
}
if (messageDataLinker) {
conceptMessClassObserver->sendMessage(answeringHandler,messageDataLinker,memPoolCon.takeMemoryPools());
} else {
taskMemMan->releaseTemporaryMemoryPools(memPoolCon.takeMemoryPools());
}
return true;
}
}
return false;
}
bool CSatisfiableTaskComplexAnsweringMessageAnalyser::analyseSatisfiableTaskMaterialization(CSatisfiableCalculationTask* statCalcTask, CCalculationAlgorithmContext* calcAlgContext) {
mStatCalcTask = statCalcTask;
CSatisfiableTaskAnswererQueryingMaterializationAdapter* matAdapter = statCalcTask->getSatisfiableAnswererMaterializationAdapter();
if (matAdapter) {
CAnsweringMessageDataObserver* conceptMessClassObserver = matAdapter->getAnswererMessageDataObserver();
CAnsweringMessageData* subsumMessageDataLinker = nullptr;
CTaskProcessorContext* taskProcessorContext = calcAlgContext->getUsedTaskProcessorContext();
CTaskHandleMemoryAllocationManager* taskMemMan = calcAlgContext->getTemporaryMemoryAllocationManager();
QList varIndiList = matAdapter->getIndividualList();
CAnsweringHandler* answeringHandler = matAdapter->getAnsweringHandler();
CConcreteOntology* testOntology = matAdapter->getTestingOntology();
CProcessingDataBox* processingDataBox = statCalcTask->getProcessingDataBox();
CIndividualProcessNodeVector* indiNodeVec = processingDataBox->getIndividualProcessNodeVector();
cint64 maxDetBranchTag = processingDataBox->getMaximumDeterministicBranchTag();
cint64 matDataIdentifer = matAdapter->getMaterializationDataIdentifier();
if (testOntology && !varIndiList.isEmpty()) {
CMemoryPoolContainer memPoolCon;
CTaskMemoryPoolAllocationManager classMessMemManCreaterMemMan(&memPoolCon, calcAlgContext->getTemporaryMemoryAllocationManager());
mTempMemAllocMan = CObjectAllocator::allocateAndConstruct(&classMessMemManCreaterMemMan);
mTempMemAllocMan->initTaskMemoryPoolAllocationManager(&memPoolCon, calcAlgContext->getTemporaryMemoryAllocationManager());
mTmpContext = CObjectParameterizingAllocator< CContextBase, CMemoryAllocationManager* >::allocateAndConstructAndParameterize(mTempMemAllocMan, mTempMemAllocMan);
for (CIndividual* varIndi : varIndiList) {
cint64 baseIndiID = -varIndi->getIndividualID();
CIndividualProcessNode* baseIndiNode = indiNodeVec->getData(baseIndiID);
bool nondetMerged = false;
baseIndiNode = getCorrectedIndividualID(baseIndiNode, indiNodeVec, &nondetMerged);
if (nondetMerged) {
maxDetBranchTag = -1;
}
CCLASSSUBSUMPTIONMESSAGELIST* subsumerList = nullptr;
CReapplyConceptLabelSet* conSet = baseIndiNode->getReapplyConceptLabelSet(false);
if (conSet) {
CReapplyConceptLabelSetIterator conSetIt = conSet->getConceptLabelSetIterator(true, true, true);
while (conSetIt.hasNext()) {
CConceptDescriptor* conDes = conSetIt.getConceptDescriptor();
if (conDes) {
CConcept* concept = conDes->getConcept();
bool negated = conDes->getNegation();
if (!negated && concept->hasClassName()) {
CDependencyTrackPoint* depTrackPoint = conSetIt.getDependencyTrackPoint();
bool deterministic = false;
if (depTrackPoint) {
if (depTrackPoint->getBranchingTag() <= maxDetBranchTag) {
deterministic = true;
}
}
if (deterministic) {
//if (concept->hasClassName() && CIRIName::getRecentIRIName(concept->getClassNameLinker()) == "http://krono.act.uji.es/people/Ernesto/qimage-ontology/OntologyQimage.owl#right_angle_point") {
// bool debug = true;
//}
if (!subsumerList) {
subsumerList = CObjectParameterizingAllocator< CCLASSSUBSUMPTIONMESSAGELIST, CContext* >::allocateAndConstructAndParameterize(mTempMemAllocMan, mTmpContext);
}
subsumerList->append(concept);
}
}
}
conSetIt.moveNext();
}
}
CAnsweringMessageDataCalculationMaterializedConcepts* subsumMessageData = CObjectAllocator::allocateAndConstruct(mTempMemAllocMan);
subsumMessageData->initMaterializedConceptsMessageData(varIndi, subsumerList, nullptr, matDataIdentifer);
subsumMessageDataLinker = subsumMessageData->append(subsumMessageDataLinker);
subsumerList = nullptr;
}
CAnsweringMessageData* messageDataLinker = subsumMessageDataLinker;
if (messageDataLinker) {
conceptMessClassObserver->sendMessage(answeringHandler, messageDataLinker, memPoolCon.takeMemoryPools());
} else {
taskMemMan->releaseTemporaryMemoryPools(memPoolCon.takeMemoryPools());
}
return true;
}
}
return false;
}
}; // end namespace Algorithm
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude