/*
* 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 "COptimizedKPSetRoleSubsumptionClassifierThread.h"
namespace Konclude {
namespace Reasoner {
namespace Classifier {
COptimizedKPSetRoleSubsumptionClassifierThread::COptimizedKPSetRoleSubsumptionClassifierThread(CReasonerManager *reasonerManager, bool dataRoleClassification)
: CSubsumptionClassifierThread(reasonerManager), CLogIdentifier("::Konclude::Reasoner::Kernel::Classifier::OptimizedKPSetRoleSubsumptionClassifierThread",this) {
satTestedCount = 0;
totalToSatTestClassCount = 0;
mClassificationCount = 0;
subsumTestedCount = 0;
totalToSubsumTestCount = 0;
mConfPossSubsumCalcOrderRoleSorted = true;
mConfPossSubsumCalcOrderFewestSubsumptionSorted = false;
mConfPossSubsumCalcOrderTopDown = true;
mConfPossSubsumCalcOrderBottomUp = false;
mConfPossSubsumPseudoModelPretest = true;
mConfPossSubsumPseudoModelTest = true;
mConfWriteDebuggingData = false;
mStatProcesedSubsumMessCount = 0;
mStatProcesedPossSubsumInitMessCount = 0;
mStatProcesedPossSubsumUpdateMessCount = 0;
mStatProcesedPseudoModelMessCount = 0;
mInterpretedSubsumptionCalculationCount = 0;
mOrderedSubsumptionCalculationCount = 0;
mPseudoModelPretestSubsumptionCalculationCount = 0;
mCreatedCalculationTaskCount = 0;
mRecievedCallbackCount = 0;
mDataRolesClassification = dataRoleClassification;
}
COptimizedKPSetRoleSubsumptionClassifierThread::~COptimizedKPSetRoleSubsumptionClassifierThread() {
}
CRolePropertiesHierarchy *COptimizedKPSetRoleSubsumptionClassifierThread::createInitialHierarchyForOntology(CConcreteOntology *ontology, CConfigurationBase *config) {
CRBox* rBox = ontology->getRBox();
CRole* topRole = nullptr;
CRole* bottomRole = nullptr;
bool classifyDataRoles = mDataRolesClassification;
if (classifyDataRoles) {
topRole = rBox->getTopDataRole();
bottomRole = rBox->getBottomDataRole();
} else {
topRole = rBox->getTopObjectRole();
bottomRole = rBox->getBottomObjectRole();
}
CRolePropertiesHierarchy *hierarchy = new CRolePropertiesHierarchy(topRole,bottomRole);
return hierarchy;
}
void COptimizedKPSetRoleSubsumptionClassifierThread::readCalculationConfig(CCalculationConfigurationExtension *config) {
if (config) {
bool configErrorFlag = false;
cint64 processorCount = 1;
QString processorCountString = CConfigDataReader::readConfigString(config,"Konclude.Calculation.ProcessorCount",QString(),&configErrorFlag);
if (!configErrorFlag) {
if (processorCountString == "AUTO") {
processorCount = CThread::idealThreadCount();
} else {
qint64 convertedWorkerCount = processorCountString.toInt(&configErrorFlag);
if (configErrorFlag) {
processorCount = convertedWorkerCount;
}
}
}
bool mulConfigErrorFlag = false;
cint64 multiplicator = CConfigDataReader::readConfigInteger(config,"Konclude.Calculation.Classification.OptimizedKPSetRoleSubsumptionClassifier.MultipliedUnitsParallelSatisfiableCalculationCount",1,&mulConfigErrorFlag);
confMaxTestParallelCount = processorCount*multiplicator;
bool maxConfigErrorFlag = false;
cint64 maxParallel = CConfigDataReader::readConfigInteger(config,"Konclude.Calculation.Classification.OptimizedKPSetRoleSubsumptionClassifier.MaximumParallelSatisfiableCalculationCount",1,&maxConfigErrorFlag);
if (!maxConfigErrorFlag) {
if (!mulConfigErrorFlag) {
confMaxTestParallelCount = qMin(confMaxTestParallelCount,maxParallel);
} else {
confMaxTestParallelCount = maxParallel;
}
}
double factor = CConfigDataReader::readConfigInteger(config,"Konclude.Calculation.Classification.OptimizedKPSetRoleSubsumptionClassifier.ParallelSatisfiableCalculationCreationFactor",1000)/1000.;
confMinTestParallelCount = confMaxTestParallelCount*factor;
mConfWriteDebuggingData = CConfigDataReader::readConfigBoolean(config,"Konclude.Debugging.WriteDebuggingData",false);
} else {
confMaxTestParallelCount = 1;
confMinTestParallelCount = 1;
mConfWriteDebuggingData = false;
}
}
COptimizedKPSetRoleSubsumptionClassifierThread* COptimizedKPSetRoleSubsumptionClassifierThread::createInitialSubsumptionSatisfiabilityTestingOrderFromBuildData(COptimizedKPSetRoleOntologyClassificationItem* ontPropItem) {
CConcreteOntology* ontology = ontPropItem->getOntology();
CConcept* topConcept = ontology->getTBox()->getTopConcept();
CRBox *rBox = ontology->getRBox();
CRole* topRole = nullptr;
CRole* bottomRole = nullptr;
bool classifyDataRoles = ontPropItem->isDataRolesClassification();
if (classifyDataRoles) {
topRole = rBox->getTopDataRole();
bottomRole = rBox->getBottomDataRole();
} else {
topRole = rBox->getTopObjectRole();
bottomRole = rBox->getBottomObjectRole();
}
cint64 satRoleCount = 1;
CBOXSET* activeRoleHash = rBox->getActivePropertyRoleSet(false);
if (activeRoleHash) {
for (CBOXSET::const_iterator it = activeRoleHash->constBegin(), itEnd = activeRoleHash->constEnd(); it != itEnd; ++it) {
CRole *role = (*it);
if (role->isDataRole() == classifyDataRoles) {
if (role && role != topRole && role != bottomRole) {
++satRoleCount;
ontPropItem->getRoleSatisfiableTestItem(role,true);
}
}
}
}
CClassifierStatistics* statistics = ontPropItem->getClassifierStatistics();
statistics->incTotalSatisfiableTestCount(satRoleCount);
COptimizedKPSetRoleTestingItem* topRoleItem = ontPropItem->getRoleSatisfiableTestItem(topRole,true);
COptimizedKPSetRoleTestingItem* bottomRoleItem = ontPropItem->getRoleSatisfiableTestItem(bottomRole,true);
ontPropItem->initTopBottomSatisfiableTestingItems(topRoleItem,bottomRoleItem);
CConcept* univConnNomValueConcept = ontology->getTBox()->getUniversalConnectionNominalValueConcept();
QList* nextItemList = ontPropItem->getNextSatisfiableTestingItemList();
QSet* nextCandItemSet = ontPropItem->getNextCandidateSatisfiableTestingItemSet();
QSet* remainingCandItemSet = ontPropItem->getRemainingCandidateSatisfiableTestingItemSet();
QList* roleItemList = ontPropItem->getRoleSatisfiableTestItemList();
for (QList::const_iterator it = roleItemList->constBegin(), itEnd = roleItemList->constEnd(); it != itEnd; ++it) {
COptimizedKPSetRoleTestingItem* roleItem(*it);
if (roleItem != bottomRoleItem) {
CRole* role = roleItem->getTestingRole();
bool complex = false;
for (CSortedNegLinker* superRoleIt = role->getIndirectSuperRoleList(); superRoleIt; superRoleIt = superRoleIt->getNext()) {
CRole* superRole = superRoleIt->getData();
if (!superRoleIt->isNegated() && superRole != topRole && superRole != role) {
COptimizedKPSetRoleTestingItem* superRoleItem = ontPropItem->getRoleSatisfiableTestItem(superRole);
if (superRoleItem) {
roleItem->addSubsumerRoleItem(superRoleItem);
}
}
if (superRole->getDomainConceptList()) {
complex = true;
}
if (superRole->getRangeConceptList()) {
complex = true;
}
if (topConcept->getOperandList() || univConnNomValueConcept) {
complex = true;
}
}
cint64 foundSubsumerCount = 0;
ontPropItem->incRemainingSatisfiableTestsCount();
if (!complex) {
roleItem->setResultSatisfiableDerivated(true);
roleItem->setPossibleSubsumptionMapInitialized(true);
} else {
for (CSortedNegLinker* superRoleIt = role->getSuperRoleList(); superRoleIt; superRoleIt = superRoleIt->getNext()) {
CRole* superRole = superRoleIt->getData();
if (!superRoleIt->isNegated()) {
COptimizedKPSetRoleTestingItem* superRoleItem = ontPropItem->getRoleSatisfiableTestItem(superRole);
if (superRoleItem) {
foundSubsumerCount++;
superRoleItem->addSuccessorSatisfiableTestItem(roleItem);
roleItem->incUnprocessedPredecessorItems();
}
}
}
}
if (foundSubsumerCount) {
nextItemList->append(roleItem);
} else {
nextCandItemSet->insert(roleItem);
}
}
}
return this;
}
CConcept* COptimizedKPSetRoleSubsumptionClassifierThread::createTemporaryConcept(CConcreteOntology* tmpRoleRealOntology) {
CConceptVector* conVec = tmpRoleRealOntology->getTBox()->getConceptVector();
CConcept* concept = CObjectAllocator< CConcept >::allocateAndConstruct(tmpRoleRealOntology->getOntologyContext()->getMemoryAllocationManager());
concept->initConcept();
cint64 newConTag = tmpRoleRealOntology->getTBox()->getNextConceptID();
concept->setConceptTag(newConTag);
conVec->setData(concept->getConceptTag(),concept);
return concept;
}
void COptimizedKPSetRoleSubsumptionClassifierThread::addTemporaryConceptOperand(CConcept* concept, CConcept* opConcept, bool negated, CConcreteOntology* tmpRoleRealOntology) {
CSortedNegLinker* opConLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(tmpRoleRealOntology->getOntologyContext()->getMemoryAllocationManager());
opConLinker->init(opConcept,negated);
concept->addOperandLinker(opConLinker);
concept->incOperandCount();
}
COptimizedKPSetRoleSubsumptionClassifierThread* COptimizedKPSetRoleSubsumptionClassifierThread::createTemporaryRoleClassificationOntology(COptimizedKPSetRoleOntologyClassificationItem* item) {
CConcreteOntology* ontology = item->getOntology();
CConcreteOntology* tmpRoleRealOntology = item->getTemporaryRoleClassificationOntology();
if (!tmpRoleRealOntology) {
tmpRoleRealOntology = new CConcreteOntology(ontology,ontology->getConfiguration());
tmpRoleRealOntology->setOntologyID(ontology->getOntologyID());
tmpRoleRealOntology->setConsistence(ontology->getConsistence());
tmpRoleRealOntology->getTBox()->setMinimalNextConceptID(ontology->getTBox()->getMinimalNextConceptID());
QSet compTransformConceptSet;
QHash* markerConRolInsItemHash = item->getMarkerConceptInstancesItemHash();
CABox* abox = item->getOntology()->getABox();
CABox* tempRoleRealAbox = tmpRoleRealOntology->getABox();
CIndividualVector* indiVec = tempRoleRealAbox->getIndividualVector(true);
CIndividual* tmpIndiProp = new CIndividual();
tmpIndiProp->initIndividual(tempRoleRealAbox->getNextIndividualId(true));
indiVec->setData(tmpIndiProp->getIndividualID(),tmpIndiProp);
CIndividual* tmpIndiMarker = new CIndividual();
tmpIndiMarker->initIndividual(tempRoleRealAbox->getNextIndividualId(true));
indiVec->setData(tmpIndiMarker->getIndividualID(),tmpIndiMarker);
tmpIndiProp->setTemporaryFakeIndividual(true);
tmpIndiMarker->setTemporaryFakeIndividual(true);
item->setTemporaryMarkerIndividual(tmpIndiMarker);
item->setTemporaryPropagationIndividual(tmpIndiProp);
CConcept* allPropConcept = createTemporaryConcept(tmpRoleRealOntology);
allPropConcept->setOperatorCode(CCAND);
COptimizedKPSetRoleTestingItem* topRoleInstItem = item->getTopRoleSatisfiableTestItem();
COptimizedKPSetRoleTestingItem* bottomRoleInstItem = item->getBottomRoleSatisfiableTestItem();
QList* roleItemList = item->getRoleSatisfiableTestItemList();
for (QList::const_iterator itemIt = roleItemList->constBegin(), itemItEnd = roleItemList->constEnd(); itemIt != itemItEnd; ++itemIt) {
COptimizedKPSetRoleTestingItem* roleItem(*itemIt);
if (roleItem != bottomRoleInstItem) {
CRole* role = roleItem->getTestingRole();
CConcept* markerConcept = createTemporaryConcept(tmpRoleRealOntology);
markerConcept->setOperatorCode(CCMARKER);
markerConcept->setRole(role);
CConcept* existConcept = createTemporaryConcept(tmpRoleRealOntology);
existConcept->setOperatorCode(CCVALUE);
existConcept->setRole(role);
existConcept->setNominalIndividual(tmpIndiMarker);
roleItem->setTemporaryExistConcept(existConcept);
CConcept* propConcept = createTemporaryConcept(tmpRoleRealOntology);
propConcept->setOperatorCode(CCALL);
propConcept->setRole(role);
addTemporaryConceptOperand(propConcept,markerConcept,false,tmpRoleRealOntology);
addTemporaryConceptOperand(allPropConcept,propConcept,false,tmpRoleRealOntology);
roleItem->setTemporaryMarkerConcept(markerConcept);
markerConRolInsItemHash->insert(markerConcept,roleItem);
roleItem->setTemporaryPropagationConcept(propConcept);
if (role->isComplexRole()) {
compTransformConceptSet.insert(propConcept);
}
}
}
if (!compTransformConceptSet.isEmpty()) {
CPreProcessContextBase* preprocessContext = new CPreProcessContextBase(tmpRoleRealOntology,ontology->getConfiguration());
CRoleChainAutomataTransformationPreProcess* roleChainAutomataTransformPreprocessor = new CRoleChainAutomataTransformationPreProcess();
roleChainAutomataTransformPreprocessor->preprocess(tmpRoleRealOntology,&compTransformConceptSet,preprocessContext);
delete preprocessContext;
delete roleChainAutomataTransformPreprocessor;
}
item->setTemporaryRoleClassificationOntology(tmpRoleRealOntology);
item->setTemporaryAllPropagationConcept(allPropConcept);
}
return this;
}
CSubsumptionClassifierThread *COptimizedKPSetRoleSubsumptionClassifierThread::scheduleOntologyClassification(CConcreteOntology *ontology, CClassificationCalculationSupport *classificationSupport, CConfigurationBase *config) {
CRolePropertiesHierarchy* hierarchy = createInitialHierarchyForOntology(ontology,config);
COptimizedKPSetRoleOntologyClassificationItem *ontPropItem = new COptimizedKPSetRoleOntologyClassificationItem(config,statistics);
ontPropItem->initClassificationItem(ontology,hierarchy,mDataRolesClassification);
ontItemList.append(ontPropItem);
processingOntItemList.append(ontPropItem);
ontItemHash.insert(ontology,ontPropItem);
readCalculationConfig(ontPropItem->getCalculationConfiguration());
if (CConfigDataReader::readConfigBoolean(ontPropItem->getCalculationConfiguration(),"Konclude.Calculation.Classification.IndividualDependenceTracking",true)) {
ontPropItem->setIndividualDependenceTrackingCollector(new CIndividualDependenceTrackingCollector());
}
createInitialSubsumptionSatisfiabilityTestingOrderFromBuildData(ontPropItem);
createTemporaryRoleClassificationOntology(ontPropItem);
if (satTestedCount == totalToSatTestClassCount) {
satTestedCount = 0;
totalToSatTestClassCount = ontPropItem->getRemainingSatisfiableTestsCount();
classStartTime.start();
} else {
totalToSatTestClassCount += ontPropItem->getRemainingSatisfiableTestsCount();
}
++mClassificationCount;
return this;
}
QString COptimizedKPSetRoleSubsumptionClassifierThread::getStatusString() {
statUpdateMutex.lock();
QString string = statusString;
string.detach();
statUpdateMutex.unlock();
return string;
}
CClassificationProgress* COptimizedKPSetRoleSubsumptionClassifierThread::getClassificationProgress() {
if (satTestedCount != totalToSatTestClassCount || subsumTestedCount != totalToSubsumTestCount) {
cint64 tested = satTestedCount + subsumTestedCount;
cint64 total = totalToSatTestClassCount + totalToSubsumTestCount;
cint64 elapsedTime = classStartTime.elapsed();
double remainingMilliSeconds = 0.;
double progessPercent = 0.;
if (elapsedTime <= 0 && total > 0) {
remainingMilliSeconds = 0.;
} else {
remainingMilliSeconds = ((double)elapsedTime / (double)tested) * (total-tested);
}
if (total <= 0) {
progessPercent = 0.;
} else {
progessPercent = ((double)tested / (double)total) * 100.;
}
cint64 classificCount = mClassificationCount;
mClassifyProgess.setClassificationCount(classificCount);
mClassifyProgess.setProgessPercent(progessPercent);
mClassifyProgess.setRemainingMilliSeconds(remainingMilliSeconds);
mClassifyProgess.setTestedSatisfiable(satTestedCount);
mClassifyProgess.setTotalSatisfiable(totalToSatTestClassCount);
mClassifyProgess.setTestedSubsumptions(subsumTestedCount);
mClassifyProgess.setTotalSubsumptions(totalToSubsumTestCount);
} else {
mClassifyProgess.setProgessPercent(0.);
mClassifyProgess.setRemainingMilliSeconds(0.);
mClassifyProgess.setTestedSatisfiable(satTestedCount);
mClassifyProgess.setTotalSatisfiable(totalToSatTestClassCount);
mClassifyProgess.setTestedSubsumptions(subsumTestedCount);
mClassifyProgess.setTotalSubsumptions(totalToSubsumTestCount);
}
return &mClassifyProgess;
}
bool itemSortLessSubsumptionsThan(const COptimizedKPSetRoleTestingItem* item1, const COptimizedKPSetRoleTestingItem* item2) {
return item1->getSubsumerRoleItemCount() < item2->getSubsumerRoleItemCount();
}
bool itemSortMoreSubsumptionsThan(const COptimizedKPSetRoleTestingItem* item1, const COptimizedKPSetRoleTestingItem* item2) {
return item1->getSubsumerRoleItemCount() > item2->getSubsumerRoleItemCount();
}
void COptimizedKPSetRoleSubsumptionClassifierThread::testDebugPossibleSubsumerCorrectCounted(COptimizedKPSetRoleOntologyClassificationItem *optKPSetClassificationItem) {
QList* classList = optKPSetClassificationItem->getRoleSatisfiableTestItemList();
cint64 totalCount = 0;
foreach (COptimizedKPSetRoleTestingItem* item, *classList) {
COptimizedKPSetRolePossibleSubsumptionMap* possSubsumMap = item->getPossibleSubsumptionMap(false);
if (possSubsumMap) {
cint64 mapCount = 0;
for (COptimizedKPSetRolePossibleSubsumptionMap::const_iterator it = possSubsumMap->constBegin(), itEnd = possSubsumMap->constEnd(); it != itEnd; ++it) {
COptimizedKPSetRolePossibleSubsumptionData* data = it.value();
if (data->isSubsumptionUnknown() || data->isUpdateRequired()) {
mapCount++;
totalCount++;
}
}
if (mapCount != possSubsumMap->getRemainingPossibleSubsumptionCount()) {
bool bug = true;
}
}
}
if (totalCount != optKPSetClassificationItem->getRemainingPossibleSubsumptionTestsCount()) {
bool bug = true;
}
}
void COptimizedKPSetRoleSubsumptionClassifierThread::testDebugPossibleSubsumerCorrectReferenced(COptimizedKPSetRoleOntologyClassificationItem *optKPSetClassificationItem) {
QList* classList = optKPSetClassificationItem->getRoleSatisfiableTestItemList();
if (mConfPossSubsumCalcOrderBottomUp) {
QSet* remItemSet = optKPSetClassificationItem->getRemainingPossibleSubsumptionTestingSet();
foreach (COptimizedKPSetRoleTestingItem* item, *classList) {
COptimizedKPSetRolePossibleSubsumptionMap* possSubsumMap = item->getPossibleSubsumptionMap(false);
if (possSubsumMap) {
for (COptimizedKPSetRolePossibleSubsumptionMap::const_iterator it = possSubsumMap->constBegin(), itEnd = possSubsumMap->constEnd(); it != itEnd; ++it) {
COptimizedKPSetRolePossibleSubsumptionData* data = it.value();
if (data->isSubsumptionUnknown() || data->isUpdateRequired()) {
COptimizedKPSetRoleTestingItem* possSubsumerItem = data->getTestingItem();
if (!possSubsumerItem->getPossibleSubsumerSet(false)->contains(item) && !optKPSetClassificationItem->getCurrentPossibleSubsumptionTestingItemSet()->contains(possSubsumerItem)) {
bool bug = true;
}
if (!remItemSet->contains(possSubsumerItem) && !optKPSetClassificationItem->getCurrentPossibleSubsumptionTestingItemSet()->contains(possSubsumerItem)) {
bool bug = true;
}
}
}
}
}
}
}
QString COptimizedKPSetRoleSubsumptionClassifierThread::createDebugKPSetString(COptimizedKPSetRoleOntologyClassificationItem *optKPSetClassificationItem, const QString& filename) {
QString debugString;
QList* propertyList = optKPSetClassificationItem->getRoleSatisfiableTestItemList();
foreach (COptimizedKPSetRoleTestingItem* item, *propertyList) {
QString iriPropertyNameString = CIRIName::getRecentIRIName(item->getTestingRole()->getPropertyNameLinker());
QString propertyDebugString = QString("Property: %1\r\n").arg(iriPropertyNameString);
QString subsumString;
foreach (COptimizedKPSetRoleTestingItem* subsumItem, *item->getSubsumerRoleItemList()) {
QString subsumIRIPropertyNameString = CIRIName::getRecentIRIName(subsumItem->getTestingRole()->getPropertyNameLinker());
if (subsumString.isEmpty()) {
subsumString += subsumIRIPropertyNameString;
} else {
subsumString += QString(", %1").arg(subsumIRIPropertyNameString);
}
}
propertyDebugString += QString("Subsumer Roles: %1\r\n").arg(subsumString);
QString possSubsumString;
COptimizedKPSetRolePossibleSubsumptionMap* possSubsumMap = item->getPossibleSubsumptionMap(false);
if (possSubsumMap) {
for (COptimizedKPSetRolePossibleSubsumptionMap::const_iterator it = possSubsumMap->constBegin(), itEnd = possSubsumMap->constEnd(); it != itEnd; ++it) {
COptimizedKPSetRolePossibleSubsumptionData* data = it.value();
QString subsumIRIPropertyNameString = CIRIName::getRecentIRIName(data->getTestingItem()->getTestingRole()->getPropertyNameLinker());
QString possString;
if (data->isSubsumptionConfirmed()) {
possString = "s";
} else if (data->isSubsumptionInvalided()) {
possString = "n";
} else {
possString = "u";
}
if (possSubsumString.isEmpty()) {
possSubsumString += QString("%1(%2)").arg(subsumIRIPropertyNameString).arg(possString);
} else {
possSubsumString += QString(", %1(%2)").arg(subsumIRIPropertyNameString).arg(possString);
}
}
}
propertyDebugString += QString("Possible Subsumer Roles: %1\r\n\r\n\r\n").arg(possSubsumString);
debugString += propertyDebugString;
}
QFile file(filename);
if (file.open(QIODevice::WriteOnly)) {
file.write(debugString.toLocal8Bit());
file.close();
}
return debugString;
}
bool COptimizedKPSetRoleSubsumptionClassifierThread::createNextSubsumtionTest() {
COntologyPropertyRoleClassificationItem *loopontPropItem = 0;
bool workTestCreated = false;
while (!workTestCreated && !processingOntItemList.isEmpty()) {
COptimizedKPSetRoleOntologyClassificationItem *ontPropItem = (COptimizedKPSetRoleOntologyClassificationItem*)processingOntItemList.first();
if (ontPropItem == loopontPropItem) {
// don't run into infinite loop without doing something
break;
}
COptimizedKPSetRoleOntologyClassificationItem *optKPSetClassificationItem = (COptimizedKPSetRoleOntologyClassificationItem *)ontPropItem;
if (!optKPSetClassificationItem->hasSatisfiableTestingPhaseFinished() && !ontPropItem->isHierarchyConstructionFailed()) {
while (!workTestCreated && optKPSetClassificationItem->hasRemainingSatisfiableTests()) {
// get next satisfiable test
QList* nextItemList = optKPSetClassificationItem->getNextSatisfiableTestingItemList();
QSet* nextCandItemSet = optKPSetClassificationItem->getNextCandidateSatisfiableTestingItemSet();
QSet* remainingCandItemSet = optKPSetClassificationItem->getRemainingCandidateSatisfiableTestingItemSet();
COptimizedKPSetRoleTestingItem* nextSatTestItem = nullptr;
if (!nextItemList->isEmpty()) {
nextSatTestItem = nextItemList->takeFirst();
remainingCandItemSet->remove(nextSatTestItem);
nextCandItemSet->remove(nextSatTestItem);
} else if (!nextCandItemSet->isEmpty()) {
COptimizedKPSetRoleTestingItem* minItem = nullptr;
cint64 minUnpPredCount = 0;
for (QSet::const_iterator it = nextCandItemSet->constBegin(), itEnd = nextCandItemSet->constEnd(); it != itEnd; ++it) {
COptimizedKPSetRoleTestingItem* item = (*it);
cint64 predCount = item->getUnprocessedPredecessorItemCount();
if (!minItem || minUnpPredCount < predCount) {
minUnpPredCount = predCount;
minItem = item;
}
}
nextSatTestItem = minItem;
remainingCandItemSet->remove(nextSatTestItem);
nextCandItemSet->remove(nextSatTestItem);
} else if (!remainingCandItemSet->isEmpty()) {
COptimizedKPSetRoleTestingItem* minItem = nullptr;
QSet::const_iterator itNext = remainingCandItemSet->constBegin();
nextSatTestItem = *itNext;
remainingCandItemSet->remove(nextSatTestItem);
}
if (nextSatTestItem && !nextSatTestItem->isSatisfiableTestOrdered()) {
optKPSetClassificationItem->decRemainingSatisfiableTestsCount();
optKPSetClassificationItem->incRunningSatisfiableTestsCount();
if (calculateSatisfiable(optKPSetClassificationItem,nextSatTestItem)) {
workTestCreated = true;
} else {
interpreteSatisfiableResult(optKPSetClassificationItem,nextSatTestItem->getTestingRole(),nextSatTestItem->getSatisfiableTestedResult());
}
}
}
if (!workTestCreated) {
if (optKPSetClassificationItem->hasAllSatisfiableTestsCompleted()) {
optKPSetClassificationItem->setSatisfiableTestingPhaseFinished(true);
// initialize possible subsumption testing phase
cint64 remainingSubSumTestCount = 0;
QSet* remTestingSet = optKPSetClassificationItem->getRemainingPossibleSubsumptionTestingSet();
QList* nextItemList = optKPSetClassificationItem->getNextPossibleSubsumptionTestingItemList();
COptimizedKPSetRoleTestingItem* topItem = optKPSetClassificationItem->getTopRoleSatisfiableTestItem();
COptimizedKPSetRoleTestingItem* bottomItem = optKPSetClassificationItem->getBottomRoleSatisfiableTestItem();
topItem->setPropagationConnected(true);
QList propList(*optKPSetClassificationItem->getRoleSatisfiableTestItemList());
qSort(propList.begin(),propList.end(),itemSortLessSubsumptionsThan);
QList resevePossSubsumClassList;
foreach (COptimizedKPSetRoleTestingItem* item, propList) {
COptimizedKPSetRolePossibleSubsumptionMap* possSubSumMap = item->getPossibleSubsumptionMap(false);
if (possSubSumMap && possSubSumMap->hasRemainingPossibleSubsumptions()) {
if (mConfPossSubsumCalcOrderTopDown) {
nextItemList->append(item);
remTestingSet->insert(item);
}
remainingSubSumTestCount += possSubSumMap->getRemainingPossibleSubsumptionCount();
resevePossSubsumClassList.append(item);
}
if (!item->isPossibleSubsumptionMapInitialized()) {
bool bug = true;
}
QList* subsumerList = item->getSubsumerRoleItemList();
COptimizedKPSetRoleTestingItem* maxSubsumerItem = nullptr;
cint64 maxSubsumerCount = 0;
for (QList::const_iterator it = subsumerList->constBegin(), itEnd = subsumerList->constEnd(); it != itEnd; ++it) {
COptimizedKPSetRoleTestingItem* subsumerItem = *it;
if (!maxSubsumerItem || subsumerItem->getSubsumerRoleItemCount() > maxSubsumerCount) {
maxSubsumerCount = subsumerItem->getSubsumerRoleItemCount();
maxSubsumerItem = subsumerItem;
}
}
if (!maxSubsumerItem) {
maxSubsumerItem = topItem;
}
bool upPropConnected = false;
QSet* upPropSet = item->getUpPropagationItemSet();
if (item != topItem) {
upPropSet->insert(maxSubsumerItem);
maxSubsumerItem->addDownPropagationItem(item);
upPropConnected |= maxSubsumerItem->isPropagationConnected();
}
for (QList::const_iterator itSub = subsumerList->constBegin(), itSubEnd = subsumerList->constEnd(); itSub != itSubEnd; ++itSub) {
COptimizedKPSetRoleTestingItem* subsumerItem = *itSub;
bool alreadySubsumed = false;
for (QSet::const_iterator itProp = upPropSet->constBegin(), itPropEnd = upPropSet->constEnd(); !alreadySubsumed && itProp != itPropEnd; ++itProp) {
COptimizedKPSetRoleTestingItem* propItem = *itProp;
if (propItem == subsumerItem || propItem->hasSubsumerRoleItem(subsumerItem)) {
alreadySubsumed = true;
}
}
if (!alreadySubsumed) {
upPropSet->insert(subsumerItem);
subsumerItem->addDownPropagationItem(item);
upPropConnected |= subsumerItem->isPropagationConnected();
}
}
if (!upPropConnected) {
for (QList::const_iterator itSub = subsumerList->constBegin(), itSubEnd = subsumerList->constEnd(); itSub != itSubEnd && !upPropConnected; ++itSub) {
COptimizedKPSetRoleTestingItem* subsumerItem = *itSub;
if (subsumerItem->isPropagationConnected()) {
upPropSet->insert(subsumerItem);
subsumerItem->addDownPropagationItem(item);
upPropConnected |= subsumerItem->isPropagationConnected();
}
}
if (!upPropConnected) {
upPropSet->insert(topItem);
topItem->addDownPropagationItem(item);
upPropConnected |= topItem->isPropagationConnected();
}
}
item->setPropagationConnected(upPropConnected);
}
foreach (COptimizedKPSetRoleTestingItem* item, propList) {
COptimizedKPSetRolePossibleSubsumptionMap* possSubsumMap = item->getPossibleSubsumptionMap(false);
QSet* upPropSet = item->getUpPropagationItemSet();
if (!possSubsumMap && item->isPossibleSubsumptionMapInitialized()) {
for (QSet::const_iterator itProp = upPropSet->constBegin(), itPropEnd = upPropSet->constEnd(); itProp != itPropEnd; ++itProp) {
COptimizedKPSetRoleTestingItem* upPropItem = *itProp;
COptimizedKPSetRolePossibleSubsumptionMap* upPropItemPossSubsumMap = upPropItem->getPossibleSubsumptionMap(false);
if (upPropItemPossSubsumMap) {
for (COptimizedKPSetRolePossibleSubsumptionMap::const_iterator itUpPoss = upPropItemPossSubsumMap->constBegin(), itUpPossEnd = upPropItemPossSubsumMap->constEnd(); itUpPoss != itUpPossEnd; ++itUpPoss) {
COptimizedKPSetRolePossibleSubsumptionData* upPossData = itUpPoss.value();
if (!item->hasSubsumerRoleItem(upPossData->getTestingItem()) && item != upPossData->getTestingItem()) {
if (!upPossData->isSubsumptionInvalided()) {
upPossData->setSubsumptionInvalid(true);
if (upPossData->isUpdateRequired()) {
prunePossibleSubsumptions(optKPSetClassificationItem,upPropItem,upPossData);
}
}
}
}
}
}
} else {
for (QSet::const_iterator itProp = upPropSet->constBegin(), itPropEnd = upPropSet->constEnd(); itProp != itPropEnd; ++itProp) {
COptimizedKPSetRoleTestingItem* upPropItem = *itProp;
COptimizedKPSetRolePossibleSubsumptionMap* upPropItemPossSubsumMap = upPropItem->getPossibleSubsumptionMap(false);
if (upPropItemPossSubsumMap) {
COptimizedKPSetRolePossibleSubsumptionMap::const_iterator itUpPoss = upPropItemPossSubsumMap->constBegin(), itUpPossEnd = upPropItemPossSubsumMap->constEnd();
if (possSubsumMap) {
COptimizedKPSetRolePossibleSubsumptionMap::const_iterator itPoss = possSubsumMap->constBegin(), itPossEnd = possSubsumMap->constEnd();
while (itPoss != itPossEnd && itUpPoss != itUpPossEnd) {
CRole* possRole = itPoss.key().getRole();
CRole* possUpRole = itUpPoss.key().getRole();
if (possRole->getRoleTag() == possUpRole->getRoleTag()) {
++itPoss;
++itUpPoss;
} else if (possRole->getRoleTag() < possUpRole->getRoleTag()) {
++itPoss;
} else if (possRole->getRoleTag() > possUpRole->getRoleTag()) {
COptimizedKPSetRolePossibleSubsumptionData* upPossData = itUpPoss.value();
if (!item->hasSubsumerRoleItem(upPossData->getTestingItem()) && item != upPossData->getTestingItem()) {
if (!upPossData->isSubsumptionInvalided()) {
upPossData->setSubsumptionInvalid(true);
if (upPossData->isUpdateRequired()) {
prunePossibleSubsumptions(optKPSetClassificationItem,upPropItem,upPossData);
}
}
}
++itUpPoss;
}
}
}
while (itUpPoss != itUpPossEnd) {
COptimizedKPSetRolePossibleSubsumptionData* upPossData = itUpPoss.value();
if (!item->hasSubsumerRoleItem(upPossData->getTestingItem()) && item != upPossData->getTestingItem()) {
if (!upPossData->isSubsumptionInvalided()) {
upPossData->setSubsumptionInvalid(true);
if (upPossData->isUpdateRequired()) {
prunePossibleSubsumptions(optKPSetClassificationItem,upPropItem,upPossData);
}
}
}
++itUpPoss;
}
}
}
}
}
foreach (COptimizedKPSetRoleTestingItem* item, resevePossSubsumClassList) {
COptimizedKPSetRolePossibleSubsumptionMap* possSubsumMap = item->getPossibleSubsumptionMap(false);
if (possSubsumMap) {
if (possSubsumMap->hasRemainingPossibleSubsumptions()) {
for (COptimizedKPSetRolePossibleSubsumptionMap::const_iterator it = possSubsumMap->constBegin(), itEnd = possSubsumMap->constEnd(); it != itEnd; ++it) {
COptimizedKPSetRolePossibleSubsumptionData* possSubsumData = it.value();
if (mConfPossSubsumCalcOrderBottomUp) {
if (possSubsumData->isSubsumptionUnknown() || possSubsumData->isUpdateRequired()) {
COptimizedKPSetRoleTestingItem* possSubsumerItem = possSubsumData->getTestingItem();
possSubsumerItem->getPossibleSubsumerSet(true)->insert(item);
if (!remTestingSet->contains(possSubsumerItem)) {
remTestingSet->insert(possSubsumerItem);
nextItemList->append(possSubsumerItem);
}
}
}
}
}
}
}
if (mConfPossSubsumCalcOrderBottomUp) {
for (QSet::const_iterator it = remTestingSet->constBegin(), itEnd = remTestingSet->constEnd(); it != itEnd; ++it) {
COptimizedKPSetRoleTestingItem* possSubsumerItem = *it;
QList* subsumersSortedList = new QList(possSubsumerItem->getPossibleSubsumerSet(false)->toList());
qSort(subsumersSortedList->begin(),subsumersSortedList->end(),itemSortMoreSubsumptionsThan);
possSubsumerItem->setPossibleSubsumedList(subsumersSortedList);
}
}
if (mConfWriteDebuggingData) {
createDebugKPSetString(optKPSetClassificationItem,"./Debugging/Classification/propertykpsets-inital-pruned.txt");
}
}
}
}
if (optKPSetClassificationItem->hasSatisfiableTestingPhaseFinished() && !optKPSetClassificationItem->hasPossibleSubsumptionTestingPhaseFinished() && !ontPropItem->isHierarchyConstructionFailed()) {
QList* nextItemList = optKPSetClassificationItem->getNextPossibleSubsumptionTestingItemList();
QSet* currentItemSet = optKPSetClassificationItem->getCurrentPossibleSubsumptionTestingItemSet();
bool canContinueSearchingForTests = true;
while (!workTestCreated && optKPSetClassificationItem->hasRemainingPossibleSubsumptionTests() && canContinueSearchingForTests) {
// get next possible subsumption test
canContinueSearchingForTests = false;
COptimizedKPSetRoleTestingItem* nextPossSubsumTestItem = nullptr;
if (!nextItemList->isEmpty()) {
nextPossSubsumTestItem = nextItemList->takeFirst();
}
if (nextPossSubsumTestItem) {
canContinueSearchingForTests = true;
if (mConfPossSubsumCalcOrderTopDown) {
COptimizedKPSetRolePossibleSubsumptionMap* possSubsumerMap = nextPossSubsumTestItem->getPossibleSubsumptionMap(false);
if (possSubsumerMap && possSubsumerMap->hasRemainingPossibleSubsumptions()) {
COptimizedKPSetRolePossibleSubsumptionData* possSubsumCalcData = getNextPossibleSubsumptionCalculation(optKPSetClassificationItem,nextPossSubsumTestItem);
if (possSubsumCalcData) {
currentItemSet->insert(nextPossSubsumTestItem);
optKPSetClassificationItem->incRunningPossibleSubsumptionTestsCount();
if (calculateSubsumption(optKPSetClassificationItem,nextPossSubsumTestItem,possSubsumCalcData->getTestingItem(),possSubsumCalcData)) {
workTestCreated = true;
} else {
interpreteSubsumptionResult(optKPSetClassificationItem,nextPossSubsumTestItem->getTestingRole(),possSubsumCalcData->getTestingItem()->getTestingRole(),possSubsumCalcData->isSubsumptionConfirmed());
}
}
} else {
QSet* remTestingSet = optKPSetClassificationItem->getRemainingPossibleSubsumptionTestingSet();
remTestingSet->remove(nextPossSubsumTestItem);
}
} else if (mConfPossSubsumCalcOrderBottomUp) {
COptimizedKPSetRolePossibleSubsumptionData* possSubsumCalcData = nullptr;
COptimizedKPSetRoleTestingItem* possSubsumedItem = nullptr;
CRole* possSubsumerRole = nextPossSubsumTestItem->getTestingRole();
CRole* candidateRole = possSubsumerRole;
QList* possSubsumedSortedList = nextPossSubsumTestItem->getPossibleSubsumerList();
if (possSubsumedSortedList && !possSubsumedSortedList->isEmpty()) {
while (!possSubsumCalcData && !possSubsumedSortedList->isEmpty()) {
possSubsumedItem = possSubsumedSortedList->takeFirst();
if (nextPossSubsumTestItem->getPossibleSubsumerSet(false)->contains(possSubsumedItem)) {
nextPossSubsumTestItem->getPossibleSubsumerSet(false)->remove(possSubsumedItem);
COptimizedKPSetRolePossibleSubsumptionMap* possSubsumerMap = possSubsumedItem->getPossibleSubsumptionMap(false);
if (possSubsumerMap && possSubsumerMap->hasRemainingPossibleSubsumptions()) {
possSubsumCalcData = possSubsumerMap->value(CRoleTagComparer(candidateRole));
}
}
}
}
if (possSubsumCalcData) {
//if ((possSubsumCalcData->isUpdateRequired() || possSubsumCalcData->isSubsumptionUnknown())) {
currentItemSet->insert(nextPossSubsumTestItem);
optKPSetClassificationItem->incRunningPossibleSubsumptionTestsCount();
if (calculateSubsumption(optKPSetClassificationItem,possSubsumedItem,nextPossSubsumTestItem,possSubsumCalcData)) {
workTestCreated = true;
} else {
interpreteSubsumptionResult(optKPSetClassificationItem,possSubsumedItem->getTestingRole(),nextPossSubsumTestItem->getTestingRole(),possSubsumCalcData->isSubsumptionConfirmed());
}
//}
} else {
QSet* remTestingSet = optKPSetClassificationItem->getRemainingPossibleSubsumptionTestingSet();
remTestingSet->remove(nextPossSubsumTestItem);
}
}
}
}
if (!workTestCreated && currentItemSet->isEmpty()) {
optKPSetClassificationItem->setPossibleSubsumptionTestingPhaseFinished(true);
}
}
if (!workTestCreated) {
if (optKPSetClassificationItem->hasPossibleSubsumptionTestingPhaseFinished() || ontPropItem->isHierarchyConstructionFailed()) {
finishOntologyClassification(ontPropItem);
processingOntItemList.removeFirst();
} else {
processingOntItemList.removeFirst();
processingOntItemList.append(ontPropItem);
loopontPropItem = ontPropItem;
}
}
}
return workTestCreated;
}
COptimizedKPSetRolePossibleSubsumptionData* COptimizedKPSetRoleSubsumptionClassifierThread::getNextPossibleSubsumptionCalculation(COptimizedKPSetRoleOntologyClassificationItem *ontPropItem, COptimizedKPSetRoleTestingItem* classItem) {
COptimizedKPSetRolePossibleSubsumptionData* possSubsumer = nullptr;
// I don't know which is the best, simply return the first one
// sort by subsumer count?
COptimizedKPSetRolePossibleSubsumptionMap* possSubsumerMap = classItem->getPossibleSubsumptionMap(false);
if (possSubsumerMap) {
if (mConfPossSubsumCalcOrderRoleSorted) {
for (COptimizedKPSetRolePossibleSubsumptionMap::const_iterator it = possSubsumerMap->constBegin(), itEnd = possSubsumerMap->constEnd(); !possSubsumer && it != itEnd; ++it) {
COptimizedKPSetRolePossibleSubsumptionData* possSubsumData = it.value();
if (possSubsumData->isSubsumptionUnknown()) {
possSubsumer = possSubsumData;
} else if (possSubsumData->isUpdateRequired()) {
prunePossibleSubsumptions(ontPropItem,classItem,possSubsumData);
}
}
}
}
return possSubsumer;
}
bool COptimizedKPSetRoleSubsumptionClassifierThread::calculateSatisfiable(COptimizedKPSetRoleOntologyClassificationItem *optKPSetClassificationItem, COptimizedKPSetRoleTestingItem* nextSatTestItem) {
CSatisfiableCalculationJob* satCalcJob = nullptr;
CPropertyClassificationComputationItem *workItem = 0;
//if (CIRIName::getRecentIRIName(nextSatTestItem->getTestingRole()->getPropertyNameLinker()) == "http://www.owllink.org/testsuite/particle-D#Neutrino" || CIRIName::getRecentIRIName(nextSatTestItem->getTestingRole()->getPropertyNameLinker()) == "http://www.co-ode.org/roberts/family-tree.owl#isBrotherInLawOf") {
// bool bug = true;
//}
CConcept* existConcept = nextSatTestItem->getTemporaryExistConcept();
CConcept* allPropConcept = optKPSetClassificationItem->getTemporaryAllPropagationConcept();
nextSatTestItem->setSatisfiableTestOrdered(true);
bool satisfiableFlag = false;
if (nextSatTestItem->isResultSatisfiableDerivated()) {
satisfiableFlag = true;
nextSatTestItem->setSatisfiableTested(true);
nextSatTestItem->setSatisfiableTestedResult(true);
return false;
}
if (nextSatTestItem->isResultUnsatisfiableDerivated()) {
satisfiableFlag = false;
nextSatTestItem->setSatisfiableTested(true);
nextSatTestItem->setSatisfiableTestedResult(false);
return false;
}
CIndividual* tmpIndiPropagation = optKPSetClassificationItem->getTemporaryPropagationIndividual();
CIndividual* tmpIndiMarker = optKPSetClassificationItem->getTemporaryMarkerIndividual();
CRole* role = nextSatTestItem->getTestingRole();
CSatisfiableCalculationJobGenerator satCalcJobGen(optKPSetClassificationItem->getOntology());
satCalcJob = satCalcJobGen.getSatisfiableCalculationJob(existConcept,false,tmpIndiPropagation,satCalcJob);
satCalcJob = satCalcJobGen.getSatisfiableCalculationJob(allPropConcept,false,tmpIndiPropagation,satCalcJob);
if (optKPSetClassificationItem->isDataRolesClassification()) {
CConcept* topDataConcept = optKPSetClassificationItem->getOntology()->getTBox()->getTopDataRangeConcept();
satCalcJob = satCalcJobGen.getSatisfiableCalculationJob(topDataConcept,false,tmpIndiMarker,satCalcJob);
} else {
CConcept* topConcept = optKPSetClassificationItem->getOntology()->getTBox()->getTopConcept();
satCalcJob = satCalcJobGen.getSatisfiableCalculationJob(topConcept,false,tmpIndiMarker,satCalcJob);
}
QHash *workHash = optKPSetClassificationItem->getComputationItemHash();
CClassifierStatistics *ontClassStat = optKPSetClassificationItem->getClassifierStatistics();
if (ontClassStat) {
ontClassStat->incCalculatedTestedSatisfiableCount(1);
}
workItem = new CPropertyClassificationComputationItem(satCalcJob,role);
workHash->insertMulti(satCalcJob,workItem);
workOntItemHash.insert(workItem,optKPSetClassificationItem);
satCalcJob->setSatisfiableClassificationRoleMarkedMessageAdapter(new CSatisfiableTaskClassificationRoleMarkedMessageAdapter(role,tmpIndiPropagation,tmpIndiMarker,optKPSetClassificationItem->getOntology(),this));
optKPSetClassificationItem->incCurrentCalculatingCount();
if (optKPSetClassificationItem->getIndividualDependenceTrackingCollector()) {
satCalcJob->setSatisfiableTaskIndividualDependenceTrackingAdapter(new CSatisfiableTaskIndividualDependenceTrackingAdapter(optKPSetClassificationItem->getIndividualDependenceTrackingCollector()));
}
processCalculationJob(satCalcJob,optKPSetClassificationItem,workItem);
++mCreatedCalculationTaskCount;
return true;
}
bool COptimizedKPSetRoleSubsumptionClassifierThread::calculateSubsumption(COptimizedKPSetRoleOntologyClassificationItem *optKPSetClassificationItem, COptimizedKPSetRoleTestingItem* subsumedItem, COptimizedKPSetRoleTestingItem* possSubsumerItem, COptimizedKPSetRolePossibleSubsumptionData* possSubsumData) {
CSatisfiableCalculationJob* satCalcJob = nullptr;
CPropertyClassificationComputationItem *workItem = 0;
++mOrderedSubsumptionCalculationCount;
CRole* subsumedRole = subsumedItem->getTestingRole();
CRole* subsumerRole = possSubsumerItem->getTestingRole();
bool isSubsumptionFlag = false;
bool precheckedSubsum = false;
CClassifierStatistics *ontClassStat = optKPSetClassificationItem->getClassifierStatistics();
if (possSubsumData && possSubsumData->isSubsumptionKnown()) {
return false;
} else if (possSubsumData && subsumedItem->hasSubsumerRoleItem(possSubsumerItem)) {
possSubsumData->setSubsumptionConfirmed(true);
return false;
}
CIndividual* tmpIndiPropagation = optKPSetClassificationItem->getTemporaryPropagationIndividual();
CIndividual* tmpIndiMarker = optKPSetClassificationItem->getTemporaryMarkerIndividual();
CConcept* existConcept = subsumedItem->getTemporaryExistConcept();
CConcept* propagationConcept = possSubsumerItem->getTemporaryPropagationConcept();
CSatisfiableCalculationJobGenerator satCalcJobGen(optKPSetClassificationItem->getOntology());
satCalcJob = satCalcJobGen.getSatisfiableCalculationJob(existConcept,false,tmpIndiPropagation,satCalcJob);
satCalcJob = satCalcJobGen.getSatisfiableCalculationJob(propagationConcept,false,tmpIndiPropagation,satCalcJob);
satCalcJob = satCalcJobGen.getSatisfiableCalculationJob(possSubsumerItem->getTemporaryMarkerConcept(),true,tmpIndiMarker,satCalcJob);
if (optKPSetClassificationItem->isDataRolesClassification()) {
CConcept* topDataConcept = optKPSetClassificationItem->getOntology()->getTBox()->getTopDataRangeConcept();
satCalcJob = satCalcJobGen.getSatisfiableCalculationJob(topDataConcept,false,tmpIndiMarker,satCalcJob);
} else {
CConcept* topConcept = optKPSetClassificationItem->getOntology()->getTBox()->getTopConcept();
satCalcJob = satCalcJobGen.getSatisfiableCalculationJob(topConcept,false,tmpIndiMarker,satCalcJob);
}
QHash *workHash = optKPSetClassificationItem->getComputationItemHash();
if (ontClassStat) {
ontClassStat->incCalculatedTestedSubsumptionCount(1);
ontClassStat->incToldSubsumptionCount(1);
}
workItem = new CPropertyClassificationComputationItem(satCalcJob,subsumerRole,subsumedRole);
workHash->insertMulti(satCalcJob,workItem);
workOntItemHash.insert(workItem,optKPSetClassificationItem);
if (optKPSetClassificationItem->getIndividualDependenceTrackingCollector()) {
satCalcJob->setSatisfiableTaskIndividualDependenceTrackingAdapter(new CSatisfiableTaskIndividualDependenceTrackingAdapter(optKPSetClassificationItem->getIndividualDependenceTrackingCollector()));
}
optKPSetClassificationItem->incCurrentCalculatingCount();
processCalculationJob(satCalcJob,optKPSetClassificationItem,workItem);
optKPSetClassificationItem->incCalculatedPossibleSubsumerCount();
++mCreatedCalculationTaskCount;
return true;
}
void COptimizedKPSetRoleSubsumptionClassifierThread::incRemainingPossibleSubsumptionTestingCount(COptimizedKPSetRoleOntologyClassificationItem *optKPSetClassificationItem, COptimizedKPSetRolePossibleSubsumptionMap* posSubsumMap) {
optKPSetClassificationItem->incPossibleSubsumerCount();
optKPSetClassificationItem->incRemainingPossibleSubsumptionTestsCount();
posSubsumMap->incRemainingPossibleSubsumptionCount();
++totalToSubsumTestCount;
}
void COptimizedKPSetRoleSubsumptionClassifierThread::decRemainingPossibleSubsumptionTestingCount(COptimizedKPSetRoleOntologyClassificationItem *optKPSetClassificationItem, COptimizedKPSetRolePossibleSubsumptionMap* posSubsumMap, bool subsumptionConfirmed) {
if (subsumptionConfirmed) {
optKPSetClassificationItem->incTruePossibleSubsumerCount();
} else {
optKPSetClassificationItem->incFalsePossibleSubsumerCount();
}
optKPSetClassificationItem->decRemainingPossibleSubsumptionTestsCount();
posSubsumMap->decRemainingPossibleSubsumptionCount();
++subsumTestedCount;
}
CSubsumptionClassifierThread *COptimizedKPSetRoleSubsumptionClassifierThread::processCalculationJob(CSatisfiableCalculationJob* job, COntologyPropertyRoleClassificationItem *ontPropItem, CPropertyClassificationComputationItem* workItem) {
CClassificationCalculationStatisticsCollection* statColl = nullptr;
if (ontPropItem->isCollectProcessStatisticsActivated()) {
statColl = ontPropItem->getCalculationStatisticsCollection();
}
job->setCalclulationStatisticsCollector(statColl);
CTestCalculatedCallbackEvent *testResultCallback = new CTestCalculatedCallbackEvent(this,job,workItem,statColl);
job->setCalculationConfiguration(ontPropItem->getCalculationConfiguration());
CSubsumptionClassifierThread::processCalculationJob(job,ontPropItem,testResultCallback,false);
return this;
}
bool COptimizedKPSetRoleSubsumptionClassifierThread::processToldClassificationMessage(COntologyClassificationItem *ontPropItem, CClassificationMessageData* messageDataLinker, CMemoryPool* memoryPools) {
COptimizedKPSetRoleOntologyClassificationItem *optKPSetClassificationItem = (COptimizedKPSetRoleOntologyClassificationItem *)ontPropItem;
CClassificationMessageData* messageDataLinkerIt = messageDataLinker;
while (messageDataLinkerIt) {
CClassificationMessageData* messageData = messageDataLinkerIt;
if (messageData->getClassificationMessageDataType() == CClassificationMessageData::TELLPROPERTYSUBSUMPTION) {
++mStatProcesedSubsumMessCount;
CClassificationPropertySubsumptionMessageData* subsumMessageData = (CClassificationPropertySubsumptionMessageData*)messageData;
CRole* subsumedRole = subsumMessageData->getSubsumedRole();
CPROPERTYSUBSUMPTIONMESSAGELIST* subsumerList = subsumMessageData->getPropertySubsumerList();
COptimizedKPSetRoleTestingItem* subsumedItem = nullptr;
subsumedItem = optKPSetClassificationItem->getRoleSatisfiableTestItem(subsumedRole);
CRole* topRole = optKPSetClassificationItem->getTopRoleSatisfiableTestItem()->getTestingRole();
COptimizedKPSetRolePossibleSubsumptionMap* possSubsumMap = subsumedItem->getPossibleSubsumptionMap(false);
if (subsumerList) {
for (CPROPERTYSUBSUMPTIONMESSAGELIST::const_iterator it = subsumerList->constBegin(), itEnd = subsumerList->constEnd(); it != itEnd; ++it) {
CRole* subsumerRole(*it);
if (subsumerRole != topRole) {
COptimizedKPSetRoleTestingItem* subsumerItem = optKPSetClassificationItem->getRoleSatisfiableTestItem(subsumerRole);
if (subsumedItem != subsumerItem) {
subsumedItem->addSubsumerRoleItem(subsumerItem);
if (possSubsumMap) {
COptimizedKPSetRolePossibleSubsumptionData* possSubsumData = possSubsumMap->value(subsumerRole,nullptr);
if (possSubsumData) {
if (!possSubsumData->isSubsumptionConfirmed()) {
possSubsumData->setSubsumptionConfirmed(true);
if (possSubsumData->isUpdateRequired()) {
prunePossibleSubsumptions(optKPSetClassificationItem,subsumedItem,possSubsumData);
}
}
}
}
propagateDownSubsumption(optKPSetClassificationItem,subsumedItem,subsumerItem);
}
}
}
}
subsumedItem->setResultSatisfiableDerivated(true);
} else if (messageData->getClassificationMessageDataType() == CClassificationMessageData::TELLCLASSINITIALIZEPOSSIBLESUBSUM) {
++mStatProcesedPossSubsumInitMessCount;
CClassificationInitializePossiblePropertySubsumptionMessageData* possSubsumMessageData = (CClassificationInitializePossiblePropertySubsumptionMessageData*)messageData;
CRole* subsumedRole = possSubsumMessageData->getSubsumedRole();
CPROPERTYPOSSIBLESUBSUMPTIONMESSAGELIST* possSubsumerList = possSubsumMessageData->getPropertyPossibleSubsumerList();
COptimizedKPSetRoleTestingItem* subsumedItem = nullptr;
subsumedItem = optKPSetClassificationItem->getRoleSatisfiableTestItem(subsumedRole);
CRole* topRole = optKPSetClassificationItem->getTopRoleSatisfiableTestItem()->getTestingRole();
COptimizedKPSetRolePossibleSubsumptionMap* possSubsumMap = subsumedItem->getPossibleSubsumptionMap(false);
if (!possSubsumerList || possSubsumerList->empty()) {
if (possSubsumMap) {
for (COptimizedKPSetRolePossibleSubsumptionMap::const_iterator it = possSubsumMap->constBegin(), itEnd = possSubsumMap->constEnd(); it != itEnd; ++it) {
COptimizedKPSetRolePossibleSubsumptionData* possSubsumData = it.value();
if (possSubsumData->isSubsumptionUnknown()) {
possSubsumData->setSubsumptionInvalid(true);
if (possSubsumData->isUpdateRequired()) {
prunePossibleSubsumptions(optKPSetClassificationItem,subsumedItem,possSubsumData);
}
}
}
}
} else {
if (!subsumedItem->isPossibleSubsumptionMapInitialized() || possSubsumMap) {
possSubsumMap = subsumedItem->getPossibleSubsumptionMap(true);
if (possSubsumMap->isEmpty()) {
// initialize the possible subsumption map
if (possSubsumerList) {
for (CPROPERTYPOSSIBLESUBSUMPTIONMESSAGELIST::const_iterator it = possSubsumerList->constBegin(), itEnd = possSubsumerList->constEnd(); it != itEnd; ++it) {
CClassificationInitializePossiblePropertySubsumptionData* possSubsumDataIt = *it;
if (possSubsumDataIt->isPossibleSubsumerValid()) {
CRole* possSubsumRole = possSubsumDataIt->getPossibleSubsumerRole();
COptimizedKPSetRoleTestingItem* possSubsumItem = optKPSetClassificationItem->getRoleSatisfiableTestItem(possSubsumRole);
if (possSubsumRole != topRole && subsumedItem != possSubsumItem && !subsumedItem->hasSubsumerRoleItem(possSubsumItem)) {
COptimizedKPSetRolePossibleSubsumptionData* possSubsumData = new COptimizedKPSetRolePossibleSubsumptionData(possSubsumItem);
possSubsumMap->insert(CRoleTagComparer(possSubsumRole),possSubsumData);
incRemainingPossibleSubsumptionTestingCount(optKPSetClassificationItem,possSubsumMap);
}
}
}
}
// prune ancestor items
QSet* upPropSet = subsumedItem->getUpPropagationItemSet();
for (QSet::const_iterator it = upPropSet->constBegin(), itEnd = upPropSet->constEnd(); it != itEnd; ++it) {
COptimizedKPSetRoleTestingItem* upPropItem = *it;
COptimizedKPSetRolePossibleSubsumptionMap* upPropItemPossSubsumMap = upPropItem->getPossibleSubsumptionMap(false);
if (upPropItemPossSubsumMap) {
COptimizedKPSetRolePossibleSubsumptionMap::const_iterator itPoss = possSubsumMap->constBegin(), itPossEnd = possSubsumMap->constEnd();
COptimizedKPSetRolePossibleSubsumptionMap::const_iterator itUpPoss = upPropItemPossSubsumMap->constBegin(), itUpPossEnd = upPropItemPossSubsumMap->constEnd();
while (itPoss != itPossEnd && itUpPoss != itUpPossEnd) {
CRole* possRole = itPoss.key().getRole();
CRole* possUpRole = itUpPoss.key().getRole();
if (possRole->getRoleTag() == possUpRole->getRoleTag()) {
++itPoss;
++itUpPoss;
} else if (possRole->getRoleTag() < possUpRole->getRoleTag()) {
++itPoss;
} else if (possRole->getRoleTag() > possUpRole->getRoleTag()) {
COptimizedKPSetRolePossibleSubsumptionData* upPossData = itUpPoss.value();
if (!subsumedItem->hasSubsumerRoleItem(upPossData->getTestingItem()) && subsumedItem != upPossData->getTestingItem()) {
if (!upPossData->isSubsumptionInvalided()) {
upPossData->setSubsumptionInvalid(true);
if (upPossData->isUpdateRequired()) {
prunePossibleSubsumptions(optKPSetClassificationItem,upPropItem,upPossData);
}
}
}
++itUpPoss;
}
}
while (itUpPoss != itUpPossEnd) {
COptimizedKPSetRolePossibleSubsumptionData* upPossData = itUpPoss.value();
if (!subsumedItem->hasSubsumerRoleItem(upPossData->getTestingItem()) && subsumedItem != upPossData->getTestingItem()) {
if (!upPossData->isSubsumptionInvalided()) {
upPossData->setSubsumptionInvalid(true);
if (upPossData->isUpdateRequired()) {
prunePossibleSubsumptions(optKPSetClassificationItem,upPropItem,upPossData);
}
}
}
++itUpPoss;
}
}
}
// prune descendant items
QSet* downPropSet = subsumedItem->getDownPropagationItemSet();
for (QSet::const_iterator it = downPropSet->constBegin(), itEnd = downPropSet->constEnd(); it != itEnd; ++it) {
COptimizedKPSetRoleTestingItem* downPropItem = *it;
COptimizedKPSetRolePossibleSubsumptionMap* downPropItemPossSubsumMap = downPropItem->getPossibleSubsumptionMap(false);
if (downPropItemPossSubsumMap) {
COptimizedKPSetRolePossibleSubsumptionMap::const_iterator itPoss = possSubsumMap->constBegin(), itPossEnd = possSubsumMap->constEnd();
COptimizedKPSetRolePossibleSubsumptionMap::const_iterator itDownPoss = downPropItemPossSubsumMap->constBegin(), itDownPossEnd = downPropItemPossSubsumMap->constEnd();
while (itPoss != itPossEnd && itDownPoss != itDownPossEnd) {
CRole* possRole = itPoss.key().getRole();
CRole* possDownRole = itDownPoss.key().getRole();
if (possRole->getRoleTag() == possDownRole->getRoleTag()) {
++itPoss;
++itDownPoss;
} else if (possDownRole->getRoleTag() < possRole->getRoleTag()) {
++itDownPoss;
} else if (possDownRole->getRoleTag() > possRole->getRoleTag()) {
COptimizedKPSetRolePossibleSubsumptionData* possData = itPoss.value();
if (!downPropItem->hasSubsumerRoleItem(possData->getTestingItem()) && downPropItem != possData->getTestingItem()) {
if (!possData->isSubsumptionInvalided()) {
possData->setSubsumptionInvalid(true);
if (possData->isUpdateRequired()) {
prunePossibleSubsumptions(optKPSetClassificationItem,subsumedItem,possData);
}
}
}
++itPoss;
}
}
while (itPoss != itPossEnd) {
COptimizedKPSetRolePossibleSubsumptionData* possData = itDownPoss.value();
if (!downPropItem->hasSubsumerRoleItem(possData->getTestingItem()) && downPropItem != possData->getTestingItem()) {
if (!possData->isSubsumptionInvalided()) {
possData->setSubsumptionInvalid(true);
if (possData->isUpdateRequired()) {
prunePossibleSubsumptions(optKPSetClassificationItem,subsumedItem,possData);
}
}
}
++itPoss;
}
} else if (downPropItem->isPossibleSubsumptionMapInitialized()) {
for (COptimizedKPSetRolePossibleSubsumptionMap::const_iterator itPoss = possSubsumMap->constBegin(), itPossEnd = possSubsumMap->constEnd(); itPoss != itPossEnd; ++itPoss) {
COptimizedKPSetRolePossibleSubsumptionData* possData = itPoss.value();
if (!downPropItem->hasSubsumerRoleItem(possData->getTestingItem()) && downPropItem != possData->getTestingItem()) {
if (!possData->isSubsumptionInvalided()) {
possData->setSubsumptionInvalid(true);
if (possData->isUpdateRequired()) {
prunePossibleSubsumptions(optKPSetClassificationItem,subsumedItem,possData);
}
}
}
}
}
}
} else {
// prune the possible subsumption map
COptimizedKPSetRolePossibleSubsumptionMap::const_iterator itPoss = possSubsumMap->constBegin(), itPossEnd = possSubsumMap->constEnd();
if (possSubsumerList) {
CPROPERTYPOSSIBLESUBSUMPTIONMESSAGELIST::const_iterator itNew = possSubsumerList->constBegin(), itNewEnd = possSubsumerList->constEnd();
while (itPoss != itPossEnd && itNew != itNewEnd) {
COptimizedKPSetRolePossibleSubsumptionData* possData = itPoss.value();
CRole* possRole = itPoss.key().getRole();
CClassificationInitializePossiblePropertySubsumptionData* possNewSubsumDataIt = *itNew;
if (possNewSubsumDataIt->isPossibleSubsumerValid()) {
CRole* newRole = possNewSubsumDataIt->getPossibleSubsumerRole();
if (possRole->getRoleTag() == newRole->getRoleTag()) {
++itPoss;
++itNew;
} else if (possRole->getRoleTag() < newRole->getRoleTag()) {
if (!possData->isSubsumptionInvalided()) {
possData->setSubsumptionInvalid(true);
if (possData->isUpdateRequired()) {
prunePossibleSubsumptions(optKPSetClassificationItem,subsumedItem,possData);
}
}
++itPoss;
} else if (possRole->getRoleTag() > newRole->getRoleTag()) {
++itNew;
}
} else {
++itNew;
}
}
}
while (itPoss != itPossEnd) {
COptimizedKPSetRolePossibleSubsumptionData* possData = itPoss.value();
CRole* possRole = itPoss.key().getRole();
if (!possData->isSubsumptionInvalided()) {
possData->setSubsumptionInvalid(true);
if (possData->isUpdateRequired()) {
prunePossibleSubsumptions(optKPSetClassificationItem,subsumedItem,possData);
}
}
++itPoss;
}
}
}
}
subsumedItem->setPossibleSubsumptionMapInitialized(true);
} else if (messageData->getClassificationMessageDataType() == CClassificationMessageData::TELLPROPERTYUPDATEPOSSIBLESUBSUM) {
++mStatProcesedPossSubsumUpdateMessCount;
CClassificationUpdatePossiblePropertySubsumptionMessageData* possSubsumMessageData = (CClassificationUpdatePossiblePropertySubsumptionMessageData*)messageData;
CRole* subsumedRole = possSubsumMessageData->getSubsumedRole();
COptimizedKPSetRoleTestingItem* subsumedItem = nullptr;
subsumedItem = optKPSetClassificationItem->getRoleSatisfiableTestItem(subsumedRole);
COptimizedKPSetRolePossibleSubsumptionMap* possSubsumMap = subsumedItem->getPossibleSubsumptionMap(false);
if (possSubsumMap && !possSubsumMap->empty()) {
possSubsumMap = subsumedItem->getPossibleSubsumptionMap(true);
for (COptimizedKPSetRolePossibleSubsumptionMap::const_iterator it = possSubsumMap->constBegin(), itEnd = possSubsumMap->constEnd(); it != itEnd; ++it) {
COptimizedKPSetRolePossibleSubsumptionData* possSubsumData = it.value();
if (possSubsumData->isUpdateRequired()) {
prunePossibleSubsumptions(optKPSetClassificationItem,subsumedItem,possSubsumData);
}
}
}
}
messageDataLinkerIt = messageDataLinkerIt->getNext();
}
return true;
}
bool COptimizedKPSetRoleSubsumptionClassifierThread::interpreteToldSubsumptionResult(COntologyPropertyRoleClassificationItem *ontPropItem, const QList< QPair > &subSumRelList, bool isSubSum) {
CRole *lastRole = nullptr;
COptimizedKPSetRoleOntologyClassificationItem *optKPSetClassificationItem = (COptimizedKPSetRoleOntologyClassificationItem *)ontPropItem;
COptimizedKPSetRoleTestingItem* subsumerItem = nullptr;
for (QList< QPair >::const_iterator it = subSumRelList.constBegin(), itEnd = subSumRelList.constEnd(); it != itEnd; ++it) {
CRole *subsumerRole = it->first;
if (lastRole != subsumerRole) {
lastRole = subsumerRole;
subsumerItem = optKPSetClassificationItem->getRoleSatisfiableTestItem(subsumerRole);
}
CRole *subsumedRole = it->second;
if (isSubSum) {
COptimizedKPSetRoleTestingItem* subsumedItem = optKPSetClassificationItem->getRoleSatisfiableTestItem(subsumedRole);
subsumerItem->addSubsumerRoleItem(subsumedItem);
}
}
return true;
}
bool COptimizedKPSetRoleSubsumptionClassifierThread::interpreteSubsumptionResult(COntologyPropertyRoleClassificationItem *ontPropItem, CRole *subsumedRole, CRole *subsumerRole, bool isSubsumption) {
COptimizedKPSetRoleOntologyClassificationItem *optKPSetClassificationItem = (COptimizedKPSetRoleOntologyClassificationItem *)ontPropItem;
++mInterpretedSubsumptionCalculationCount;
optKPSetClassificationItem->decRunningPossibleSubsumptionTestsCount();
COptimizedKPSetRoleTestingItem* subsumedItem = optKPSetClassificationItem->getRoleSatisfiableTestItem(subsumedRole);
COptimizedKPSetRoleTestingItem* subsumerItem = optKPSetClassificationItem->getRoleSatisfiableTestItem(subsumerRole);
//QString iriPropertyNameString1 = CIRIName::getRecentIRIName(subsumedRole->getPropertyNameLinker());
//QString iriPropertyNameString2 = CIRIName::getRecentIRIName(subsumerRole->getPropertyNameLinker());
//if (iriPropertyNameString1 == "http://www.bootstrep.eu/ontology/GRO#BindingOfProteinToProteinBindingSiteOfDNA" && iriPropertyNameString2 == "http://www.bootstrep.eu/ontology/GRO#DNAProteinInteraction" && !isSubsumption) {
// bool bug = true;
// calculateSubsumption(optKPSetPropertyificationItem,subsumedItem,subsumerItem,nullptr);
//}
COptimizedKPSetRoleTestingItem* topItem = optKPSetClassificationItem->getTopRoleSatisfiableTestItem();
COptimizedKPSetRolePossibleSubsumptionMap* possSubsumMap = subsumedItem->getPossibleSubsumptionMap(false);
COptimizedKPSetRolePossibleSubsumptionData* possSubsumData = nullptr;
if (possSubsumMap) {
possSubsumData = possSubsumMap->value(subsumerRole);
}
if (isSubsumption) {
optKPSetClassificationItem->incCalculatedTruePossibleSubsumerCount();
if (possSubsumData) {
possSubsumData->setSubsumptionConfirmed(true);
}
subsumedItem->addSubsumerRoleItem(subsumerItem);
subsumedItem->addUpPropagationItem(subsumerItem);
subsumerItem->addDownPropagationItem(subsumedItem);
propagateDownSubsumption(optKPSetClassificationItem,subsumedItem,subsumerItem);
} else {
optKPSetClassificationItem->incCalculatedFalsePossibleSubsumerCount();
if (possSubsumData) {
possSubsumData->setSubsumptionInvalid(true);
}
}
if (possSubsumData && possSubsumData->isUpdateRequired()) {
prunePossibleSubsumptions(optKPSetClassificationItem,subsumedItem,possSubsumData);
}
QList* nextItemList = optKPSetClassificationItem->getNextPossibleSubsumptionTestingItemList();
QSet* currentItemSet = optKPSetClassificationItem->getCurrentPossibleSubsumptionTestingItemSet();
if (mConfPossSubsumCalcOrderTopDown) {
if (currentItemSet->contains(subsumedItem)) {
currentItemSet->remove(subsumedItem);
if (possSubsumMap) {
if (possSubsumMap->hasRemainingPossibleSubsumptions()) {
nextItemList->prepend(subsumedItem);
} else {
QSet* remTestingSet = optKPSetClassificationItem->getRemainingPossibleSubsumptionTestingSet();
remTestingSet->remove(subsumedItem);
}
}
}
}
if (mConfPossSubsumCalcOrderBottomUp) {
if (currentItemSet->contains(subsumerItem)) {
currentItemSet->remove(subsumerItem);
if (subsumerItem->hasRemainingPossibleSubsumedItems()) {
QSet* remPossSubsumedItemSet = subsumerItem->getPossibleSubsumerSet(false);
QList* remPossSubsumedItemList = subsumerItem->getPossibleSubsumerList();
nextItemList->prepend(subsumerItem);
QSet* upPropSet = subsumedItem->getUpPropagationItemSet();
for (QSet::const_iterator itUp = upPropSet->constBegin(), itUpEnd = upPropSet->constEnd(); itUp != itUpEnd; ++itUp) {
COptimizedKPSetRoleTestingItem* upItem = *itUp;
if (remPossSubsumedItemSet->contains(upItem)) {
remPossSubsumedItemList->prepend(upItem);
}
}
} else {
QSet* remTestingSet = optKPSetClassificationItem->getRemainingPossibleSubsumptionTestingSet();
remTestingSet->remove(subsumerItem);
}
}
}
return true;
}
bool COptimizedKPSetRoleSubsumptionClassifierThread::prunePossibleSubsumptions(COptimizedKPSetRoleOntologyClassificationItem *optKPSetClassificationItem, COptimizedKPSetRoleTestingItem* item, COptimizedKPSetRolePossibleSubsumptionData* possSubsumData) {
if (possSubsumData->isUpdateRequired()) {
COptimizedKPSetRolePossibleSubsumptionMap* possSubsumMap = item->getPossibleSubsumptionMap(false);
possSubsumData->setSubsumptionUpdated(true);
decRemainingPossibleSubsumptionTestingCount(optKPSetClassificationItem,possSubsumMap,true);
if (possSubsumData->isSubsumptionConfirmed()) {
// is subsuming
COptimizedKPSetRoleTestingItem* subsumerItem = possSubsumData->getTestingItem();
CRole* subsumerRole = subsumerItem->getTestingRole();
// establish the subsumption for all successor nodes
QSet* downPropSet = item->getDownPropagationItemSet();
for (QSet::const_iterator it = downPropSet->constBegin(), itEnd = downPropSet->constEnd(); it != itEnd; ++it) {
COptimizedKPSetRoleTestingItem* downPropItem = *it;
pruneDownSubsumption(optKPSetClassificationItem,downPropItem,subsumerRole);
}
return true;
} else {
// is not subsuming
COptimizedKPSetRoleTestingItem* notSubsumerItem = possSubsumData->getTestingItem();
CRole* notSubsumerRole = notSubsumerItem->getTestingRole();
// establish the subsumption for all successor nodes
QSet* upPropSet = item->getUpPropagationItemSet();
for (QSet::const_iterator it = upPropSet->constBegin(), itEnd = upPropSet->constEnd(); it != itEnd; ++it) {
COptimizedKPSetRoleTestingItem* upPropItem = *it;
pruneUpNotSubsumption(optKPSetClassificationItem,upPropItem,notSubsumerRole);
}
return true;
}
}
return false;
}
bool COptimizedKPSetRoleSubsumptionClassifierThread::propagateDownSubsumption(COptimizedKPSetRoleOntologyClassificationItem *optKPSetClassificationItem, COptimizedKPSetRoleTestingItem* item, COptimizedKPSetRoleTestingItem* subsumerItem) {
bool propagated = false;
QSet* downPropSet = item->getDownPropagationItemSet();
for (QSet::const_iterator it = downPropSet->constBegin(), itEnd = downPropSet->constEnd(); it != itEnd; ++it) {
COptimizedKPSetRoleTestingItem* downPropItem = *it;
if (!downPropItem->hasSubsumerRoleItem(subsumerItem) && downPropItem != subsumerItem) {
downPropItem->addSubsumerRoleItem(subsumerItem);
propagateDownSubsumption(optKPSetClassificationItem,downPropItem,subsumerItem);
propagated = true;
}
}
return propagated;
}
bool COptimizedKPSetRoleSubsumptionClassifierThread::pruneDownSubsumption(COptimizedKPSetRoleOntologyClassificationItem *optKPSetClassificationItem, COptimizedKPSetRoleTestingItem* item, CRole* subsumerRole) {
COptimizedKPSetRolePossibleSubsumptionMap* possSubsumMap = item->getPossibleSubsumptionMap(false);
if (possSubsumMap) {
COptimizedKPSetRolePossibleSubsumptionData* possSubsumData = possSubsumMap->value(subsumerRole);
if (possSubsumData && !possSubsumData->isSubsumptionConfirmed()) {
possSubsumData->setSubsumptionConfirmed(true);
possSubsumData->setSubsumptionUpdated(true);
decRemainingPossibleSubsumptionTestingCount(optKPSetClassificationItem,possSubsumMap,true);
CClassifierStatistics *ontClassStat = optKPSetClassificationItem->getClassifierStatistics();
if (ontClassStat) {
ontClassStat->incDerivatedTestedSubsumptionCount(1);
}
QSet* downPropSet = item->getDownPropagationItemSet();
for (QSet::const_iterator it = downPropSet->constBegin(), itEnd = downPropSet->constEnd(); it != itEnd; ++it) {
COptimizedKPSetRoleTestingItem* downPropItem = *it;
pruneDownSubsumption(optKPSetClassificationItem,downPropItem,subsumerRole);
}
return true;
}
}
return false;
}
bool COptimizedKPSetRoleSubsumptionClassifierThread::pruneUpNotSubsumption(COptimizedKPSetRoleOntologyClassificationItem *optKPSetClassificationItem, COptimizedKPSetRoleTestingItem* item, CRole* notSubsumerRole) {
COptimizedKPSetRolePossibleSubsumptionMap* possSubsumMap = item->getPossibleSubsumptionMap(false);
if (possSubsumMap) {
COptimizedKPSetRolePossibleSubsumptionData* possSubsumData = possSubsumMap->value(notSubsumerRole);
if (possSubsumData && !possSubsumData->isSubsumptionInvalided()) {
possSubsumData->setSubsumptionInvalid(true);
possSubsumData->setSubsumptionUpdated(true);
decRemainingPossibleSubsumptionTestingCount(optKPSetClassificationItem,possSubsumMap,false);
CClassifierStatistics *ontClassStat = optKPSetClassificationItem->getClassifierStatistics();
if (ontClassStat) {
ontClassStat->incPrunedTestedSubsumptionCount(1);
}
QSet* upPropSet = item->getUpPropagationItemSet();
for (QSet::const_iterator it = upPropSet->constBegin(), itEnd = upPropSet->constEnd(); it != itEnd; ++it) {
COptimizedKPSetRoleTestingItem* upPropItem = *it;
pruneUpNotSubsumption(optKPSetClassificationItem,upPropItem,notSubsumerRole);
}
return true;
}
}
return false;
}
bool COptimizedKPSetRoleSubsumptionClassifierThread::interpreteSatisfiableResult(COntologyPropertyRoleClassificationItem *ontPropItem, CRole *satisfiableRole, bool isSatis) {
COptimizedKPSetRoleOntologyClassificationItem *optKPSetClassificationItem = (COptimizedKPSetRoleOntologyClassificationItem *)ontPropItem;
CClassifierStatistics *ontClassStat = optKPSetClassificationItem->getClassifierStatistics();
if (ontClassStat) {
ontClassStat->incToldSatisfiableCount(1);
}
++satTestedCount;
optKPSetClassificationItem->decRunningSatisfiableTestsCount();
COptimizedKPSetRoleTestingItem* satTestedItem = optKPSetClassificationItem->getRoleSatisfiableTestItem(satisfiableRole);
//if (CIRIName::getRecentIRIName(satisfiableRole->getPropertyNameLinker()) == "http://www.gdst.uqam.ca/Documents/Ontologies/HIT/Equipment_SH_Ontology.owl#Folding_chair" && !isSatis) {
// bool bug = true;
// calculateSatisfiable(optKPSetClassificationItem,satTestedItem);
// return false;
//}
satTestedItem->setSatisfiableTested(true);
satTestedItem->setSatisfiableTestedResult(isSatis);
if (isSatis) {
optKPSetClassificationItem->addSatisfiableRoleItem(satTestedItem);
} else {
CRolePropertiesHierarchy* hierarchy = optKPSetClassificationItem->getHierarchy();
hierarchy->getBottomHierarchyNode()->addEquivalentElement(satisfiableRole);
hierarchy->updateNodeEquivalentElements(hierarchy->getBottomHierarchyNode());
}
QList* nextItemList = optKPSetClassificationItem->getNextSatisfiableTestingItemList();
QSet* nextCandItemSet = optKPSetClassificationItem->getNextCandidateSatisfiableTestingItemSet();
QSet* remainingCandItemSet = optKPSetClassificationItem->getRemainingCandidateSatisfiableTestingItemSet();
QList* subSumItemList = satTestedItem->getSubsumerRoleItemList();
QList* succItemList = satTestedItem->getSuccessorItemList();
for (QList::const_iterator it = succItemList->constBegin(), itEnd = succItemList->constEnd(); it != itEnd; ++it) {
COptimizedKPSetRoleTestingItem* succItem = *it;
if (!isSatis) {
succItem->setResultUnsatisfiableDerivated(true);
} else {
for (QList::const_iterator itSubsum = subSumItemList->constBegin(), itSubsumEnd = subSumItemList->constEnd(); itSubsum != itSubsumEnd; ++itSubsum) {
COptimizedKPSetRoleTestingItem* subusmerItem = *itSubsum;
if (succItem != subusmerItem) {
succItem->addSubsumerRoleItem(subusmerItem);
}
}
}
succItem->decUnprocessedPredecessorItems();
if (succItem->hasOnlyProcessedPredecessorItems()) {
nextItemList->append(succItem);
} else {
nextCandItemSet->insert(succItem);
}
}
return false;
}
bool COptimizedKPSetRoleSubsumptionClassifierThread::interpreteTestResults(CTestCalculatedCallbackEvent *testResult) {
CSatisfiableCalculationJob *satCalcJob = testResult->getSatisfiableCalculationJob();
bool testSat = testResult->getTestResultSatisfiable();
CPropertyClassificationComputationItem *workItem = (CPropertyClassificationComputationItem*)testResult->getClassificationWorkItem();
++mRecievedCallbackCount;
COntologyPropertyRoleClassificationItem *ontPropItem = workOntItemHash.value(workItem);
if (ontPropItem) {
QHash *workHash = ontPropItem->getComputationItemHash();
if (workItem) {
ontPropItem->decCurrentCalculatingCount();
if (testResult->hasCalculationError()) {
LOG(ERROR,getLogDomain(),logTr("Error in computation, role classification for ontology '%1' failed.").arg(ontPropItem->getOntology()->getTerminologyName()),getLogObject());
ontPropItem->setHierarchyConstructionFailed();
} else {
if (workItem->isRoleSatisfiableTest()) {
interpreteSatisfiableResult(ontPropItem,workItem->getSatisfiableTestedRole(),testSat);
} else if (workItem->isRoleSubsumptionTest()) {
interpreteSubsumptionResult(ontPropItem,workItem->getSubsumedTestedRole(),workItem->getSubsumerTestedRole(),!testSat);
}
}
QHash::iterator itWorkItem = workHash->find(satCalcJob);
while (itWorkItem != workHash->end()) {
if (itWorkItem.value() == workItem) {
workHash->erase(itWorkItem);
break;
}
++itWorkItem;
}
delete workItem;
delete satCalcJob;
}
workOntItemHash.remove(workItem);
CClassificationCalculationStatisticsCollection* statisticCollection = testResult->getUsedStatisticsCollection();
if (statisticCollection) {
ontPropItem->reuseCalculationStatisticsCollection(statisticCollection);
}
}
return true;
}
bool COptimizedKPSetRoleSubsumptionClassifierThread::finishOntologyClassification(COntologyPropertyRoleClassificationItem *ontPropItem) {
if (!ontPropItem->isHierarchyConstructed() && !ontPropItem->isHierarchyConstructionFailed()) {
CConcreteOntology *ontology = ontPropItem->getOntology();
LOG(INFO,getLogDomain(),logTr("Starting Transitive Reduction for Ontology '%1'.").arg(ontology->getTerminologyName()),getLogObject());
// build taxonomy
COptimizedKPSetRoleOntologyClassificationItem *optKPSetClassificationItem = (COptimizedKPSetRoleOntologyClassificationItem *)ontPropItem;
QList* satItemList = optKPSetClassificationItem->getSatisfiableRoleItemList();
CRolePropertiesHierarchy* hierarchy = optKPSetClassificationItem->getHierarchy();
QList itemList;
COptimizedKPSetRoleTestingItem* topItem = optKPSetClassificationItem->getTopRoleSatisfiableTestItem();
CRolePropertiesHierarchyNode* topHierNode = hierarchy->getTopHierarchyNode();
CRolePropertiesHierarchyNode* bottomHierNode = hierarchy->getBottomHierarchyNode();
cint64 topSubsumingItemCount = topItem->getSubsumerRoleItemCount();
topItem->setSatisfiableRoleHierarchyNode(topHierNode);
if (topSubsumingItemCount) {
QList* subsumingConceptItemList = topItem->sortSubsumingConceptItemList();
for (QList::const_iterator subsumedIt = subsumingConceptItemList->constBegin(), subsumedItEnd = subsumingConceptItemList->constEnd(); subsumedIt != subsumedItEnd; ++subsumedIt) {
COptimizedKPSetRoleTestingItem* subsumedConceptItem = *subsumedIt;
// mark as equivalent
subsumedConceptItem->setEquivalentItem(true);
topHierNode->addEquivalentElement(subsumedConceptItem->getTestingRole());
}
hierarchy->updateNodeEquivalentElements(topHierNode);
}
LOG(INFO,getLogDomain(),logTr("Sorting roles for Ontology '%1'.").arg(ontology->getTerminologyName()),getLogObject());
for (QList::const_iterator it = satItemList->constBegin(), itEnd = satItemList->constEnd(); it != itEnd; ++it) {
COptimizedKPSetRoleTestingItem* item = *it;
if (!item->isEquivalentItem() && item != topItem) {
CRolePropertiesHierarchyNode* itemNode = hierarchy->getHierarchyNode(item->getTestingRole(),true);
item->setSatisfiableRoleHierarchyNode(itemNode);
cint64 itemSubsumingCount = item->getSubsumerRoleItemCount();
itemList.append(item);
if (itemSubsumingCount > topSubsumingItemCount) {
QList* subsumingConceptItemList = item->sortSubsumingConceptItemList();
for (QList::const_iterator subsumedIt = subsumingConceptItemList->constBegin(), subsumedItEnd = subsumingConceptItemList->constEnd(); subsumedIt != subsumedItEnd; ++subsumedIt) {
COptimizedKPSetRoleTestingItem* subsumedConceptItem = *subsumedIt;
cint64 subsumedItemSubsumingCount = subsumedConceptItem->getSubsumerRoleItemCount();
if (subsumedItemSubsumingCount == itemSubsumingCount) {
// mark as equivalent
subsumedConceptItem->setEquivalentItem(true);
itemNode->addEquivalentElement(subsumedConceptItem->getTestingRole());
} else {
break;
}
}
}
hierarchy->updateNodeEquivalentElements(itemNode);
}
}
LOG(INFO,getLogDomain(),logTr("Transitive Reduction for Ontology '%1'.").arg(ontology->getTerminologyName()),getLogObject());
for (QList::const_iterator it = itemList.constBegin(), itEnd = itemList.constEnd(); it != itEnd; ++it) {
COptimizedKPSetRoleTestingItem* item = *it;
if (!item->isEquivalentItem() && item != topItem) {
cint64 itemSubsumingCount = item->getSubsumerRoleItemCount();
CRolePropertiesHierarchyNode* itemHierNode = item->getSatisfiableRoleHierarchyNode();
QList* subsumingConceptItemList = item->getSubsumerRoleItemList();
QList::const_iterator subsumedIt = subsumingConceptItemList->constBegin(), subsumedItEnd = subsumingConceptItemList->constEnd();
cint64 eqCount = 0;
cint64 remainingSubsumingCount = itemSubsumingCount;
// remove direct equivalences
while (subsumedIt != subsumedItEnd) {
COptimizedKPSetRoleTestingItem* subsumedConceptItem = *subsumedIt;
cint64 subsumedItemSubsumingCount = subsumedConceptItem->getSubsumerRoleItemCount();
if (itemSubsumingCount != subsumedItemSubsumingCount) {
break;
} else {
++eqCount;
++subsumedIt;
--remainingSubsumingCount;
}
}
while (subsumedIt != subsumedItEnd && (*subsumedIt)->isEquivalentItem()) {
++subsumedIt;
}
// find first parent
if (subsumedIt == subsumedItEnd) {
// no parent, use top as parent
itemHierNode->makeParent(topHierNode);
} else {
itemHierNode->addPredecessorNode(topHierNode);
QList parentItemList;
while (subsumedIt != subsumedItEnd) {
COptimizedKPSetRoleTestingItem* subsumedConceptItem = *subsumedIt;
if (!subsumedConceptItem->isEquivalentItem()) {
subsumedConceptItem->setPredecessorItem(true);
CRolePropertiesHierarchyNode* subsumedHierNode = subsumedConceptItem->getSatisfiableRoleHierarchyNode();
itemHierNode->makeParent(subsumedHierNode);
parentItemList.append(subsumedConceptItem);
remainingSubsumingCount -= subsumedConceptItem->getSubsumerRoleItemCount()+1;
++subsumedIt;
break;
} else {
++subsumedIt;
}
}
bool searchForMoreParents = remainingSubsumingCount > 0;
while (subsumedIt != subsumedItEnd) {
COptimizedKPSetRoleTestingItem* subsumedConceptItem = *subsumedIt;
if (!subsumedConceptItem->isEquivalentItem()) {
bool predOfOnePrevParent = false;
if (searchForMoreParents) {
for (QList::const_iterator parentIt = parentItemList.constBegin(), parentItEnd = parentItemList.constEnd(); parentIt != parentItEnd && !predOfOnePrevParent; ++parentIt) {
COptimizedKPSetRoleTestingItem* parentItem = *parentIt;
if (parentItem->getSubsumerRoleItemSet()->contains(subsumedConceptItem)) {
predOfOnePrevParent = true;
}
}
}
subsumedConceptItem->setPredecessorItem(true);
CRolePropertiesHierarchyNode* subsumedHierNode = subsumedConceptItem->getSatisfiableRoleHierarchyNode();
if (!predOfOnePrevParent && searchForMoreParents) {
itemHierNode->makeParent(subsumedHierNode);
parentItemList.append(subsumedConceptItem);
} else {
itemHierNode->addPredecessorNode(subsumedHierNode);
}
}
++subsumedIt;
}
}
}
}
for (QList::const_iterator it = itemList.constBegin(), itEnd = itemList.constEnd(); it != itEnd; ++it) {
COptimizedKPSetRoleTestingItem* item = *it;
if (!item->isPredecessorItem() && !item->isEquivalentItem()) {
CRolePropertiesHierarchyNode* itemHierNode = item->getSatisfiableRoleHierarchyNode();
bottomHierNode->makeParent(itemHierNode);
}
}
LOG(INFO,getLogDomain(),logTr("Collect statistics for Ontology '%1'.").arg(ontology->getTerminologyName()),getLogObject());
#ifdef OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGSTATUSDESCRIPTION
statUpdateMutex.lock();
statusString = QString("Finished ontology role classification");
statUpdateMutex.unlock();
#endif
CClassification* classification = ontology->getClassification();
if (classification) {
CPropertyRoleClassification* propRoleClassification = ontPropItem->getPropertyRoleClassification();
CClassificationStatisticsCollectionStrings* classifStatCollStrings = ontPropItem->getClassificationStatisticsCollectionStrings();
CClassifierStatistics* classifierStats = ontPropItem->getClassifierStatistics();
classifStatCollStrings->addProcessingStatistics("role-classification-total-satisfiable-test-count",classifierStats->getTotalSatisfiableCount());
classifStatCollStrings->addProcessingStatistics("role-classification-satisfiable-tested-count",classifierStats->getTestedSatisfiableCount());
classifStatCollStrings->addProcessingStatistics("role-classification-satisfiable-derivate-tested-count",classifierStats->getDerivatedTestedSatisfiableCount());
classifStatCollStrings->addProcessingStatistics("role-classification-satisfiable-calculated-tested-count",classifierStats->getCalculatedTestedSatisfiableCount());
classifStatCollStrings->addProcessingStatistics("role-classification-satisfiable-pruned-tested-count",classifierStats->getPrunedTestedSatisfiableCount());
classifStatCollStrings->addProcessingStatistics("role-classification-satisfiable-told-tested-count",classifierStats->getToldSatisfiableCount()-classifierStats->getCalculatedTestedSatisfiableCount());
classifStatCollStrings->addProcessingStatistics("role-classification-total-subsumption-test-count",classifierStats->getTotalSatisfiableCount()*(classifierStats->getTotalSatisfiableCount()-1));
classifStatCollStrings->addProcessingStatistics("role-classification-subsumption-tested-count",classifierStats->getTestedSubsumptionCount());
classifStatCollStrings->addProcessingStatistics("role-classification-subsumption-subproperty-tested-count",classifierStats->getSubclassTestedSubsumptionCount());
classifStatCollStrings->addProcessingStatistics("role-classification-subsumption-subproperty-identifier-occur-tested-count",classifierStats->getSubclassIdentifierOccurTestedSubsumptionCount());
classifStatCollStrings->addProcessingStatistics("role-classification-subsumption-derivate-tested-count",classifierStats->getDerivatedTestedSubsumptionCount());
classifStatCollStrings->addProcessingStatistics("role-classification-subsumption-calculated-tested-count",classifierStats->getCalculatedTestedSubsumptionCount());
classifStatCollStrings->addProcessingStatistics("role-classification-subsumption-pruned-tested-count",classifierStats->getPrunedTestedSubsumptionCount());
classifStatCollStrings->addProcessingStatistics("role-classification-subsumption-told-tested-count",classifierStats->getToldSubsumptionCount()-classifierStats->getCalculatedTestedSubsumptionCount());
propRoleClassification->setRolePropertiesHierarchy(hierarchy);
propRoleClassification->setClassificationStatistics(classifStatCollStrings);
classification->setPropertyRoleClassification(propRoleClassification,optKPSetClassificationItem->isDataRolesClassification());
}
ontPropItem->setHasRemainingTests(false);
--mClassificationCount;
LOG(INFO,getLogDomain(),logTr("Roles of ontology '%1' classified.").arg(ontology->getTerminologyName()),getLogObject());
LOG(INFO,getLogDomain(),logTr("Used %1 satisfiable tests and %3 calculated subsumption tests.").arg(ontPropItem->getCalcedSatisfiableCount()).arg(ontPropItem->getClassifierStatistics()->getCalculatedTestedSubsumptionCount()),getLogObject());
LOG(INFO,getLogDomain(),logTr("Confirmed %1 of %2 possible subsumer roles.").arg(optKPSetClassificationItem->getTruePossibleSubsumerCount()).arg(optKPSetClassificationItem->getPossibleSubsumerCount()),getLogObject());
LOG(INFO,getLogDomain(),logTr("Confirmed %1 and invalidated %2 possible subsumer roles with calculation.").arg(optKPSetClassificationItem->getCalculatedTruePossibleSubsumerCount()).arg(optKPSetClassificationItem->getFalsePossibleSubsumerCount()),getLogObject());
}
ontPropItem->submitHierarchyConstructed();
ontPropItem->doClassifiedCallback();
return true;
}
}; // end namespace Classifier
}; // end namespace Reasoner
}; // end namespace Konclude