/*
* 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 "CSatisfiableTaskSaturationOccurrenceStatisticsCollector.h"
namespace Konclude {
namespace Reasoner {
namespace Kernel {
namespace Algorithm {
CSatisfiableTaskSaturationOccurrenceStatisticsCollector::CSatisfiableTaskSaturationOccurrenceStatisticsCollector(COccurrenceStatisticsCacheWriter* occStatsCacheWriter) {
mOccStatsCacheWriter = occStatsCacheWriter;
mCollectedOccStatsNodeCount = 0;
mCollectedOccStatsSuccNodeCount = 0;
mCollectedOccStatsConceptCount = 0;
mCollectedOccStatsRoleCount = 0;
}
CSatisfiableTaskSaturationOccurrenceStatisticsCollector::~CSatisfiableTaskSaturationOccurrenceStatisticsCollector() {
}
bool CSatisfiableTaskSaturationOccurrenceStatisticsCollector::analyseSatisfiableTask(CSatisfiableCalculationTask* statCalcTask, CCalculationAlgorithmContext* calcAlgContext) {
mOntology = statCalcTask->getProcessingDataBox()->getOntology();
mOntologyTag = mOntology->getOntologyID();
return collectOccurrenceStatistics(statCalcTask->getProcessingDataBox(), calcAlgContext);
}
CIndividualSaturationProcessNode* CSatisfiableTaskSaturationOccurrenceStatisticsCollector::getSuccessorNode(CConceptSaturationDescriptor* conDes, CIndividualSaturationProcessNode* satNode, CCalculationAlgorithmContext* calcAlgContext) {
CConcept* concept = conDes->getConcept();
bool conNegation = conDes->isNegated();
CRole* role = concept->getRole();
CConceptData* conceptData = concept->getConceptData();
if (conceptData) {
CConceptProcessData* conProcData = (CConceptProcessData*)conceptData;
CConceptReferenceLinking* conRefLinking = conProcData->getConceptReferenceLinking();
if (conRefLinking) {
CConceptSaturationReferenceLinkingData* confSatRefLinkingData = (CConceptSaturationReferenceLinkingData*)conRefLinking;
CSaturationConceptReferenceLinking* extSatCalcRefLinkData = confSatRefLinkingData->getExistentialSuccessorConceptSaturationReferenceLinkingData();
if (extSatCalcRefLinkData) {
CIndividualSaturationProcessNode* existIndiNode = (CIndividualSaturationProcessNode*)extSatCalcRefLinkData->getIndividualProcessNodeForConcept();
if (existIndiNode) {
return existIndiNode;
}
}
}
}
CSortedNegLinker* conceptOpLinkerIt = concept->getOperandList();
while (conceptOpLinkerIt) {
CConcept* opConcept = conceptOpLinkerIt->getData();
bool opConNegation = conceptOpLinkerIt->isNegated() ^ conNegation;
CConceptData* opConceptData = opConcept->getConceptData();
if (opConceptData) {
CConceptProcessData* conProcData = (CConceptProcessData*)opConceptData;
CConceptReferenceLinking* conRefLinking = conProcData->getConceptReferenceLinking();
if (conRefLinking) {
CConceptSaturationReferenceLinkingData* confSatRefLinkingData = (CConceptSaturationReferenceLinkingData*)conRefLinking;
CSaturationConceptReferenceLinking* satCalcRefLinkData = confSatRefLinkingData->getConceptSaturationReferenceLinkingData(opConNegation);
if (satCalcRefLinkData) {
CIndividualSaturationProcessNode* existIndiNode = (CIndividualSaturationProcessNode*)satCalcRefLinkData->getIndividualProcessNodeForConcept();
if (existIndiNode) {
return existIndiNode;
}
}
}
}
conceptOpLinkerIt = conceptOpLinkerIt->getNext();
}
CConcept* baseTopConcept = nullptr;
if (!role->isDataRole()) {
baseTopConcept = calcAlgContext->getUsedProcessingDataBox()->getOntologyTopConcept();
} else {
baseTopConcept = calcAlgContext->getUsedProcessingDataBox()->getOntologyTopDataRangeConcept();
}
CConcept* opConcept = baseTopConcept;
bool opConNegation = false;
CConceptData* opConceptData = opConcept->getConceptData();
if (opConceptData) {
CConceptProcessData* conProcData = (CConceptProcessData*)opConceptData;
CConceptReferenceLinking* conRefLinking = conProcData->getConceptReferenceLinking();
if (conRefLinking) {
CConceptSaturationReferenceLinkingData* confSatRefLinkingData = (CConceptSaturationReferenceLinkingData*)conRefLinking;
CSaturationConceptReferenceLinking* satCalcRefLinkData = confSatRefLinkingData->getConceptSaturationReferenceLinkingData(opConNegation);
if (satCalcRefLinkData) {
CIndividualSaturationProcessNode* existIndiNode = (CIndividualSaturationProcessNode*)satCalcRefLinkData->getIndividualProcessNodeForConcept();
if (existIndiNode) {
return existIndiNode;
}
}
}
}
return nullptr;
}
bool CSatisfiableTaskSaturationOccurrenceStatisticsCollector::visitNodeSuccessors(CIndividualSaturationProcessNode* satNode,
bool visitedExistentialSuccessessors, bool visitNominalSuccessors, bool visitDataSuccessors, bool analyseConcepts, bool analyseSuccessorLinks,
function visitSuccNodeFunc, function visitSuccRoleFunc, CCalculationAlgorithmContext* calcAlgContext) {
CReapplyConceptSaturationLabelSet* conSet = satNode->getReapplyConceptSaturationLabelSet(false);
CLinkedRoleSaturationSuccessorHash* linkedSuccHash = satNode->getLinkedRoleSuccessorHash(false);
CIndividualSaturationProcessNode* copiedNode = satNode->getCopyIndividualNode();
if (copiedNode && copiedNode->getReapplyConceptSaturationLabelSet(false) && copiedNode->getReapplyConceptSaturationLabelSet(false)->getConceptSaturationDescriptionLinker() == conSet->getConceptSaturationDescriptionLinker() && (!linkedSuccHash || copiedNode->getLinkedRoleSuccessorHash(false))) {
return visitNodeSuccessors(copiedNode, visitedExistentialSuccessessors, visitNominalSuccessors, visitDataSuccessors, analyseConcepts, analyseSuccessorLinks, visitSuccNodeFunc, visitSuccRoleFunc, calcAlgContext);
}
bool visited = false;
if (analyseSuccessorLinks && linkedSuccHash) {
CPROCESSHASH* linkSuccDatahash = linkedSuccHash->getLinkedRoleSuccessorHash();
for (CPROCESSHASH::const_iterator it = linkSuccDatahash->constBegin(), itEnd = linkSuccDatahash->constEnd(); it != itEnd; ++it) {
CRole* role = it.key();
CLinkedRoleSaturationSuccessorData* linkSuccData = it.value();
if (linkSuccData->mSuccCount > 0) {
CPROCESSMAP* succNodeMap = linkSuccData->getSuccessorNodeDataMap(false);
for (CPROCESSMAP::const_iterator succIt = succNodeMap->constBegin(), succItEnd = succNodeMap->constEnd(); succIt != succItEnd; ++succIt) {
bool roleSuccessorVisited = false;
CSaturationSuccessorData* succData = succIt.value();
if (succData->mActiveCount > 0) {
CIndividualSaturationProcessNode* succSatNode = succData->mSuccIndiNode;
bool visistSuccessorNode = true;
if (!succSatNode || succSatNode->isABoxIndividualRepresentationNode()) {
visistSuccessorNode = false;
}
if (succSatNode && succSatNode->getIntegratedNominalIndividual() || succData->mVALUENominalConnection) {
if (!visitNominalSuccessors) {
visistSuccessorNode = false;
}
} else {
if (role->isDataRole()) {
if (!visitDataSuccessors) {
visistSuccessorNode = false;
}
} else {
if (!visitedExistentialSuccessessors) {
visistSuccessorNode = false;
}
}
}
if (visistSuccessorNode) {
roleSuccessorVisited = true;
visited |= visitSuccNodeFunc(succSatNode, succSatNode->getIndividualID());
}
}
if (roleSuccessorVisited) {
bool baseRole = false;
for (CXNegLinker* creationRoleLinkerIt = succData->mCreationRoleLinker; creationRoleLinkerIt && !baseRole; creationRoleLinkerIt = creationRoleLinkerIt->getNext()) {
if (!creationRoleLinkerIt->isNegated() && creationRoleLinkerIt->getData() == role) {
baseRole = true;
}
}
if (baseRole) {
for (CSortedNegLinker* superRoleLinkerIt = role->getIndirectSuperRoleList(); superRoleLinkerIt; superRoleLinkerIt = superRoleLinkerIt->getNext()) {
CRole* superRole = superRoleLinkerIt->getData();
bool superRoleNegation = superRoleLinkerIt->isNegated();
visited |= visitSuccRoleFunc(superRole, superRoleNegation);
}
}
}
}
}
}
} else if (analyseConcepts && conSet) {
for (CConceptSaturationDescriptor* conSatDesIt = conSet->getConceptSaturationDescriptionLinker(); conSatDesIt; conSatDesIt = conSatDesIt->getNext()) {
CConcept* concept = conSatDesIt->getConcept();
bool conNegation = conSatDesIt->isNegated();
cint64 conCode = concept->getOperatorCode();
CRole* role = concept->getRole();
bool existentialSuccessorCand = false;
if (!conNegation && conCode == CCVALUE && visitNominalSuccessors) {
visited |= visitSuccNodeFunc(nullptr, concept->getNominalIndividual()->getIndividualID());
}
if (!conNegation && conCode == CCATLEAST || conNegation && conCode == CCATMOST) {
CIndividualSaturationProcessNode* succSatNode = getSuccessorNode(conSatDesIt, satNode, calcAlgContext);
CSaturationSuccessorData succData;
succData.mSuccCount = concept->getParameter();
if (conNegation) {
succData.mSuccCount--;
}
visited |= visitSuccNodeFunc(succSatNode, succSatNode->getIndividualID());
}
if (!conNegation && (conCode == CCSOME || conCode == CCAQSOME) || conNegation && (conCode == CCALL)) {
existentialSuccessorCand = true;
}
if (role && existentialSuccessorCand) {
CIndividualSaturationProcessNode* succSatNode = getSuccessorNode(conSatDesIt, satNode, calcAlgContext);
if (succSatNode) {
bool visistSuccessorNode = true;
if (succSatNode->getIntegratedNominalIndividual()) {
if (!visitNominalSuccessors) {
visistSuccessorNode = false;
}
} else {
if (role->isDataRole()) {
if (!visitDataSuccessors) {
visistSuccessorNode = false;
}
} else {
if (!visitedExistentialSuccessessors) {
visistSuccessorNode = false;
}
}
}
if (visistSuccessorNode) {
visited |= visitSuccNodeFunc(succSatNode, succSatNode->getIndividualID());
for (CSortedNegLinker* superRoleLinkerIt = role->getIndirectSuperRoleList(); superRoleLinkerIt; superRoleLinkerIt = superRoleLinkerIt->getNext()) {
CRole* superRole = superRoleLinkerIt->getData();
bool superRoleNegation = superRoleLinkerIt->isNegated();
visited |= visitSuccRoleFunc(superRole, superRoleNegation);
}
}
}
}
}
}
return visited;
}
bool CSatisfiableTaskSaturationOccurrenceStatisticsCollector::collectOccurrenceStatistics(CProcessingDataBox* processingDataBox, CCalculationAlgorithmContext* calcAlgContext) {
if (processingDataBox->hasIndividualSaturationCompletedNodeLinker()) {
CIndividualSaturationProcessNodeLinker* succIdentNodeLinker = nullptr;
for (CIndividualSaturationProcessNodeLinker* indiNodeLinkerIt = processingDataBox->getIndividualSaturationCompletedNodeLinker(); indiNodeLinkerIt; indiNodeLinkerIt = indiNodeLinkerIt->getNext()) {
CIndividualSaturationProcessNode* indiProcessNode = indiNodeLinkerIt->getProcessingIndividual();
if (indiProcessNode->isOccurrenceStatisticsCollectingRequired() && !indiProcessNode->isOccurrenceStatisticsCollected()) {
CIndividualSaturationProcessNodeLinker* indiProcessNodeLinker = CObjectAllocator< CIndividualSaturationProcessNodeLinker >::allocateAndConstruct(calcAlgContext->getTemporaryMemoryAllocationManager());
indiProcessNodeLinker->initProcessNodeLinker(indiProcessNode, true);
succIdentNodeLinker = indiProcessNodeLinker->append(succIdentNodeLinker);
indiProcessNode->setOccurrenceStatisticsCollected(true);
}
}
for (CIndividualSaturationProcessNodeLinker* indiNodeLinkerIt = processingDataBox->getIndividualSaturationAnalysationNodeLinker(); indiNodeLinkerIt; indiNodeLinkerIt = indiNodeLinkerIt->getNext()) {
CIndividualSaturationProcessNode* indiProcessNode = indiNodeLinkerIt->getProcessingIndividual();
if (indiProcessNode->isOccurrenceStatisticsCollectingRequired() && !indiProcessNode->isOccurrenceStatisticsCollected()) {
CIndividualSaturationProcessNodeLinker* indiProcessNodeLinker = CObjectAllocator< CIndividualSaturationProcessNodeLinker >::allocateAndConstruct(calcAlgContext->getTemporaryMemoryAllocationManager());
indiProcessNodeLinker->initProcessNodeLinker(indiProcessNode, true);
succIdentNodeLinker = indiProcessNodeLinker->append(succIdentNodeLinker);
indiProcessNode->setOccurrenceStatisticsCollected(true);
}
}
while (succIdentNodeLinker) {
CIndividualSaturationProcessNodeLinker* indiProcessNodeLinker = succIdentNodeLinker;
succIdentNodeLinker = succIdentNodeLinker->getNext();
indiProcessNodeLinker->clearNext();
++mCollectedOccStatsNodeCount;
CIndividualSaturationProcessNode* indiProcessNode = indiProcessNodeLinker->getProcessingIndividual();
visitNodeSuccessors(indiProcessNode, true, false, true, true, true, [&](CIndividualSaturationProcessNode* succNode, cint64 succIndiId)->bool {
if (succNode && !succNode->isOccurrenceStatisticsCollected() && succNode->isInitialized()) {
succNode->setOccurrenceStatisticsCollectingRequired(true);
succNode->setOccurrenceStatisticsCollected(true);
CIndividualSaturationProcessNodeLinker* indiProcessNodeLinker = CObjectAllocator< CIndividualSaturationProcessNodeLinker >::allocateAndConstruct(calcAlgContext->getTemporaryMemoryAllocationManager());
indiProcessNodeLinker->initProcessNodeLinker(succNode, true);
succIdentNodeLinker = indiProcessNodeLinker->append(succIdentNodeLinker);
++mCollectedOccStatsSuccNodeCount;
}
return true;
}, [&](CRole* role, bool inversed)->bool {
mOccStatsCacheWriter->incRoleInstanceOccurrencceStatistics(mOntology, role->getRoleTag(), 1, 0, 0, 1, 0, 0);
++mCollectedOccStatsRoleCount;
return true;
}, calcAlgContext);
collectConceptOccurrenceStatistics(indiProcessNode, calcAlgContext);
}
}
return true;
}
bool CSatisfiableTaskSaturationOccurrenceStatisticsCollector::collectConceptOccurrenceStatistics(CIndividualSaturationProcessNode* indiNode, CCalculationAlgorithmContext* calcAlgContext) {
CReapplyConceptSaturationLabelSet* conSet = indiNode->getReapplyConceptSaturationLabelSet(false);
if (conSet) {
for (CConceptSaturationDescriptor* conSatDesLinkerIt = conSet->getConceptSaturationDescriptionLinker(); conSatDesLinkerIt; conSatDesLinkerIt = conSatDesLinkerIt->getNext()) {
CConcept* concept = conSatDesLinkerIt->getConcept();
mOccStatsCacheWriter->incConceptInstanceOccurrencceStatistics(mOntology, concept->getConceptTag(), 1, 0, 0, 1);
++mCollectedOccStatsConceptCount;
}
return true;
}
return false;
}
}; // end namespace Algorithm
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude