/* * 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 "CSatisfiableTaskPropertyClassificationMessageAnalyser.h" namespace Konclude { namespace Reasoner { namespace Kernel { namespace Algorithm { CSatisfiableTaskPropertyClassificationMessageAnalyser::CSatisfiableTaskPropertyClassificationMessageAnalyser() { } bool CSatisfiableTaskPropertyClassificationMessageAnalyser::readCalculationConfig(CCalculationConfigurationExtension *config) { if (config) { return true; } return false; } CIndividualProcessNode* CSatisfiableTaskPropertyClassificationMessageAnalyser::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; } CClassificationMessageData* CSatisfiableTaskPropertyClassificationMessageAnalyser::extractPossibleSubsumptionInformation(CRole* testingRole, CIndividualProcessNode* indiNode, CReapplyConceptLabelSet* conSet, CCalculationAlgorithmContext* calcAlgContext) { STATINC(ANALYSEPOSSIBLESUBSUMPTIONSCOUNT,calcAlgContext); CClassificationMessageData* messageDataLinker = nullptr; // initialize possible subsumption list CPROPERTYPOSSIBLESUBSUMPTIONMESSAGELIST* 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(); CRole* markerRole = concept->getRole(); if (!negated && concept->getOperatorCode() == CCMARKER && markerRole && markerRole != testingRole) { if (!possSubsumerList) { possSubsumerList = CObjectParameterizingAllocator< CPROPERTYPOSSIBLESUBSUMPTIONMESSAGELIST,CContext* >::allocateAndConstructAndParameterize(mTempMemAllocMan,mTmpContext); } CClassificationInitializePossiblePropertySubsumptionData* possSubsumData = CObjectAllocator< CClassificationInitializePossiblePropertySubsumptionData >::allocateAndConstruct(mTempMemAllocMan); possSubsumData->initClassificationPossibleSubsumptionData(markerRole); possSubsumerList->append(possSubsumData); } conSetIt.moveNext(); } CClassificationInitializePossiblePropertySubsumptionMessageData* possSubsumMessageData = CObjectAllocator::allocateAndConstruct(mTempMemAllocMan); possSubsumMessageData->initClassificationPossibleSubsumptionMessageData(testingRole,possSubsumerList); messageDataLinker = possSubsumMessageData->append(messageDataLinker); return messageDataLinker; } bool CSatisfiableTaskPropertyClassificationMessageAnalyser::analyseSatisfiableTask(CSatisfiableCalculationTask* statCalcTask, CCalculationAlgorithmContext* calcAlgContext) { mStatCalcTask = statCalcTask; CSatisfiableTaskClassificationRoleMarkedMessageAdapter* classMessRoleMarkedAdapter = statCalcTask->getSatisfiableClassificationRoleMarkedMessageAdapter(); if (classMessRoleMarkedAdapter) { CClassificationMessageDataObserver* roleMessClassObserver = classMessRoleMarkedAdapter->getRoleClassificationMessageDataObserver(); CClassificationMessageData* subsumMessageDataLinker = nullptr; CClassificationMessageData* possSubsumMessageDataLinker = nullptr; CClassificationMessageData* pmMessageDataLinker = nullptr; CTaskProcessorContext* taskProcessorContext = calcAlgContext->getUsedTaskProcessorContext(); CTaskHandleMemoryAllocationManager* taskMemMan = calcAlgContext->getTemporaryMemoryAllocationManager(); CRole* testingRole = classMessRoleMarkedAdapter->getTestingRole(); CIndividual* markerIndi = classMessRoleMarkedAdapter->getMarkerIndividual(); //QString iriClassNameString = CIRIName::getRecentIRIName(testingConcept->getClassNameLinker()); //if (iriClassNameString == "http://www.owllink.org/testsuite/galen#LowerLobeOfLeftLung") { // bool bug = true; //} //} //considerOtherNode = false; CConcreteOntology* testOntology = classMessRoleMarkedAdapter->getTestingOntology(); CProcessingDataBox* processingDataBox = statCalcTask->getProcessingDataBox(); CIndividualProcessNodeVector* indiNodeVec = processingDataBox->getIndividualProcessNodeVector(); cint64 maxDetBranchTag = processingDataBox->getMaximumDeterministicBranchTag(); if (testOntology && testingRole && markerIndi) { cint64 markerIndiID = markerIndi->getIndividualID(); CIndividualProcessNode* markerIndiNode = indiNodeVec->getData(-markerIndiID); bool nondetMerged = false; markerIndiNode = getCorrectedIndividualID(markerIndiNode,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); CPROPERTYSUBSUMPTIONMESSAGELIST* subsumerList = nullptr; CReapplyConceptLabelSet* conSet = markerIndiNode->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(); CRole* markerRole = concept->getRole(); if (!negated && concept->getOperatorCode() == CCMARKER && markerRole) { CDependencyTrackPoint* depTrackPoint = conSetIt.getDependencyTrackPoint(); bool deterministic = false; if (depTrackPoint) { if (depTrackPoint->getBranchingTag() <= maxDetBranchTag) { deterministic = true; } } if (deterministic && markerRole != testingRole) { if (!subsumerList) { subsumerList = CObjectParameterizingAllocator< CPROPERTYSUBSUMPTIONMESSAGELIST,CContext* >::allocateAndConstructAndParameterize(mTempMemAllocMan,mTmpContext); } subsumerList->append(markerRole); } } } conSetIt.moveNext(); } CClassificationMessageData* messageData = extractPossibleSubsumptionInformation(testingRole,markerIndiNode,conSet,calcAlgContext); if (messageData) { possSubsumMessageDataLinker = messageData->append(possSubsumMessageDataLinker); } } CClassificationPropertySubsumptionMessageData* subsumMessageData = CObjectAllocator::allocateAndConstruct(mTempMemAllocMan); subsumMessageData->initClassificationSubsumptionMessageData(testingRole,subsumerList); subsumMessageDataLinker = subsumMessageData->append(subsumMessageDataLinker); subsumerList = nullptr; CClassificationMessageData* messageDataLinker = subsumMessageDataLinker; if (pmMessageDataLinker) { messageDataLinker = pmMessageDataLinker->append(messageDataLinker); } if (possSubsumMessageDataLinker) { messageDataLinker = possSubsumMessageDataLinker->append(messageDataLinker); } if (messageDataLinker) { roleMessClassObserver->tellClassificationMessage(testOntology,messageDataLinker,memPoolCon.takeMemoryPools()); } else { taskMemMan->releaseTemporaryMemoryPools(memPoolCon.takeMemoryPools()); } return true; } } return false; } }; // end namespace Algorithm }; // end namespace Kernel }; // end namespace Reasoner }; // end namespace Konclude