/* * 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 "COptimizedSubClassSubsumptionClassifierThread.h" namespace Konclude { namespace Reasoner { namespace Classifier { #ifdef OPTIMIZEDSUBCLASSCLASSIFIERDEBUGCOUTOUTPUT #define OPTIMIZEDSUBCLASSCLASSIFIERDEBUGB #endif #ifdef OPTIMIZEDSUBCLASSCLASSIFIERDEBUGCOUTOUTPUT #define OPTIMIZEDSUBCLASSCLASSIFIERDEBUGB #endif #ifdef OPTIMIZEDSUBCLASSCLASSIFIERDEBUGBOXDESCRIPTION #define OPTIMIZEDSUBCLASSCLASSIFIERDEBUGB #endif #ifdef OPTIMIZEDSUBCLASSCLASSIFIERDEBUGSTATUSDESCRIPTION #define OPTIMIZEDSUBCLASSCLASSIFIERDEBUGB #endif COptimizedSubClassSubsumptionClassifierThread::COptimizedSubClassSubsumptionClassifierThread(CReasonerManager *reasonerManager) : CSubsumptionClassifierThread(reasonerManager), CLogIdentifier("::Konclude::Reasoner::Kernel::Classifier::OptimizedSubClassSubsumptionClassifierThread",this) { satTestedCount = 0; totalToTestCount = 0; mClassificationCount = 0; mSatNodeExpCacheReader = nullptr; mSatNodeExpCache = dynamic_cast(reasonerManager->getSaturationAssociationExpansionCache()); if (mSatNodeExpCache) { mSatNodeExpCacheReader = mSatNodeExpCache->createCacheReader(); } mStatFastSubClassCheckCacheTryCount = 0; mStatFastSubClassCheckCacheSuccCount = 0; } COptimizedSubClassSubsumptionClassifierThread::~COptimizedSubClassSubsumptionClassifierThread() { } CTaxonomy *COptimizedSubClassSubsumptionClassifierThread::createEmptyTaxonomyForOntology(CConcreteOntology *ontology, CConfigurationBase *config) { CTBox *tBox = ontology->getTBox(); CConceptVector *conVec = tBox->getConceptVector(); CConcept *topConcept = conVec->getData(1); CConcept *bottomConcept = conVec->getData(0); CPartialPruningTaxonomy *tax = new CPartialPruningTaxonomy(topConcept,bottomConcept); return tax->readConfig(config); } void COptimizedSubClassSubsumptionClassifierThread::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.OptimizedSubClassSubsumptionClassifier.MultipliedUnitsParallelSatisfiableCalculationCount",1,&mulConfigErrorFlag); confMaxTestParallelCount = processorCount*multiplicator; bool maxConfigErrorFlag = false; cint64 maxParallel = CConfigDataReader::readConfigInteger(config,"Konclude.Calculation.Classification.OptimizedSubClassSubsumptionClassifier.MaximumParallelSatisfiableCalculationCount",1,&maxConfigErrorFlag); if (!maxConfigErrorFlag) { if (!mulConfigErrorFlag) { confMaxTestParallelCount = qMin(confMaxTestParallelCount,maxParallel); } else { confMaxTestParallelCount = maxParallel; } } } else { confMaxTestParallelCount = 1; } } CSubsumptionClassifierThread *COptimizedSubClassSubsumptionClassifierThread::scheduleOntologyClassification(CConcreteOntology *ontology, CClassificationCalculationSupport *classificationSupport, CConfigurationBase *config) { CTaxonomy *taxonomy = createEmptyTaxonomyForOntology(ontology,config); COptimizedSubClassOntologyClassificationItem *ontClassItem = new COptimizedSubClassOntologyClassificationItem(config,statistics); ontClassItem->initTaxonomyConcepts(ontology,taxonomy); ontItemList.append(ontClassItem); processingOntItemList.append(ontClassItem); ontItemHash.insert(ontology,ontClassItem); readCalculationConfig(ontClassItem->getCalculationConfiguration()); if (CConfigDataReader::readConfigBoolean(ontClassItem->getCalculationConfiguration(),"Konclude.Calculation.Classification.IndividualDependenceTracking",true)) { ontClassItem->setIndividualDependenceTrackingCollector(new CIndividualDependenceTrackingCollector()); } CPartialPruningTaxonomy *parTax = dynamic_cast(taxonomy); if (parTax) { COntologyClassClassificationItem *ontClassItem = (COntologyClassClassificationItem*)ontItemHash.value(ontology); parTax->createStatistics(ontClassItem->getClassifierStatistics()); } createObviousSubsumptionSatisfiableTestingOrder(ontClassItem); if (satTestedCount == totalToTestCount) { satTestedCount = 0; totalToTestCount = ontClassItem->getRemainingSatisfiableTestsCount(); classStartTime.start(); } else { totalToTestCount += ontClassItem->getRemainingSatisfiableTestsCount(); } ++mClassificationCount; return this; } void COptimizedSubClassSubsumptionClassifierThread::createObviousSubsumptionSatisfiableTestingOrder(COptimizedSubClassOntologyClassificationItem* ontClassItem) { CPrecomputation* precomputation = ontClassItem->getOntology()->getPrecomputation(); CSaturationData* saturationData = precomputation->getSaturationModelData(); bool subsumerSaturationExtraction = CConfigDataReader::readConfigBoolean(ontClassItem->getCalculationConfiguration(),"Konclude.Calculation.Classification.SaturationSubsumerExtraction",true); if (saturationData && subsumerSaturationExtraction) { createObviousSubsumptionSatisfiableTestingOrderFromSaturationData(ontClassItem); } else { createObviousSubsumptionSatisfiableTestingOrderFromBuildData(ontClassItem); } } void COptimizedSubClassSubsumptionClassifierThread::createObviousSubsumptionSatisfiableTestingOrderFromSaturationData(COptimizedSubClassOntologyClassificationItem* ontClassItem) { CTBox *tBox = ontClassItem->getOntology()->getDataBoxes()->getTBox(); CBOXHASH* candidateEqConHash = tBox->getCandidateEquivalentConceptHash(false); CBOXHASH* eqConCandidateHash = tBox->getEquivalentConceptCandidateHash(false); CBOXSET* eqConNonCandidateSet = tBox->getEquivalentConceptNonCandidateSet(false); CConcreteOntology *onto = ontClassItem->getOntology(); CConcept *topConcept = onto->getDataBoxes()->getTopConcept(); CConcept *bottomConcept = onto->getDataBoxes()->getBottomConcept(); QHash* conceptSatItemHash = ontClassItem->getConceptSatisfiableTestItemHash(); QList* satTestItemContainer = ontClassItem->getConceptSatisfiableTestItemContainer(); COptimizedSubClassSatisfiableTestingItem* topItem = ontClassItem->getConceptSatisfiableTestItem(topConcept,true); COptimizedSubClassSatisfiableTestingItem* bottomItem = ontClassItem->getConceptSatisfiableTestItem(bottomConcept,true); ontClassItem->initTopBottomSatisfiableTestingItems(topItem,bottomItem); QList* nextItemList = ontClassItem->getNextSatisfiableTestingItemList(); QSet* nextCandItemSet = ontClassItem->getNextCandidateSatisfiableTestingItemSet(); QSet* remainingCandItemSet = ontClassItem->getRemainingCandidateSatisfiableTestingItemSet(); if (topConcept->getOperandList()) { // has not absorbed GCIs nextItemList->append(topItem); } bool invalidatedConRefLinking = false; QHash* conRefLinkDataHash = ontClassItem->getConceptReferenceLinkingDataHash(); QList extClassConceptList; CPrecomputedSaturationSubsumerExtractor* precSatSubsumerExtractor = ontClassItem->getPrecomputedSaturationSubsumerExtractor(true); CBOXSET *conceptHash = tBox->getActiveClassConceptSet(false); if (conceptHash) { for (CBOXSET::const_iterator it = conceptHash->constBegin(), itEnd = conceptHash->constEnd(); it != itEnd; ++it) { CConcept *concept = (*it); if (concept && concept != topConcept && concept != bottomConcept || (concept == topConcept && topConcept->getOperandList())) { COptimizedSubClassSatisfiableTestingItem* subsumerItem = ontClassItem->getConceptSatisfiableTestItem(concept,true); CConceptProcessData* conProcData = (CConceptProcessData*)concept->getConceptData(); CConceptSaturationReferenceLinkingData* conRefSatLinking = (CConceptSaturationReferenceLinkingData*)conProcData->getConceptReferenceLinking(); if (!conRefSatLinking) { conRefSatLinking = new CConceptSaturationReferenceLinkingData(); conProcData->setConceptReferenceLinking(conRefSatLinking); } conRefLinkDataHash->insert(concept,subsumerItem); if (conRefSatLinking->getClassifierReferenceLinkingData() || invalidatedConRefLinking) { conProcData->setInvalidatedReferenceLinking(true); } else { conRefSatLinking->setClassifierReferenceLinkingData(subsumerItem); } extClassConceptList.append(concept); } } } for (QList::const_iterator it = extClassConceptList.constBegin(), itEnd = extClassConceptList.constEnd(); it != itEnd; ++it) { CConcept* concept(*it); CConceptProcessData* conProcData = (CConceptProcessData*)concept->getConceptData(); CConceptSaturationReferenceLinkingData* conRefSatLinking = (CConceptSaturationReferenceLinkingData*)conProcData->getConceptReferenceLinking(); COptimizedSubClassSatisfiableTestingItem* classItem = (COptimizedSubClassSatisfiableTestingItem*)conRefSatLinking->getClassifierReferenceLinkingData(); bool unsatisfiableFlag = false; bool insufficientFlag = false; bool incompleteProcessingFlag = false; if (precSatSubsumerExtractor->getConceptFlags(concept,&unsatisfiableFlag,&insufficientFlag,&incompleteProcessingFlag)) { if (!unsatisfiableFlag) { bool possibleSubsumerFlag = false; precSatSubsumerExtractor->extractSubsumers(concept,classItem,&possibleSubsumerFlag,ontClassItem->getIndividualDependenceTrackingCollector(),classItem); cint64 foundSubsumerCount = classItem->getSubsumingConceptItemCount(); classItem->setUnprocessedPredecessorItems(foundSubsumerCount); if (!insufficientFlag) { classItem->setResultSatisfiableDerivated(true); } ontClassItem->incRemainingSatisfiableTestsCount(); remainingCandItemSet->insert(classItem); if (foundSubsumerCount <= 0) { nextItemList->append(classItem); } } else { ontClassItem->incRemainingSatisfiableTestsCount(); classItem->setResultUnsatisfiableDerivated(true); nextItemList->append(classItem); } } } } void COptimizedSubClassSubsumptionClassifierThread::createObviousSubsumptionSatisfiableTestingOrderFromBuildData(COptimizedSubClassOntologyClassificationItem* ontClassItem) { CTBox *tBox = ontClassItem->getOntology()->getDataBoxes()->getTBox(); CBOXHASH* candidateEqConHash = tBox->getCandidateEquivalentConceptHash(false); CBOXHASH* eqConCandidateHash = tBox->getEquivalentConceptCandidateHash(false); CBOXSET* eqConNonCandidateSet = tBox->getEquivalentConceptNonCandidateSet(false); CConcreteOntology *onto = ontClassItem->getOntology(); CConcept *topConcept = onto->getDataBoxes()->getTopConcept(); CConcept *bottomConcept = onto->getDataBoxes()->getBottomConcept(); QHash* conceptSatItemHash = ontClassItem->getConceptSatisfiableTestItemHash(); QList* satTestItemContainer = ontClassItem->getConceptSatisfiableTestItemContainer(); COptimizedSubClassSatisfiableTestingItem* topItem = ontClassItem->getConceptSatisfiableTestItem(topConcept,true); COptimizedSubClassSatisfiableTestingItem* bottomItem = ontClassItem->getConceptSatisfiableTestItem(bottomConcept,true); ontClassItem->initTopBottomSatisfiableTestingItems(topItem,bottomItem); QList* nextItemList = ontClassItem->getNextSatisfiableTestingItemList(); QSet* nextCandItemSet = ontClassItem->getNextCandidateSatisfiableTestingItemSet(); QSet* remainingCandItemSet = ontClassItem->getRemainingCandidateSatisfiableTestingItemSet(); CConcept* univConnNomValueConcept = tBox->getUniversalConnectionNominalValueConcept(); if (topConcept->getOperandList() || univConnNomValueConcept) { // has not absorbed GCIs nextItemList->append(topItem); } bool invalidatedConRefLinking = false; QHash* conRefLinkDataHash = ontClassItem->getConceptReferenceLinkingDataHash(); CBOXSET *conceptHash = tBox->getActiveClassConceptSet(false); if (conceptHash) { for (CBOXSET::const_iterator it = conceptHash->constBegin(), itEnd = conceptHash->constEnd(); it != itEnd; ++it) { CConcept *concept = (*it); if (concept && concept != topConcept && concept != bottomConcept || (concept == topConcept && topConcept->getOperandList())) { QSet > conSet; QList > conList; QSet conSubsumSet; conList.append(QPair(concept,false)); conSet.insert(QPair(concept,false)); while (!conList.isEmpty()) { QPair conNegPair = conList.takeFirst(); CConcept *con = conNegPair.first; bool neg = conNegPair.second; qint64 conOpCode = con->getProcessingOperatorTag(); cint64 opCount = con->getOperandCount(); cint64 param = con->getParameter(); if (conOpCode == CCAND && (!neg || neg && opCount <= 1) || conOpCode == CCOR && (neg || !neg && opCount <= 1)) { CSortedNegLinker *opConIt = con->getOperandList(); while (opConIt) { CConcept *opCon = opConIt->getData(); bool opNeg = opConIt->isNegated(); QPair opConNegPair(opCon,neg ^ opNeg); if (opCon->hasClassName()) { if (neg ^ opNeg) { if (!conSet.contains(opConNegPair)) { conSet.insert(opConNegPair); conList.append(opConNegPair); } } else { conSubsumSet.insert(opCon); } } else { if (!conSet.contains(opConNegPair)) { conSet.insert(opConNegPair); conList.append(opConNegPair); } } opConIt = opConIt->getNext(); } } else if (!neg && (conOpCode == CCSOME || conOpCode == CCATLEAST && param >= 1) || neg && (conOpCode == CCALL || conOpCode == CCATMOST && param >= 2)) { CRole* role = con->getRole(); CSortedNegLinker* superRoleIt = role->getIndirectSuperRoleList(); while (superRoleIt) { CRole* superRole = superRoleIt->getData(); bool superRoleNeg = superRoleIt->isNegated(); CSortedNegLinker* domainConIt = superRole->getDomainRangeConceptList(superRoleNeg); while (domainConIt) { CConcept *domCon = domainConIt->getData(); bool opDomNeg = domainConIt->isNegated(); QPair domConNegPair(domCon,neg ^ opDomNeg); if (domCon->hasClassName()) { if (neg ^ opDomNeg) { if (!conSet.contains(domConNegPair)) { conSet.insert(domConNegPair); conList.append(domConNegPair); } } else { conSubsumSet.insert(domCon); } } else { if (!conSet.contains(domConNegPair)) { conSet.insert(domConNegPair); conList.append(domConNegPair); } } domainConIt = domainConIt->getNext(); } superRoleIt = superRoleIt->getNext(); } } else if (!neg && (conOpCode == CCNOMINAL)) { CIndividual* individual = con->getNominalIndividual(); CConceptAssertionLinker* assConLinkIt = individual->getAssertionConceptLinker(); while (assConLinkIt) { CConcept* assCon = assConLinkIt->getData(); bool assConNeg = assConLinkIt->isNegated(); QPair assConNegPair(assCon,neg ^ assConNeg); if (assCon->hasClassName()) { if (neg ^ assConNeg) { if (!conSet.contains(assConNegPair)) { conSet.insert(assConNegPair); conList.append(assConNegPair); } } else { conSubsumSet.insert(assCon); } } else { if (!conSet.contains(assConNegPair)) { conSet.insert(assConNegPair); conList.append(assConNegPair); } } assConLinkIt = assConLinkIt->getNext(); } } } //QString iriClassNameString = CIRIName::getRecentIRIName(concept->getClassNameLinker()); //if (iriClassNameString == "http://www.owllink.org/testsuite/galen#Haem") { // bool bug = true; //} COptimizedSubClassSatisfiableTestingItem* subsumerItem = ontClassItem->getConceptSatisfiableTestItem(concept,true); CConceptProcessData* conProcData = (CConceptProcessData*)concept->getConceptData(); CConceptSaturationReferenceLinkingData* conRefSatLinking = (CConceptSaturationReferenceLinkingData*)conProcData->getConceptReferenceLinking(); if (!conRefSatLinking) { conRefSatLinking = new CConceptSaturationReferenceLinkingData(); conProcData->setConceptReferenceLinking(conRefSatLinking); } conRefLinkDataHash->insert(concept,subsumerItem); if (conRefSatLinking->getClassifierReferenceLinkingData() || invalidatedConRefLinking) { conProcData->setInvalidatedReferenceLinking(true); } else { conRefSatLinking->setClassifierReferenceLinkingData(subsumerItem); } bool foundSubsumingConcepts = false; for (QSet::const_iterator it = conSubsumSet.constBegin(), itEnd = conSubsumSet.constEnd(); it != itEnd; ++it) { CConcept* subsumedConcept = *it; COptimizedSubClassSatisfiableTestingItem* subsumedItem = ontClassItem->getConceptSatisfiableTestItem(subsumedConcept,true); subsumedItem->addSuccessorSatisfiableTestItem(subsumerItem); subsumerItem->incUnprocessedPredecessorItems(); foundSubsumingConcepts = true; } ontClassItem->incRemainingSatisfiableTestsCount(); remainingCandItemSet->insert(subsumerItem); if (!foundSubsumingConcepts) { nextItemList->append(subsumerItem); } } } } } QString COptimizedSubClassSubsumptionClassifierThread::getStatusString() { statUpdateMutex.lock(); QString string = statusString; string.detach(); statUpdateMutex.unlock(); return string; } CClassificationProgress* COptimizedSubClassSubsumptionClassifierThread::getClassificationProgress() { if (satTestedCount != totalToTestCount) { cint64 testedClasses = satTestedCount; cint64 totalClasses = totalToTestCount; cint64 elapsedTime = classStartTime.elapsed(); double remainingMilliSeconds = 0.; double progessPercent = 0.; if (elapsedTime <= 0 && testedClasses > 0) { remainingMilliSeconds = 0.; } else { remainingMilliSeconds = ((double)elapsedTime / (double)satTestedCount) * (totalToTestCount-testedClasses); } if (totalClasses <= 0) { progessPercent = 0.; } else { progessPercent = ((double)testedClasses / (double)totalClasses) * 100.; } cint64 classificCount = mClassificationCount; mClassifyProgess.setClassificationCount(classificCount); mClassifyProgess.setProgessPercent(progessPercent); mClassifyProgess.setRemainingMilliSeconds(remainingMilliSeconds); mClassifyProgess.setTestedSatisfiable(testedClasses); mClassifyProgess.setTotalSatisfiable(totalClasses); } else { mClassifyProgess.setProgessPercent(0.); mClassifyProgess.setRemainingMilliSeconds(0.); mClassifyProgess.setTestedSatisfiable(satTestedCount); mClassifyProgess.setTotalSatisfiable(totalToTestCount); } return &mClassifyProgess; } bool COptimizedSubClassSubsumptionClassifierThread::createNextSubsumtionTest() { COntologyClassificationItem *loopOntClassItem = 0; bool workTestCreated = false; while (!workTestCreated && !processingOntItemList.isEmpty()) { COntologyClassificationItem *ontClassItem = processingOntItemList.first(); if (ontClassItem == loopOntClassItem) { // don't run into infinite loop without doing something break; } COptimizedSubClassOntologyClassificationItem *optSubClassItem = (COptimizedSubClassOntologyClassificationItem *)ontClassItem; while (!workTestCreated && optSubClassItem->hasRemainingSatisfiableTests() && !optSubClassItem->isTaxonomyConstructionFailed()) { // get next satisfiable test QList* nextItemList = optSubClassItem->getNextSatisfiableTestingItemList(); QSet* nextCandItemSet = optSubClassItem->getNextCandidateSatisfiableTestingItemSet(); QSet* remainingCandItemSet = optSubClassItem->getRemainingCandidateSatisfiableTestingItemSet(); COptimizedSubClassSatisfiableTestingItem* nextSatTestItem = nullptr; if (!nextItemList->isEmpty()) { nextSatTestItem = nextItemList->takeFirst(); remainingCandItemSet->remove(nextSatTestItem); nextCandItemSet->remove(nextSatTestItem); } else if (!nextCandItemSet->isEmpty()) { COptimizedSubClassSatisfiableTestingItem* minItem = nullptr; cint64 minUnpPredCount = 0; cint64 maxItCount = 100; for (QSet::const_iterator it = nextCandItemSet->constBegin(), itEnd = nextCandItemSet->constEnd(); it != itEnd && maxItCount > 0; ++it, --maxItCount) { COptimizedSubClassSatisfiableTestingItem* 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()) { COptimizedSubClassSatisfiableTestingItem* minItem = nullptr; //cint64 minUnpPredCount = 0; //for (QSet::const_iterator it = remainingCandItemSet->constBegin(), itEnd = remainingCandItemSet->constEnd(); it != itEnd; ++it) { // COptimizedSubClassSatisfiableTestingItem* item = (*it); // cint64 predCount = item->getUnprocessedPredecessorItemCount(); // if (!minItem || minUnpPredCount < predCount) { // minUnpPredCount = predCount; // minItem = item; // } //} //nextSatTestItem = minItem; //remainingCandItemSet->remove(nextSatTestItem); QSet::const_iterator itNext = remainingCandItemSet->constBegin(); nextSatTestItem = *itNext; remainingCandItemSet->remove(nextSatTestItem); } if (nextSatTestItem && !nextSatTestItem->isSatisfiableTestOrdered()) { optSubClassItem->decRemainingSatisfiableTestsCount(); optSubClassItem->incRunningSatisfiableTestsCount(); if (calculateSatisfiable(optSubClassItem,nextSatTestItem)) { workTestCreated = true; } else { interpreteSatisfiableResult(optSubClassItem,nextSatTestItem->getSatisfiableConcept(),nextSatTestItem->getSatisfiableTestedResult()); } } } if (!workTestCreated) { if (optSubClassItem->hasAllSatisfiableTestsCompleted() || optSubClassItem->isTaxonomyConstructionFailed()) { finishOntologyClassification(optSubClassItem); processingOntItemList.removeFirst(); } else { processingOntItemList.removeFirst(); processingOntItemList.append(ontClassItem); loopOntClassItem = ontClassItem; } } } return workTestCreated; } bool COptimizedSubClassSubsumptionClassifierThread::calculateSatisfiable(COptimizedSubClassOntologyClassificationItem *optSubClassItem, COptimizedSubClassSatisfiableTestingItem* nextSatTestItem) { CSatisfiableCalculationJob* satCalcJob = nullptr; CClassClassificationComputationItem *workItem = 0; CConcept* concept = nextSatTestItem->getSatisfiableConcept(); nextSatTestItem->setSatisfiableTestOrdered(true); bool satisfiableFlag = false; #ifdef OPTIMIZEDSUBCLASSCLASSIFIERDEBUGB QString iriClassNameString = CIRIName::getRecentIRIName(concept->getClassNameLinker()); #endif #ifdef OPTIMIZEDSUBCLASSCLASSIFIERDEBUGSTATUSDESCRIPTION statUpdateMutex.lock(); statusString = QString("[%2/%3] Calculating, is '%1' satisfiable").arg(iriClassNameString).arg(optSubClassItem->getClassifierStatistics()->getTestedSatisfiableCount()).arg(optSubClassItem->getClassifierStatistics()->getTotalSatisfiableCount()); statUpdateMutex.unlock(); #endif #ifdef OPTIMIZEDSUBCLASSCLASSIFIERDEBUGLOGOUTPUT LOG(INFO,getLogDomain(),QString("Calculating whether '%1' is satisfiable").arg(iriClassNameString),this); #endif #ifdef OPTIMIZEDSUBCLASSCLASSIFIERDEBUGCOUTOUTPUT cout<isResultSatisfiableDerivated()) { satisfiableFlag = true; nextSatTestItem->setSatisfiableTested(true); nextSatTestItem->setSatisfiableTestedResult(true); return false; } if (nextSatTestItem->isResultUnsatisfiableDerivated()) { satisfiableFlag = false; nextSatTestItem->setSatisfiableTested(true); nextSatTestItem->setSatisfiableTestedResult(false); return false; } CPrecomputedSaturationSubsumerExtractor* precSatSubsumerExtractor = optSubClassItem->getPrecomputedSaturationSubsumerExtractor(false); bool unsatisfiableFlag = false; if (precSatSubsumerExtractor && precSatSubsumerExtractor->getConceptFlags(concept,&unsatisfiableFlag,nullptr,nullptr) && unsatisfiableFlag) { satisfiableFlag = false; nextSatTestItem->setSatisfiableTested(true); nextSatTestItem->setSatisfiableTestedResult(false); return false; } if (fastSatisfiableOnlySubClassPrecheckTest(optSubClassItem,nextSatTestItem,&satisfiableFlag)) { nextSatTestItem->setSatisfiableTested(true); nextSatTestItem->setSatisfiableTestedResult(satisfiableFlag); return false; } CSatisfiableCalculationJobGenerator satCalcJobGen(optSubClassItem->getOntology()); satCalcJob = satCalcJobGen.getSatisfiableCalculationJob(concept); QHash *workHash = optSubClassItem->getWorkItemHash(); CClassifierStatistics *ontClassStat = optSubClassItem->getClassifierStatistics(); if (ontClassStat) { ontClassStat->incCalculatedTestedSatisfiableCount(1); } workItem = new CClassClassificationComputationItem(satCalcJob,concept); workHash->insertMulti(satCalcJob,workItem); workOntItemHash.insert(workItem,optSubClassItem); QHash* conRefLinkDataHash = optSubClassItem->getConceptReferenceLinkingDataHash(); satCalcJob->setSatisfiableClassificationMessageAdapter(new CSatisfiableTaskClassificationMessageAdapter(concept,optSubClassItem->getOntology(),this,nullptr, CSatisfiableTaskClassificationMessageAdapter::EFEXTRACTSUBSUMERSROOTNODE | CSatisfiableTaskClassificationMessageAdapter::EFEXTRACTOTHERNODESSINGLEDEPENDENCY | CSatisfiableTaskClassificationMessageAdapter::EFEXTRACTSUBSUMERSOTHERNODES)); if (optSubClassItem->getIndividualDependenceTrackingCollector()) { satCalcJob->setSatisfiableTaskIndividualDependenceTrackingAdapter(new CSatisfiableTaskIndividualDependenceTrackingAdapter(optSubClassItem->getIndividualDependenceTrackingCollector(),nextSatTestItem)); } optSubClassItem->incCurrentCalculatingCount(); processCalculationJob(satCalcJob,optSubClassItem,workItem); return true; } CIndividualSaturationProcessNode* COptimizedSubClassSubsumptionClassifierThread::getSaturationIndividualNodeForConcept(CConcept* concept, bool negated) { CIndividualSaturationProcessNode* node = nullptr; CConceptData* conceptData = concept->getConceptData(); if (conceptData) { CConceptProcessData* conProcData = (CConceptProcessData*)conceptData; CConceptReferenceLinking* conRefLinking = conProcData->getConceptReferenceLinking(); if (conRefLinking) { CConceptSaturationReferenceLinkingData* confSatRefLinkingData = (CConceptSaturationReferenceLinkingData*)conRefLinking; CSaturationConceptReferenceLinking* satCalcRefLinkData = confSatRefLinkingData->getConceptSaturationReferenceLinkingData(negated); if (satCalcRefLinkData) { node = (CIndividualSaturationProcessNode*)satCalcRefLinkData->getIndividualProcessNodeForConcept(); } } } return node; } bool COptimizedSubClassSubsumptionClassifierThread::hasCachedSaturationIndividualNodeAssociatedExpansionProplematicConcept(CCacheEntry* cacheEntry, CConcept* testingConcept) { if (!cacheEntry) { return true; } CSaturationNodeAssociatedExpansionCacheEntry* satNodeExpCacheEntry = (CSaturationNodeAssociatedExpansionCacheEntry*)cacheEntry; CSaturationNodeAssociatedDeterministicConceptExpansion* detExp = satNodeExpCacheEntry->getDeterministicConceptExpansion(); CSaturationNodeAssociatedNondeterministicConceptExpansion* ndetExpLinker = satNodeExpCacheEntry->getNondeterministicConceptExpansionLinker(); if (!detExp && !ndetExpLinker) { return true; } CCacheValue cacheValue(mSatNodeExpCacheReader->getCacheValue(testingConcept,true)); if (detExp) { CSaturationNodeAssociatedConceptLinker* cacheValueExpLinker = detExp->getConceptExpansionLinker(&cacheValue); if (cacheValueExpLinker) { return true; } } if (ndetExpLinker && (!detExp || detExp->requiresNonDeterministicExpansion())) { bool allNonDetExpansionsProblematic = true; for (CSaturationNodeAssociatedNondeterministicConceptExpansion* ndetExpLinkerIt = ndetExpLinker; allNonDetExpansionsProblematic && ndetExpLinkerIt; ndetExpLinkerIt = ndetExpLinkerIt->getNext()) { CSaturationNodeAssociatedConceptLinker* ndetCacheValueExpLinker = ndetExpLinkerIt->getConceptExpansionLinker(&cacheValue); if (!ndetCacheValueExpLinker) { allNonDetExpansionsProblematic = false; } } if (allNonDetExpansionsProblematic) { return true; } } return false; } CCacheEntry* COptimizedSubClassSubsumptionClassifierThread::getAssociatedSaturationCacheEntry(COptimizedSubClassSatisfiableTestingItem* classConItem) { CCacheEntry* cacheEntry = classConItem->getFastSatisfiabilityTestedSaturationCacheEntry(); if (!cacheEntry) { CConcept* concept = classConItem->getSatisfiableConcept(); CIndividualSaturationProcessNode* satNode = getSaturationIndividualNodeForConcept(concept,false); cacheEntry = mSatNodeExpCacheReader->getCacheEntry(satNode); classConItem->setFastSatisfiabilityTestedSaturationCacheEntry(cacheEntry); } return cacheEntry; } bool COptimizedSubClassSubsumptionClassifierThread::fastSatisfiableOnlySubClassPrecheckTest(COptimizedSubClassOntologyClassificationItem *optSubClassItem, COptimizedSubClassSatisfiableTestingItem* nextSatTestItem, bool* isSatisfiableFlag) { QHash* conceptSatItemHash = optSubClassItem->getConceptSatisfiableTestItemHash(); CBOXHASH* triggerImpHash = optSubClassItem->getOntology()->getTBox()->getTriggerImplicationHash(false); CConcept* concept = nextSatTestItem->getSatisfiableConcept(); //QString className = CIRIName::getRecentIRIName(concept->getClassNameLinker()); //if (className == "galen#Salmonella" || className == "http://www.owllink.org/testsuite/galen#SalmonellaGroupA") { // bool bug = true; //} bool satFlag = false; bool testComplete = false; if (concept->getOperatorCode() == CCSUB) { cint64 conCount = concept->getOperandCount(); if (conCount == 1) { CSortedNegLinker* opLinkerIt = concept->getOperandList(); CConcept* firstConcept = opLinkerIt->getData(); cint64 firstOpCode = firstConcept->getOperatorCode(); CConcept* subClassConcept = nullptr; if (!opLinkerIt->isNegated() && (firstOpCode == CCATOM || firstOpCode == CCSUB || firstOpCode == CCEQ)) { subClassConcept = firstConcept; } if ((!triggerImpHash || !triggerImpHash->contains(concept)) && subClassConcept) { COptimizedSubClassSatisfiableTestingItem* subClassConItem = conceptSatItemHash->value(subClassConcept); if (subClassConItem && subClassConItem->isSatisfiableTested()) { if (!triggerImpHash || !triggerImpHash->contains(subClassConcept)) { ++mStatFastSubClassCheckCacheTryCount; CCacheEntry* superCacheEntry = getAssociatedSaturationCacheEntry(subClassConItem); if (!hasCachedSaturationIndividualNodeAssociatedExpansionProplematicConcept(superCacheEntry,concept)) { nextSatTestItem->setFastSatisfiabilityTestedSaturationCacheEntry(superCacheEntry); nextSatTestItem->setSuccessfullyFastSatisfiabilityTested(true); ++mStatFastSubClassCheckCacheSuccCount; QList* subsumedSubsumingConList = subClassConItem->getSubsumingConceptItemList(); for (QList::const_iterator it = subsumedSubsumingConList->constBegin(), itEnd = subsumedSubsumingConList->constEnd(); it != itEnd; ++it) { COptimizedSubClassSatisfiableTestingItem* subsumedItem = (*it); if (subClassConItem != subsumedItem && subsumedItem != nextSatTestItem) { nextSatTestItem->addSubsumingConceptItem(subsumedItem); } } nextSatTestItem->addSubsumingConceptItem(subClassConItem); satFlag = subClassConItem->getSatisfiableTestedResult(); testComplete = true; } } } } } } else if (concept->getOperatorCode() == CCATOM) { COptimizedSubClassSatisfiableTestingItem* topClassConItem = optSubClassItem->getTopConceptSatisfiableTestItem(); if (topClassConItem) { CCacheEntry* topCacheEntry = getAssociatedSaturationCacheEntry(topClassConItem); ++mStatFastSubClassCheckCacheTryCount; if (!hasCachedSaturationIndividualNodeAssociatedExpansionProplematicConcept(topCacheEntry,concept)) { nextSatTestItem->setFastSatisfiabilityTestedSaturationCacheEntry(topCacheEntry); nextSatTestItem->setSuccessfullyFastSatisfiabilityTested(true); ++mStatFastSubClassCheckCacheSuccCount; satFlag = true; testComplete = true; } } } if (satFlag && isSatisfiableFlag) { *isSatisfiableFlag = true; } return testComplete; } CSubsumptionClassifierThread *COptimizedSubClassSubsumptionClassifierThread::processCalculationJob(CSatisfiableCalculationJob* job, COntologyClassClassificationItem *ontClassItem, CClassClassificationComputationItem* workItem) { CClassificationCalculationStatisticsCollection* statColl = nullptr; if (ontClassItem->isCollectProcessStatisticsActivated()) { statColl = ontClassItem->getCalculationStatisticsCollection(); } job->setCalclulationStatisticsCollector(statColl); CTestCalculatedCallbackEvent *testResultCallback = new CTestCalculatedCallbackEvent(this,job,workItem,statColl); job->setCalculationConfiguration(ontClassItem->getCalculationConfiguration()); CSubsumptionClassifierThread::processCalculationJob(job,ontClassItem,testResultCallback); return this; } bool COptimizedSubClassSubsumptionClassifierThread::processToldClassificationMessage(COntologyClassificationItem *ontClassItem, CClassificationMessageData* messageDataLinker, CMemoryPool* memoryPools) { COptimizedSubClassOntologyClassificationItem *optSubClassItem = (COptimizedSubClassOntologyClassificationItem *)ontClassItem; CClassificationMessageData* messageDataLinkerIt = messageDataLinker; while (messageDataLinkerIt) { CClassificationMessageData* messageData = messageDataLinkerIt; if (messageData->getClassificationMessageDataType() == CClassificationMessageData::TELLCLASSSUBSUMPTION) { CClassificationClassSubsumptionMessageData* subsumMessageData = (CClassificationClassSubsumptionMessageData*)messageData; CConcept* subsumedConcept = subsumMessageData->getSubsumedConcept(); CCLASSSUBSUMPTIONMESSAGELIST* subsumerList = subsumMessageData->getClassSubsumerList(); COptimizedSubClassSatisfiableTestingItem* subsumedItem = nullptr; subsumedItem = optSubClassItem->getConceptSatisfiableTestItem(subsumedConcept); //QString iriClassNameString = CIRIName::getRecentIRIName(subsumedItem->getSatisfiableConcept()->getClassNameLinker()); //if (iriClassNameString == "http://www.owllink.org/testsuite/galen#LowerLobeOfLeftLung") { // bool bug = true; //} if (subsumerList) { for (CCLASSSUBSUMPTIONMESSAGELIST::const_iterator it = subsumerList->constBegin(), itEnd = subsumerList->constEnd(); it != itEnd; ++it) { CConcept* subsumerConcept(*it); COptimizedSubClassSatisfiableTestingItem* subsumerItem = optSubClassItem->getConceptSatisfiableTestItem(subsumerConcept); subsumedItem->addSubsumingConceptItem(subsumerItem); } } subsumedItem->setResultSatisfiableDerivated(true); } messageDataLinkerIt = messageDataLinkerIt->getNext(); } return true; } bool COptimizedSubClassSubsumptionClassifierThread::interpreteToldSubsumptionResult(COntologyClassClassificationItem *ontClassItem, const QList > &subSumRelList, bool isSubSum) { CConcept *lastConcept = nullptr; COptimizedSubClassOntologyClassificationItem *optSubClassItem = (COptimizedSubClassOntologyClassificationItem *)ontClassItem; COptimizedSubClassSatisfiableTestingItem* subsumerItem = nullptr; for (QList >::const_iterator it = subSumRelList.constBegin(), itEnd = subSumRelList.constEnd(); it != itEnd; ++it) { CConcept *subsumerConcept = it->first; if (lastConcept != subsumerConcept) { lastConcept = subsumerConcept; subsumerItem = optSubClassItem->getConceptSatisfiableTestItem(subsumerConcept); } CConcept *subsumedConcept = it->second; if (isSubSum) { COptimizedSubClassSatisfiableTestingItem* subsumedItem = optSubClassItem->getConceptSatisfiableTestItem(subsumedConcept); subsumerItem->addSubsumingConceptItem(subsumedItem); } } return true; } bool COptimizedSubClassSubsumptionClassifierThread::interpreteSubsumptionResult(COntologyClassClassificationItem *ontClassItem, CConcept *subsumerConcept, CConcept *subsumedConcept, bool isSubsumption) { return false; } bool COptimizedSubClassSubsumptionClassifierThread::interpreteSatisfiableResult(COntologyClassClassificationItem *ontClassItem, CConcept *satisfiableConcept, bool isSatis) { COptimizedSubClassOntologyClassificationItem *optSubClassItem = (COptimizedSubClassOntologyClassificationItem *)ontClassItem; CClassifierStatistics *ontClassStat = optSubClassItem->getClassifierStatistics(); if (ontClassStat) { ontClassStat->incToldSatisfiableCount(1); } ++satTestedCount; optSubClassItem->decRunningSatisfiableTestsCount(); COptimizedSubClassSatisfiableTestingItem* satTestedItem = optSubClassItem->getConceptSatisfiableTestItem(satisfiableConcept); satTestedItem->setSatisfiableTested(true); satTestedItem->setSatisfiableTestedResult(isSatis); COptimizedSubClassSatisfiableTestingItem* topItem = optSubClassItem->getTopConceptSatisfiableTestItem(); if (isSatis) { // update processing lists #ifdef OPTIMIZEDSUBCLASSCLASSIFIERDEBUGB QString iriClassNameString = CIRIName::getRecentIRIName(satisfiableConcept->getClassNameLinker()); satTestedConList.append(iriClassNameString); #endif #ifdef OPTIMIZEDSUBCLASSCLASSIFIERDEBUGLOGOUTPUT LOG(INFO,getLogDomain(),QString("[%1 / %2] Calculated: '%3' is satisfiable").arg(satTestedCount).arg(totalToTestCount).arg(iriClassNameString),this); #endif #ifdef OPTIMIZEDSUBCLASSCLASSIFIERDEBUGSTATUSDESCRIPTION statUpdateMutex.lock(); statusString = QString("Interpreting, '%1' is satisfiable").arg(iriClassNameString); statUpdateMutex.unlock(); #endif #ifdef OPTIMIZEDSUBCLASSCLASSIFIERDEBUGCOUTOUTPUT cout<addSatisfiableConceptItem(satTestedItem); } else { CTaxonomy *tax = optSubClassItem->getTaxonomy(); if (topItem) { tax->setConceptSatisfiable(satisfiableConcept,false); } else { tax->getBottomHierarchyNode()->addEquivalentConcept(satisfiableConcept); tax->updateNodeEquivalences(tax->getBottomHierarchyNode()); } } QList* nextItemList = optSubClassItem->getNextSatisfiableTestingItemList(); QSet* nextCandItemSet = optSubClassItem->getNextCandidateSatisfiableTestingItemSet(); QSet* remainingCandItemSet = optSubClassItem->getRemainingCandidateSatisfiableTestingItemSet(); QList* succItemList = satTestedItem->getSuccessorItemList(); for (QList::const_iterator it = succItemList->constBegin(), itEnd = succItemList->constEnd(); it != itEnd; ++it) { COptimizedSubClassSatisfiableTestingItem* succItem = *it; if (!isSatis) { succItem->setResultUnsatisfiableDerivated(true); } succItem->decUnprocessedPredecessorItems(); if (succItem->hasOnlyProcessedPredecessorItems()) { nextItemList->append(succItem); } else { nextCandItemSet->insert(succItem); } } return false; } bool COptimizedSubClassSubsumptionClassifierThread::interpreteTestResults(CTestCalculatedCallbackEvent *testResult) { CSatisfiableCalculationJob *satCalcJob = testResult->getSatisfiableCalculationJob(); bool testSat = testResult->getTestResultSatisfiable(); CClassClassificationComputationItem *workItem = (CClassClassificationComputationItem*)testResult->getClassificationWorkItem(); COntologyClassClassificationItem *ontClassItem = workOntItemHash.value(workItem); if (ontClassItem) { QHash *workHash = ontClassItem->getWorkItemHash(); CTaxonomy *taxonomy = ontClassItem->getTaxonomy(); if (workItem) { ontClassItem->decCurrentCalculatingCount(); if (workItem->isTestValid()) { if (testResult->hasCalculationError()) { LOG(ERROR,getLogDomain(),logTr("Error in computation, classification for ontology '%1' failed.").arg(ontClassItem->getOntology()->getTerminologyName()),getLogObject()); ontClassItem->setTaxonomyConstructionFailed(); } else { if (workItem->isConceptSatisfiableTest()) { interpreteSatisfiableResult(ontClassItem,workItem->getSatisfiableTestedConcept(),testSat); } } } QHash::iterator itWorkItem = workHash->find(satCalcJob); while (itWorkItem != workHash->end()) { if (itWorkItem.value() == workItem) { workHash->erase(itWorkItem); break; } ++itWorkItem; } delete workItem; } workOntItemHash.remove(workItem); CClassificationCalculationStatisticsCollection* statisticCollection = testResult->getUsedStatisticsCollection(); if (statisticCollection) { ontClassItem->reuseCalculationStatisticsCollection(statisticCollection); } #ifdef OPTIMIZEDSUBCLASSCLASSIFIERDEBUGTAXONOMYCOUTOUTPUT QString taxString = taxonomy->getConceptHierarchyString(); cout<isTaxonomyConstructed() && !ontClassItem->isTaxonomyConstructionFailed()) { #ifdef OPTIMIZEDSUBCLASSCLASSIFIERDEBUGLOGOUTPUT LOG(INFO,getLogDomain(),QString("Building Class Taxonomy"),this); #endif // build taxonomy COptimizedSubClassOntologyClassificationItem *optSubClassItem = (COptimizedSubClassOntologyClassificationItem *)ontClassItem; QList* satItemList = optSubClassItem->getSatisfiableConceptItemList(); CTaxonomy *tax = optSubClassItem->getTaxonomy(); QList itemList; COptimizedSubClassSatisfiableTestingItem* topItem = optSubClassItem->getTopConceptSatisfiableTestItem(); CHierarchyNode* topHierNode = tax->getTopHierarchyNode(); CHierarchyNode* bottomHierNode = tax->getBottomHierarchyNode(); cint64 topSubsumingItemCount = topItem->getSubsumingConceptItemCount(); topItem->setSatisfiableConceptHierarchyNode(topHierNode); if (topSubsumingItemCount) { QList* subsumingConceptItemList = topItem->sortSubsumingConceptItemList(); for (QList::const_iterator subsumedIt = subsumingConceptItemList->constBegin(), subsumedItEnd = subsumingConceptItemList->constEnd(); subsumedIt != subsumedItEnd; ++subsumedIt) { COptimizedSubClassSatisfiableTestingItem* subsumedConceptItem = *subsumedIt; // mark as equivalent subsumedConceptItem->setEquivalentItem(true); topHierNode->addEquivalentConcept(subsumedConceptItem->getSatisfiableConcept()); tax->updateNodeEquivalences(topHierNode); } } for (QList::const_iterator it = satItemList->constBegin(), itEnd = satItemList->constEnd(); it != itEnd; ++it) { COptimizedSubClassSatisfiableTestingItem* item = *it; if (!item->isEquivalentItem() && item != topItem) { CHierarchyNode* itemNode = tax->getHierarchyNode(item->getSatisfiableConcept(),true); item->setSatisfiableConceptHierarchyNode(itemNode); cint64 itemSubsumingCount = item->getSubsumingConceptItemCount(); itemList.append(item); if (itemSubsumingCount > topSubsumingItemCount) { QList* subsumingConceptItemList = item->sortSubsumingConceptItemList(); for (QList::const_iterator subsumedIt = subsumingConceptItemList->constBegin(), subsumedItEnd = subsumingConceptItemList->constEnd(); subsumedIt != subsumedItEnd; ++subsumedIt) { COptimizedSubClassSatisfiableTestingItem* subsumedConceptItem = *subsumedIt; cint64 subsumedItemSubsumingCount = subsumedConceptItem->getSubsumingConceptItemCount(); if (subsumedItemSubsumingCount == itemSubsumingCount) { // mark as equivalent subsumedConceptItem->setEquivalentItem(true); itemNode->addEquivalentConcept(subsumedConceptItem->getSatisfiableConcept()); tax->updateNodeEquivalences(itemNode); } else { break; } } } } } for (QList::const_iterator it = itemList.constBegin(), itEnd = itemList.constEnd(); it != itEnd; ++it) { COptimizedSubClassSatisfiableTestingItem* item = *it; if (!item->isEquivalentItem() && item != topItem) { cint64 itemSubsumingCount = item->getSubsumingConceptItemCount(); CHierarchyNode* itemHierNode = item->getSatisfiableConceptHierarchyNode(); //QString iriClassNameString = CIRIName::getRecentIRIName(item->getSatisfiableConcept()->getClassNameLinker()); //if (iriClassNameString == "http://www.owllink.org/testsuite/galen#LowerLobeOfLeftLung") { // bool bug = true; //} QList* subsumingConceptItemList = item->getSubsumingConceptItemList(); QList::const_iterator subsumedIt = subsumingConceptItemList->constBegin(), subsumedItEnd = subsumingConceptItemList->constEnd(); cint64 eqCount = 0; cint64 remainingSubsumingCount = itemSubsumingCount; // remove direct equivalences while (subsumedIt != subsumedItEnd) { COptimizedSubClassSatisfiableTestingItem* subsumedConceptItem = *subsumedIt; cint64 subsumedItemSubsumingCount = subsumedConceptItem->getSubsumingConceptItemCount(); if (subsumedItemSubsumingCount != itemSubsumingCount) { 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) { COptimizedSubClassSatisfiableTestingItem* subsumedConceptItem = *subsumedIt; if (!subsumedConceptItem->isEquivalentItem()) { subsumedConceptItem->setPredecessorItem(true); CHierarchyNode* subsumedHierNode = subsumedConceptItem->getSatisfiableConceptHierarchyNode(); itemHierNode->makeParent(subsumedHierNode); parentItemList.append(subsumedConceptItem); remainingSubsumingCount -= subsumedConceptItem->getSubsumingConceptItemCount()+1; ++subsumedIt; break; } else { ++subsumedIt; } } bool searchForMoreParents = remainingSubsumingCount > 0; while (subsumedIt != subsumedItEnd) { COptimizedSubClassSatisfiableTestingItem* subsumedConceptItem = *subsumedIt; if (!subsumedConceptItem->isEquivalentItem()) { bool predOfOnePrevParent = false; if (searchForMoreParents) { for (QList::const_iterator parentIt = parentItemList.constBegin(), parentItEnd = parentItemList.constEnd(); parentIt != parentItEnd && !predOfOnePrevParent; ++parentIt) { COptimizedSubClassSatisfiableTestingItem* parentItem = *parentIt; if (parentItem->getSubsumingConceptItemSet()->contains(subsumedConceptItem)) { predOfOnePrevParent = true; } } } subsumedConceptItem->setPredecessorItem(true); CHierarchyNode* subsumedHierNode = subsumedConceptItem->getSatisfiableConceptHierarchyNode(); 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) { COptimizedSubClassSatisfiableTestingItem* item = *it; if (!item->isPredecessorItem() && !item->isEquivalentItem()) { CHierarchyNode* itemHierNode = item->getSatisfiableConceptHierarchyNode(); bottomHierNode->makeParent(itemHierNode); } } #ifdef OPTIMIZEDSUBCLASSCLASSIFIERDEBUGSTATUSDESCRIPTION statUpdateMutex.lock(); statusString = QString("Finished ontology classification"); statUpdateMutex.unlock(); #endif CTaxonomy *taxonomy = ontClassItem->getTaxonomy(); CConcreteOntology *ontology = ontClassItem->getOntology(); CClassification* classification = ontology->getClassification(); if (classification) { CClassConceptClassification* classConClassification = ontClassItem->getClassConceptClassification(); CClassificationStatisticsCollectionStrings* classifStatCollStrings = ontClassItem->getClassificationStatisticsCollectionStrings(); CClassifierStatistics* classifierStats = ontClassItem->getClassifierStatistics(); classifStatCollStrings->addProcessingStatistics("class-classification-total-satisfiable-test-count",classifierStats->getTotalSatisfiableCount()); classifStatCollStrings->addProcessingStatistics("class-classification-satisfiable-tested-count",classifierStats->getTestedSatisfiableCount()); classifStatCollStrings->addProcessingStatistics("class-classification-satisfiable-pseudo-model-merged-tested-count",classifierStats->getPseudoModelMergedTestedSatisfiableCount()); classifStatCollStrings->addProcessingStatistics("class-classification-satisfiable-derivate-tested-count",classifierStats->getDerivatedTestedSatisfiableCount()); classifStatCollStrings->addProcessingStatistics("class-classification-satisfiable-calculated-tested-count",classifierStats->getCalculatedTestedSatisfiableCount()); classifStatCollStrings->addProcessingStatistics("class-classification-satisfiable-pruned-tested-count",classifierStats->getPrunedTestedSatisfiableCount()); classifStatCollStrings->addProcessingStatistics("class-classification-satisfiable-told-tested-count",classifierStats->getToldSatisfiableCount()-classifierStats->getCalculatedTestedSatisfiableCount()); classifStatCollStrings->addProcessingStatistics("class-classification-total-subsumption-test-count",classifierStats->getTotalSatisfiableCount()*(classifierStats->getTotalSatisfiableCount()-1)); classifStatCollStrings->addProcessingStatistics("class-classification-subsumption-tested-count",classifierStats->getTestedSubsumptionCount()); classifStatCollStrings->addProcessingStatistics("class-classification-subsumption-pseudo-model-merged-tested-count",classifierStats->getPseudoModelMergedTestedSubsumptionCount()); classifStatCollStrings->addProcessingStatistics("class-classification-subsumption-subclass-tested-count",classifierStats->getSubclassTestedSubsumptionCount()); classifStatCollStrings->addProcessingStatistics("class-classification-subsumption-subclass-identifier-occur-tested-count",classifierStats->getSubclassIdentifierOccurTestedSubsumptionCount()); classifStatCollStrings->addProcessingStatistics("class-classification-subsumption-derivate-tested-count",classifierStats->getDerivatedTestedSubsumptionCount()); classifStatCollStrings->addProcessingStatistics("class-classification-subsumption-calculated-tested-count",classifierStats->getCalculatedTestedSubsumptionCount()); classifStatCollStrings->addProcessingStatistics("class-classification-subsumption-pruned-tested-count",classifierStats->getPrunedTestedSubsumptionCount()); classifStatCollStrings->addProcessingStatistics("class-classification-subsumption-told-tested-count",classifierStats->getToldSubsumptionCount()-classifierStats->getCalculatedTestedSubsumptionCount()); classConClassification->setClassConceptTaxonomy(taxonomy); classConClassification->setClassificationStatistics(classifStatCollStrings); if (ontClassItem->getIndividualDependenceTrackingCollector()) { classConClassification->setDependentIndividualsTracking(ontClassItem->getIndividualDependenceTrackingCollector()->getExtendingIndividualDependenceTracking()); } classification->setClassConceptClassification(classConClassification); } ontology->setConceptTaxonomy(taxonomy); ontClassItem->setHasRemainingTests(false); taxonomy->setTaxonomyComplete(true); --mClassificationCount; LOG(INFO,getLogDomain(),logTr("Ontology '%1' classified with %2 satisfiable tests.").arg(ontology->getTerminologyName()).arg(ontClassItem->getCalcedSatisfiableCount()),getLogObject()); } ontClassItem->submitTaxonomyConstructed(); ontClassItem->doClassifiedCallback(); return true; } }; // end namespace Classifier }; // end namespace Reasoner }; // end namespace Konclude