/* * 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 "COptimizedKPSetClassSubsumptionClassifierThread.h" namespace Konclude { namespace Reasoner { namespace Classifier { #ifdef OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCOUTOUTPUT #define OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGB #endif #ifdef OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCOUTOUTPUT #define OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGB #endif #ifdef OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGBOXDESCRIPTION #define OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGB #endif #ifdef OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGSTATUSDESCRIPTION #define OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGB #endif #ifdef OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGB #define OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(a) #else #define OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(a) #endif //#define OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(a) a COptimizedKPSetClassSubsumptionClassifierThread::COptimizedKPSetClassSubsumptionClassifierThread(CReasonerManager *reasonerManager) : CSubsumptionClassifierThread(reasonerManager), CLogIdentifier("::Konclude::Reasoner::Kernel::Classifier::OptimizedKPSetClassSubsumptionClassifierThread",this) { satTestedCount = 0; totalToSatTestClassCount = 0; mClassificationCount = 0; subsumTestedCount = 0; totalToSubsumTestCount = 0; mConfPossSubsumCalcOrderConceptSorted = 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; mSatNodeExpCacheReader = nullptr; mSatNodeExpCache = dynamic_cast(reasonerManager->getSaturationAssociationExpansionCache()); if (mSatNodeExpCache) { mSatNodeExpCacheReader = mSatNodeExpCache->createCacheReader(); } } COptimizedKPSetClassSubsumptionClassifierThread::~COptimizedKPSetClassSubsumptionClassifierThread() { } CTaxonomy *COptimizedKPSetClassSubsumptionClassifierThread::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 COptimizedKPSetClassSubsumptionClassifierThread::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.OptimizedKPSetClassSubsumptionClassifier.MultipliedUnitsParallelSatisfiableCalculationCount",1,&mulConfigErrorFlag); confMaxTestParallelCount = processorCount*multiplicator; bool maxConfigErrorFlag = false; cint64 maxParallel = CConfigDataReader::readConfigInteger(config,"Konclude.Calculation.Classification.OptimizedKPSetClassSubsumptionClassifier.MaximumParallelSatisfiableCalculationCount",1,&maxConfigErrorFlag); if (!maxConfigErrorFlag) { if (!mulConfigErrorFlag) { confMaxTestParallelCount = qMin(confMaxTestParallelCount,maxParallel); } else { confMaxTestParallelCount = maxParallel; } } double factor = CConfigDataReader::readConfigInteger(config,"Konclude.Calculation.Classification.OptimizedKPSetClassSubsumptionClassifier.ParallelSatisfiableCalculationCreationFactor",1000)/1000.; confMinTestParallelCount = confMaxTestParallelCount*factor; mConfWriteDebuggingData = CConfigDataReader::readConfigBoolean(config,"Konclude.Debugging.WriteDebuggingData",false); } else { confMaxTestParallelCount = 1; confMinTestParallelCount = 1; mConfWriteDebuggingData = false; } } COptimizedKPSetClassOntologyClassificationItem* COptimizedKPSetClassSubsumptionClassifierThread::createOntologyClassificationItem(CConcreteOntology *ontology, CConfigurationBase *config) { return new COptimizedKPSetClassOntologyClassificationItem(config,statistics); } CSubsumptionClassifierThread *COptimizedKPSetClassSubsumptionClassifierThread::scheduleOntologyClassification(CConcreteOntology *ontology, CClassificationCalculationSupport *classificationSupport, CConfigurationBase *config) { CTaxonomy *taxonomy = createEmptyTaxonomyForOntology(ontology,config); COptimizedKPSetClassOntologyClassificationItem *ontClassItem = createOntologyClassificationItem(ontology,config); 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 == totalToSatTestClassCount) { satTestedCount = 0; totalToSatTestClassCount = ontClassItem->getRemainingSatisfiableTestsCount(); classStartTime.start(); } else { totalToSatTestClassCount += ontClassItem->getRemainingSatisfiableTestsCount(); } ++mClassificationCount; return this; } void COptimizedKPSetClassSubsumptionClassifierThread::createObviousSubsumptionSatisfiableTestingOrder(COptimizedKPSetClassOntologyClassificationItem* 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 COptimizedKPSetClassSubsumptionClassifierThread::createObviousSubsumptionSatisfiableTestingOrderFromSaturationData(COptimizedKPSetClassOntologyClassificationItem* 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(); COptimizedKPSetClassTestingItem* topItem = ontClassItem->getConceptSatisfiableTestItem(topConcept,true); COptimizedKPSetClassTestingItem* 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(); bool testTopConcept = false; if (topConcept->getOperandList() || eqConNonCandidateSet && !eqConNonCandidateSet->isEmpty() || univConnNomValueConcept) { // has not absorbed GCIs nextItemList->append(topItem); testTopConcept = true; } else { topItem->setPossibleSubsumptionMapInitialized(true); } bool invalidatedConRefLinking = false; QSet* equivConNonCandSet = ontClassItem->getEquivaltentConceptNonCandidateSet(); CBOXHASH* equivConCandidateHash = ontClassItem->getEquivalentConceptCandidateHash(); if (eqConCandidateHash) { for (CBOXHASH::const_iterator it = eqConCandidateHash->constBegin(), itEnd = eqConCandidateHash->constEnd(); it != itEnd; ++it) { CConcept* eqCon = it.key(); CConcept* candCon = it.value(); equivConCandidateHash->insert(eqCon,candCon); } } QHash* conRefLinkDataHash = ontClassItem->getConceptReferenceLinkingDataHash(); QList extClassConceptItemList; 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 && testTopConcept)) { if (concept->getOperatorCode() == CCEQ) { if (!eqConCandidateHash || !eqConCandidateHash->contains(concept)) { equivConNonCandSet->insert(concept); } } COptimizedKPSetClassTestingItem* classItem = 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,classItem); if (conRefSatLinking->getClassifierReferenceLinkingData() || invalidatedConRefLinking) { conProcData->setInvalidatedReferenceLinking(true); } else { conRefSatLinking->setClassifierReferenceLinkingData(classItem); } extClassConceptItemList.append(classItem); } } } for (QList::const_iterator it = extClassConceptItemList.constBegin(), itEnd = extClassConceptItemList.constEnd(); it != itEnd; ++it) { COptimizedKPSetClassTestingItem* classItem = (*it); CConcept* concept = classItem->getTestingConcept(); bool unsatisfiableFlag = false; bool insufficientFlag = false; bool incompleteProcessedFlag = false; //QString iriClassNameString = CIRIName::getRecentIRIName(concept->getClassNameLinker()); //if (iriClassNameString == "http://owl.man.ac.uk/2005/07/sssw/people#sheep") { // bool bug = true; //} if (!classItem->isSatisfiableTested()) { if (precSatSubsumerExtractor->getConceptFlags(concept,&unsatisfiableFlag,&insufficientFlag,&incompleteProcessedFlag)) { if (!unsatisfiableFlag) { bool possibleSubsumerFlag = false; precSatSubsumerExtractor->extractSubsumers(concept,classItem,&possibleSubsumerFlag,ontClassItem->getIndividualDependenceTrackingCollector(),classItem); if (incompleteProcessedFlag) { QSet conSubsumSet = getSubsumerSetFromBuildData(concept,ontClassItem); for (QSet::const_iterator it = conSubsumSet.constBegin(), itEnd = conSubsumSet.constEnd(); it != itEnd; ++it) { CConcept* subsumerConcept = *it; COptimizedKPSetClassTestingItem* subsumerItem = ontClassItem->getConceptSatisfiableTestItem(subsumerConcept,true); classItem->addSubsumingConceptItem(subsumerItem); } } if (equivConNonCandSet && !equivConNonCandSet->isEmpty()) { for (CBOXSET::const_iterator eqConIt = equivConNonCandSet->constBegin(), eqConItEnd = equivConNonCandSet->constEnd(); !possibleSubsumerFlag && eqConIt != eqConItEnd; ++eqConIt) { CConcept* eqCon = *eqConIt; CConceptProcessData* eqConProcData = (CConceptProcessData*)eqCon->getConceptData(); CConceptSaturationReferenceLinkingData* eqConRefSatLinking = (CConceptSaturationReferenceLinkingData*)eqConProcData->getConceptReferenceLinking(); COptimizedKPSetClassTestingItem* eqClassItem = (COptimizedKPSetClassTestingItem*)eqConRefSatLinking->getClassifierReferenceLinkingData(); if (!classItem->hasSubsumerConceptItem(eqClassItem)) { possibleSubsumerFlag = true; } } } cint64 foundSubsumerCount = 0; QList* subsumerItemList = classItem->getSubsumingConceptItemList(); for (QList::const_iterator subsubItemIt = subsumerItemList->constBegin(), itEnd = subsumerItemList->constEnd(); subsubItemIt != itEnd; ++subsubItemIt) { COptimizedKPSetClassTestingItem* subsumerItem(*subsubItemIt); ++foundSubsumerCount; subsumerItem->addSuccessorSatisfiableTestItem(classItem); } classItem->setUnprocessedPredecessorItems(foundSubsumerCount); if (!insufficientFlag && !possibleSubsumerFlag && !incompleteProcessedFlag) { classItem->setResultSatisfiableDerivated(true); classItem->setPossibleSubsumptionMapInitialized(true); } ontClassItem->incRemainingSatisfiableTestsCount(); remainingCandItemSet->insert(classItem); if (foundSubsumerCount <= 0) { nextItemList->append(classItem); } } else { ontClassItem->incRemainingSatisfiableTestsCount(); classItem->setResultUnsatisfiableDerivated(true); nextItemList->append(classItem); } } else { bool foundSubsumingConcepts = false; QSet conSubsumSet = getSubsumerSetFromBuildData(concept,ontClassItem); for (QSet::const_iterator it = conSubsumSet.constBegin(), itEnd = conSubsumSet.constEnd(); it != itEnd; ++it) { CConcept* subsumedConcept = *it; COptimizedKPSetClassTestingItem* subsumerItem = ontClassItem->getConceptSatisfiableTestItem(subsumedConcept,true); subsumerItem->addSuccessorSatisfiableTestItem(classItem); classItem->incUnprocessedPredecessorItems(); foundSubsumingConcepts = true; } ontClassItem->incRemainingSatisfiableTestsCount(); remainingCandItemSet->insert(classItem); if (!foundSubsumingConcepts) { nextItemList->append(classItem); } } } } } QSet COptimizedKPSetClassSubsumptionClassifierThread::getSubsumerSetFromBuildData(CConcept* concept, COptimizedKPSetClassOntologyClassificationItem* ontClassItem) { 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(); } } } return conSubsumSet; } void COptimizedKPSetClassSubsumptionClassifierThread::createObviousSubsumptionSatisfiableTestingOrderFromBuildData(COptimizedKPSetClassOntologyClassificationItem* 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(); COptimizedKPSetClassTestingItem* topItem = ontClassItem->getConceptSatisfiableTestItem(topConcept,true); COptimizedKPSetClassTestingItem* 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(); bool testTopConcept = true; if (topConcept->getOperandList() || eqConNonCandidateSet && !eqConNonCandidateSet->isEmpty() || univConnNomValueConcept) { // has not absorbed GCIs nextItemList->append(topItem); testTopConcept = true; } else { topItem->setPossibleSubsumptionMapInitialized(true); } bool invalidatedConRefLinking = false; QSet* equivConNonCandSet = ontClassItem->getEquivaltentConceptNonCandidateSet(); CBOXHASH* equivConCandidateHash = ontClassItem->getEquivalentConceptCandidateHash(); if (eqConCandidateHash) { for (CBOXHASH::const_iterator it = eqConCandidateHash->constBegin(), itEnd = eqConCandidateHash->constEnd(); it != itEnd; ++it) { CConcept* eqCon = it.key(); CConcept* candCon = it.value(); equivConCandidateHash->insert(eqCon,candCon); } } 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 && testTopConcept)) { if (concept->getOperatorCode() == CCEQ) { if (!eqConCandidateHash || !eqConCandidateHash->contains(concept)) { equivConNonCandSet->insert(concept); } } QSet conSubsumSet = getSubsumerSetFromBuildData(concept,ontClassItem); //QString iriClassNameString = CIRIName::getRecentIRIName(concept->getClassNameLinker()); //if (iriClassNameString == "http://www.owllink.org/testsuite/galen#Haem") { // bool bug = true; //} COptimizedKPSetClassTestingItem* 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; COptimizedKPSetClassTestingItem* subsumedItem = ontClassItem->getConceptSatisfiableTestItem(subsumedConcept,true); subsumedItem->addSuccessorSatisfiableTestItem(subsumerItem); subsumerItem->incUnprocessedPredecessorItems(); foundSubsumingConcepts = true; } ontClassItem->incRemainingSatisfiableTestsCount(); remainingCandItemSet->insert(subsumerItem); if (!foundSubsumingConcepts) { nextItemList->append(subsumerItem); } } } } } QString COptimizedKPSetClassSubsumptionClassifierThread::getStatusString() { statUpdateMutex.lock(); QString string = statusString; string.detach(); statUpdateMutex.unlock(); return string; } CClassificationProgress* COptimizedKPSetClassSubsumptionClassifierThread::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 COptimizedKPSetClassTestingItem* item1, const COptimizedKPSetClassTestingItem* item2) { return item1->getSubsumingConceptItemCount() < item2->getSubsumingConceptItemCount(); } bool itemSortMoreSubsumptionsThan(const COptimizedKPSetClassTestingItem* item1, const COptimizedKPSetClassTestingItem* item2) { return item1->getSubsumingConceptItemCount() > item2->getSubsumingConceptItemCount(); } void COptimizedKPSetClassSubsumptionClassifierThread::testDebugPossibleSubsumerCorrectCounted(COptimizedKPSetClassOntologyClassificationItem *optKPSetClassificationItem) { QList* classList = optKPSetClassificationItem->getConceptSatisfiableTestItemContainer(); cint64 totalCount = 0; foreach (COptimizedKPSetClassTestingItem* item, *classList) { COptimizedKPSetClassPossibleSubsumptionMap* possSubsumMap = item->getPossibleSubsumptionMap(false); if (possSubsumMap) { cint64 mapCount = 0; for (COptimizedKPSetClassPossibleSubsumptionMap::const_iterator it = possSubsumMap->constBegin(), itEnd = possSubsumMap->constEnd(); it != itEnd; ++it) { COptimizedKPSetClassPossibleSubsumptionData* 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 COptimizedKPSetClassSubsumptionClassifierThread::testDebugPossibleSubsumerCorrectReferenced(COptimizedKPSetClassOntologyClassificationItem *optKPSetClassificationItem) { QList* classList = optKPSetClassificationItem->getSatisfiableConceptItemList(); if (mConfPossSubsumCalcOrderBottomUp) { QSet* remItemSet = optKPSetClassificationItem->getRemainingPossibleSubsumptionClassTestingSet(); foreach (COptimizedKPSetClassTestingItem* item, *classList) { COptimizedKPSetClassPossibleSubsumptionMap* possSubsumMap = item->getPossibleSubsumptionMap(false); if (possSubsumMap) { for (COptimizedKPSetClassPossibleSubsumptionMap::const_iterator it = possSubsumMap->constBegin(), itEnd = possSubsumMap->constEnd(); it != itEnd; ++it) { COptimizedKPSetClassPossibleSubsumptionData* data = it.value(); if (data->isSubsumptionUnknown() || data->isUpdateRequired()) { COptimizedKPSetClassTestingItem* possSubsumerItem = data->getClassItem(); if (!possSubsumerItem->getPossibleSubsumedSet(false)->contains(item) && !optKPSetClassificationItem->getCurrentPossibleSubsumptionTestingItemSet()->contains(possSubsumerItem)) { bool bug = true; } if (!remItemSet->contains(possSubsumerItem) && !optKPSetClassificationItem->getCurrentPossibleSubsumptionTestingItemSet()->contains(possSubsumerItem)) { bool bug = true; } } } } } } } QString COptimizedKPSetClassSubsumptionClassifierThread::createDebugKPSetString(COptimizedKPSetClassOntologyClassificationItem *optKPSetClassificationItem, const QString& filename) { QString debugString; QList* classList = optKPSetClassificationItem->getSatisfiableConceptItemList(); foreach (COptimizedKPSetClassTestingItem* item, *classList) { QString iriClassNameString = CIRIName::getRecentIRIName(item->getTestingConcept()->getClassNameLinker()); QString classDebugString = QString("Class: %1\r\n").arg(iriClassNameString); QString subsumString; foreach (COptimizedKPSetClassTestingItem* subsumItem, *item->getSubsumingConceptItemList()) { QString subsumIRIClassNameString = CIRIName::getRecentIRIName(subsumItem->getTestingConcept()->getClassNameLinker()); if (subsumString.isEmpty()) { subsumString += subsumIRIClassNameString; } else { subsumString += QString(", %1").arg(subsumIRIClassNameString); } } classDebugString += QString("Subsumer Classes: %1\r\n").arg(subsumString); QString possSubsumString; COptimizedKPSetClassPossibleSubsumptionMap* possSubsumMap = item->getPossibleSubsumptionMap(false); if (possSubsumMap) { for (COptimizedKPSetClassPossibleSubsumptionMap::const_iterator it = possSubsumMap->constBegin(), itEnd = possSubsumMap->constEnd(); it != itEnd; ++it) { COptimizedKPSetClassPossibleSubsumptionData* data = it.value(); QString subsumIRIClassNameString = CIRIName::getRecentIRIName(data->getClassItem()->getTestingConcept()->getClassNameLinker()); QString possString; if (data->isSubsumptionConfirmed()) { possString = "s"; } else if (data->isSubsumptionInvalided()) { possString = "n"; } else { possString = "u"; } if (possSubsumString.isEmpty()) { possSubsumString += QString("%1(%2)").arg(subsumIRIClassNameString).arg(possString); } else { possSubsumString += QString(", %1(%2)").arg(subsumIRIClassNameString).arg(possString); } } } classDebugString += QString("Possible Subsumer Classes: %1\r\n\r\n\r\n").arg(possSubsumString); debugString += classDebugString; } QFile file(filename); if (file.open(QIODevice::WriteOnly)) { file.write(debugString.toLocal8Bit()); file.close(); } return debugString; } bool COptimizedKPSetClassSubsumptionClassifierThread::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; } COptimizedKPSetClassOntologyClassificationItem *optKPSetClassificationItem = (COptimizedKPSetClassOntologyClassificationItem *)ontClassItem; if (!optKPSetClassificationItem->hasSatisfiableTestingPhaseFinished() && !optKPSetClassificationItem->isTaxonomyConstructionFailed()) { while (!workTestCreated && optKPSetClassificationItem->hasRemainingSatisfiableTests()) { // get next satisfiable test QList* nextItemList = optKPSetClassificationItem->getNextSatisfiableTestingItemList(); QSet* nextCandItemSet = optKPSetClassificationItem->getNextCandidateSatisfiableTestingItemSet(); QSet* remainingCandItemSet = optKPSetClassificationItem->getRemainingCandidateSatisfiableTestingItemSet(); COptimizedKPSetClassTestingItem* nextSatTestItem = nullptr; if (!nextItemList->isEmpty()) { nextSatTestItem = nextItemList->takeFirst(); remainingCandItemSet->remove(nextSatTestItem); nextCandItemSet->remove(nextSatTestItem); } else if (!nextCandItemSet->isEmpty()) { COptimizedKPSetClassTestingItem* minItem = nullptr; cint64 minUnpPredCount = 0; cint64 maxItCount = 100; for (QSet::const_iterator it = nextCandItemSet->constBegin(), itEnd = nextCandItemSet->constEnd(); it != itEnd && maxItCount > 0; ++it, --maxItCount) { COptimizedKPSetClassTestingItem* item = (*it); cint64 predCount = item->getUnprocessedPredecessorItemCount(); if (!minItem || predCount < minUnpPredCount) { minUnpPredCount = predCount; minItem = item; } } nextSatTestItem = minItem; remainingCandItemSet->remove(nextSatTestItem); nextCandItemSet->remove(nextSatTestItem); } else if (!remainingCandItemSet->isEmpty()) { COptimizedKPSetClassTestingItem* minItem = nullptr; //cint64 minUnpPredCount = 0; //for (QSet::const_iterator it = remainingCandItemSet->constBegin(), itEnd = remainingCandItemSet->constEnd(); it != itEnd; ++it) { // COptimizedKPSetClassTestingItem* item = (*it); // cint64 predCount = item->getUnprocessedPredecessorItemCount(); // if (!minItem || minUnpPredCount < predCount) { // minUnpPredCount = predCount; // minItem = item; // } //} //nextSatTestItem = minItem; 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->getTestingConcept(),nextSatTestItem->getSatisfiableTestedResult()); } } } if (!workTestCreated) { if (optKPSetClassificationItem->hasAllSatisfiableTestsCompleted()) { optKPSetClassificationItem->setSatisfiableTestingPhaseFinished(true); OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); // initialize possible subsumption testing phase cint64 remainingSubSumTestCount = 0; QSet* remTestingSet = optKPSetClassificationItem->getRemainingPossibleSubsumptionClassTestingSet(); QList* nextItemList = optKPSetClassificationItem->getNextPossibleSubsumptionTestingItemList(); COptimizedKPSetClassTestingItem* topItem = optKPSetClassificationItem->getTopConceptSatisfiableTestItem(); COptimizedKPSetClassTestingItem* bottomItem = optKPSetClassificationItem->getBottomConceptSatisfiableTestItem(); if (topItem) { topItem->setPropagationConnected(true); } QList classList(*optKPSetClassificationItem->getSatisfiableConceptItemList()); qSort(classList.begin(),classList.end(),itemSortLessSubsumptionsThan); QList resevePossSubsumClassList; foreach (COptimizedKPSetClassTestingItem* item, classList) { COptimizedKPSetClassPossibleSubsumptionMap* 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->getSubsumingConceptItemList(); COptimizedKPSetClassTestingItem* maxSubsumerItem = nullptr; cint64 maxSubsumerCount = 0; for (QList::const_iterator it = subsumerList->constBegin(), itEnd = subsumerList->constEnd(); it != itEnd; ++it) { COptimizedKPSetClassTestingItem* subsumerItem = *it; if (!maxSubsumerItem || subsumerItem->getSubsumingConceptItemCount() > maxSubsumerCount) { maxSubsumerCount = subsumerItem->getSubsumingConceptItemCount(); 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) { COptimizedKPSetClassTestingItem* subsumerItem = *itSub; bool alreadySubsumed = false; for (QSet::const_iterator itProp = upPropSet->constBegin(), itPropEnd = upPropSet->constEnd(); !alreadySubsumed && itProp != itPropEnd; ++itProp) { COptimizedKPSetClassTestingItem* propItem = *itProp; if (propItem == subsumerItem || propItem->hasSubsumerConceptItem(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) { COptimizedKPSetClassTestingItem* 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); } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(createDebugKPSetString(optKPSetClassificationItem,"./Debugging/Classification/classkpsets-inital.txt")); foreach (COptimizedKPSetClassTestingItem* item, classList) { COptimizedKPSetClassPossibleSubsumptionMap* 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) { COptimizedKPSetClassTestingItem* upPropItem = *itProp; COptimizedKPSetClassPossibleSubsumptionMap* upPropItemPossSubsumMap = upPropItem->getPossibleSubsumptionMap(false); if (upPropItemPossSubsumMap) { for (COptimizedKPSetClassPossibleSubsumptionMap::const_iterator itUpPoss = upPropItemPossSubsumMap->constBegin(), itUpPossEnd = upPropItemPossSubsumMap->constEnd(); itUpPoss != itUpPossEnd; ++itUpPoss) { COptimizedKPSetClassPossibleSubsumptionData* upPossData = itUpPoss.value(); if (!item->hasSubsumerConceptItem(upPossData->getClassItem()) && item != upPossData->getClassItem()) { if (!upPossData->isSubsumptionInvalided()) { upPossData->setSubsumptionInvalid(true); if (upPossData->isUpdateRequired()) { prunePossibleSubsumptions(optKPSetClassificationItem,upPropItem,upPossData); } } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); } } } } } else { for (QSet::const_iterator itProp = upPropSet->constBegin(), itPropEnd = upPropSet->constEnd(); itProp != itPropEnd; ++itProp) { COptimizedKPSetClassTestingItem* upPropItem = *itProp; COptimizedKPSetClassPossibleSubsumptionMap* upPropItemPossSubsumMap = upPropItem->getPossibleSubsumptionMap(false); if (upPropItemPossSubsumMap) { COptimizedKPSetClassPossibleSubsumptionMap::const_iterator itUpPoss = upPropItemPossSubsumMap->constBegin(), itUpPossEnd = upPropItemPossSubsumMap->constEnd(); if (possSubsumMap) { COptimizedKPSetClassPossibleSubsumptionMap::const_iterator itPoss = possSubsumMap->constBegin(), itPossEnd = possSubsumMap->constEnd(); while (itPoss != itPossEnd && itUpPoss != itUpPossEnd) { CConcept* possCon = itPoss.key().getConcept(); CConcept* possUpCon = itUpPoss.key().getConcept(); if (possCon->getConceptTag() == possUpCon->getConceptTag()) { ++itPoss; ++itUpPoss; } else if (possCon->getConceptTag() < possUpCon->getConceptTag()) { ++itPoss; } else if (possCon->getConceptTag() > possUpCon->getConceptTag()) { COptimizedKPSetClassPossibleSubsumptionData* upPossData = itUpPoss.value(); if (!item->hasSubsumerConceptItem(upPossData->getClassItem()) && item != upPossData->getClassItem()) { if (!upPossData->isSubsumptionInvalided()) { upPossData->setSubsumptionInvalid(true); if (upPossData->isUpdateRequired()) { prunePossibleSubsumptions(optKPSetClassificationItem,upPropItem,upPossData); } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); } } ++itUpPoss; } } } while (itUpPoss != itUpPossEnd) { COptimizedKPSetClassPossibleSubsumptionData* upPossData = itUpPoss.value(); if (!item->hasSubsumerConceptItem(upPossData->getClassItem()) && item != upPossData->getClassItem()) { if (!upPossData->isSubsumptionInvalided()) { upPossData->setSubsumptionInvalid(true); if (upPossData->isUpdateRequired()) { prunePossibleSubsumptions(optKPSetClassificationItem,upPropItem,upPossData); } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); } } ++itUpPoss; } } } } } foreach (COptimizedKPSetClassTestingItem* item, resevePossSubsumClassList) { COptimizedKPSetClassPossibleSubsumptionMap* possSubsumMap = item->getPossibleSubsumptionMap(false); if (possSubsumMap) { if (possSubsumMap->hasRemainingPossibleSubsumptions()) { for (COptimizedKPSetClassPossibleSubsumptionMap::const_iterator it = possSubsumMap->constBegin(), itEnd = possSubsumMap->constEnd(); it != itEnd; ++it) { COptimizedKPSetClassPossibleSubsumptionData* possSubsumData = it.value(); if (mConfPossSubsumPseudoModelPretest) { if (possSubsumData->isSubsumptionUnknown()) { bool isSubsumptionFlag = false; if (fastPseudoModelSubsumptionClassPrecheckTest(optKPSetClassificationItem,item,possSubsumData->getClassItem(),&isSubsumptionFlag)) { CClassifierStatistics* ontClassStat = optKPSetClassificationItem->getClassifierStatistics(); if (ontClassStat) { ontClassStat->incPseudoModelMergedTestedSubsumptionCount(1); } if (!isSubsumptionFlag) { optKPSetClassificationItem->incRunningPossibleSubsumptionTestsCount(); possSubsumData->setSubsumptionInvalid(true); ++mPseudoModelPretestSubsumptionCalculationCount; interpreteSubsumptionResult(optKPSetClassificationItem,item->getTestingConcept(),possSubsumData->getClassItem()->getTestingConcept(),possSubsumData->isSubsumptionConfirmed()); } } } } if (mConfPossSubsumCalcOrderBottomUp) { if (possSubsumData->isSubsumptionUnknown() || possSubsumData->isUpdateRequired()) { COptimizedKPSetClassTestingItem* possSubsumerItem = possSubsumData->getClassItem(); possSubsumerItem->getPossibleSubsumedSet(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) { COptimizedKPSetClassTestingItem* possSubsumerItem = *it; QList* subsumersSortedList = new QList(possSubsumerItem->getPossibleSubsumedSet(false)->toList()); qSort(subsumersSortedList->begin(),subsumersSortedList->end(),itemSortMoreSubsumptionsThan); possSubsumerItem->setPossibleSubsumedList(subsumersSortedList); } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectReferenced(optKPSetClassificationItem)); } if (mConfWriteDebuggingData) { createDebugKPSetString(optKPSetClassificationItem,"./Debugging/Classification/classkpsets-inital-pruned.txt"); } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(createDebugKPSetString(optKPSetClassificationItem,"./Debugging/Classification/classkpsets-inital-pruned.txt")); OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); } } } if (optKPSetClassificationItem->hasSatisfiableTestingPhaseFinished() && !optKPSetClassificationItem->hasPossibleSubsumptionTestingPhaseFinished() && !optKPSetClassificationItem->isTaxonomyConstructionFailed()) { QList* nextItemList = optKPSetClassificationItem->getNextPossibleSubsumptionTestingItemList(); QSet* currentItemSet = optKPSetClassificationItem->getCurrentPossibleSubsumptionTestingItemSet(); bool canContinueSearchingForTests = true; while (!workTestCreated && optKPSetClassificationItem->hasRemainingPossibleSubsumptionTests() && canContinueSearchingForTests) { // get next possible subsumption test canContinueSearchingForTests = false; COptimizedKPSetClassTestingItem* nextPossSubsumTestItem = nullptr; if (!nextItemList->isEmpty()) { nextPossSubsumTestItem = nextItemList->takeFirst(); } if (nextPossSubsumTestItem) { canContinueSearchingForTests = true; if (mConfPossSubsumCalcOrderTopDown) { COptimizedKPSetClassPossibleSubsumptionMap* possSubsumerMap = nextPossSubsumTestItem->getPossibleSubsumptionMap(false); if (possSubsumerMap && possSubsumerMap->hasRemainingPossibleSubsumptions()) { COptimizedKPSetClassPossibleSubsumptionData* possSubsumCalcData = getNextPossibleSubsumptionCalculation(optKPSetClassificationItem,nextPossSubsumTestItem); if (possSubsumCalcData) { currentItemSet->insert(nextPossSubsumTestItem); optKPSetClassificationItem->incRunningPossibleSubsumptionTestsCount(); if (calculateSubsumption(optKPSetClassificationItem,nextPossSubsumTestItem,possSubsumCalcData->getClassItem(),possSubsumCalcData)) { workTestCreated = true; } else { interpreteSubsumptionResult(optKPSetClassificationItem,nextPossSubsumTestItem->getTestingConcept(),possSubsumCalcData->getClassItem()->getTestingConcept(),possSubsumCalcData->isSubsumptionConfirmed()); } } } else { QSet* remTestingSet = optKPSetClassificationItem->getRemainingPossibleSubsumptionClassTestingSet(); remTestingSet->remove(nextPossSubsumTestItem); } } else if (mConfPossSubsumCalcOrderBottomUp) { COptimizedKPSetClassPossibleSubsumptionData* possSubsumCalcData = nullptr; COptimizedKPSetClassTestingItem* possSubsumedItem = nullptr; OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectReferenced(optKPSetClassificationItem)); CConcept* possSubsumerConcept = nextPossSubsumTestItem->getTestingConcept(); CConcept* candidateConcept = possSubsumerConcept; if (possSubsumerConcept->getOperatorCode() == CCEQ) { candidateConcept = optKPSetClassificationItem->getEquivalentConceptCandidateHash()->value(possSubsumerConcept); if (!candidateConcept) { candidateConcept = possSubsumerConcept; } } QList* possSubsumedSortedList = nextPossSubsumTestItem->getPossibleSubsumedList(); if (possSubsumedSortedList && !possSubsumedSortedList->isEmpty()) { while (!possSubsumCalcData && !possSubsumedSortedList->isEmpty()) { possSubsumedItem = possSubsumedSortedList->takeFirst(); if (nextPossSubsumTestItem->getPossibleSubsumedSet(false)->contains(possSubsumedItem)) { nextPossSubsumTestItem->getPossibleSubsumedSet(false)->remove(possSubsumedItem); COptimizedKPSetClassPossibleSubsumptionMap* possSubsumerMap = possSubsumedItem->getPossibleSubsumptionMap(false); if (possSubsumerMap && possSubsumerMap->hasRemainingPossibleSubsumptions()) { possSubsumCalcData = possSubsumerMap->value(CConceptTagComparer(candidateConcept)); } } } } if (possSubsumCalcData) { //if ((possSubsumCalcData->isUpdateRequired() || possSubsumCalcData->isSubsumptionUnknown())) { currentItemSet->insert(nextPossSubsumTestItem); optKPSetClassificationItem->incRunningPossibleSubsumptionTestsCount(); //QString iriClassNameString1 = CIRIName::getRecentIRIName(possSubsumedItem->getTestingConcept()->getClassNameLinker()); //QString iriClassNameString2 = CIRIName::getRecentIRIName(nextPossSubsumTestItem->getTestingConcept()->getClassNameLinker()); //if (iriClassNameString2 == "http://www.owllink.org/testsuite/npt8-D#TransitionMetalAtom" && iriClassNameString1 == "http://www.owllink.org/testsuite/npt8-D#TitaniumFamilyAtom") { // bool bug = true; //} //if (subsumCalcedSet.contains(QPair(possSubsumedItem->getTestingConcept(),nextPossSubsumTestItem->getTestingConcept()))) { // bool bug = true; //} //subsumCalcedSet.insert(QPair(possSubsumedItem->getTestingConcept(),nextPossSubsumTestItem->getTestingConcept())); if (calculateSubsumption(optKPSetClassificationItem,possSubsumedItem,nextPossSubsumTestItem,possSubsumCalcData)) { workTestCreated = true; } else { interpreteSubsumptionResult(optKPSetClassificationItem,possSubsumedItem->getTestingConcept(),nextPossSubsumTestItem->getTestingConcept(),possSubsumCalcData->isSubsumptionConfirmed()); } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectReferenced(optKPSetClassificationItem)); //} } else { QSet* remTestingSet = optKPSetClassificationItem->getRemainingPossibleSubsumptionClassTestingSet(); remTestingSet->remove(nextPossSubsumTestItem); OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectReferenced(optKPSetClassificationItem)); } } } } if (!workTestCreated && currentItemSet->isEmpty()) { optKPSetClassificationItem->setPossibleSubsumptionTestingPhaseFinished(true); } } if (!workTestCreated) { if (optKPSetClassificationItem->hasPossibleSubsumptionTestingPhaseFinished() || optKPSetClassificationItem->isTaxonomyConstructionFailed()) { finishOntologyClassification(optKPSetClassificationItem); processingOntItemList.removeFirst(); } else { processingOntItemList.removeFirst(); processingOntItemList.append(ontClassItem); loopOntClassItem = ontClassItem; } } } return workTestCreated; } COptimizedKPSetClassPossibleSubsumptionData* COptimizedKPSetClassSubsumptionClassifierThread::getNextPossibleSubsumptionCalculation(COptimizedKPSetClassOntologyClassificationItem *ontClassItem, COptimizedKPSetClassTestingItem* classItem) { COptimizedKPSetClassPossibleSubsumptionData* possSubsumer = nullptr; // I don't know which is the best, simply return the first one // sort by subsumer count? COptimizedKPSetClassPossibleSubsumptionMap* possSubsumerMap = classItem->getPossibleSubsumptionMap(false); if (possSubsumerMap) { if (mConfPossSubsumCalcOrderConceptSorted) { for (COptimizedKPSetClassPossibleSubsumptionMap::const_iterator it = possSubsumerMap->constBegin(), itEnd = possSubsumerMap->constEnd(); !possSubsumer && it != itEnd; ++it) { COptimizedKPSetClassPossibleSubsumptionData* possSubsumData = it.value(); if (possSubsumData->isSubsumptionUnknown()) { possSubsumer = possSubsumData; } else if (possSubsumData->isUpdateRequired()) { prunePossibleSubsumptions(ontClassItem,classItem,possSubsumData); } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(ontClassItem)); } } } return possSubsumer; } bool COptimizedKPSetClassSubsumptionClassifierThread::calculateSatisfiable(COptimizedKPSetClassOntologyClassificationItem *optKPSetClassificationItem, COptimizedKPSetClassTestingItem* nextSatTestItem) { CSatisfiableCalculationJob* satCalcJob = nullptr; CClassClassificationComputationItem *workItem = 0; CConcept* concept = nextSatTestItem->getTestingConcept(); nextSatTestItem->setSatisfiableTestOrdered(true); bool satisfiableFlag = false; #ifdef OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGB QString iriClassNameString = CIRIName::getRecentIRIName(concept->getClassNameLinker()); #endif #ifdef OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGSTATUSDESCRIPTION statUpdateMutex.lock(); statusString = QString("[%2/%3] Calculating, is '%1' satisfiable").arg(iriClassNameString).arg(optKPSetClassificationItem->getClassifierStatistics()->getTestedSatisfiableCount()).arg(optKPSetClassificationItem->getClassifierStatistics()->getTotalSatisfiableCount()); statUpdateMutex.unlock(); #endif #ifdef OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGLOGOUTPUT LOG(INFO,getLogDomain(),QString("Calculating whether '%1' is satisfiable").arg(iriClassNameString),this); #endif #ifdef OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCOUTOUTPUT 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 = optKPSetClassificationItem->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(optKPSetClassificationItem,nextSatTestItem,&satisfiableFlag)) { nextSatTestItem->setSatisfiableTested(true); nextSatTestItem->setSatisfiableTestedResult(satisfiableFlag); return false; } CSatisfiableCalculationJobGenerator satCalcJobGen(optKPSetClassificationItem->getOntology()); satCalcJob = satCalcJobGen.getSatisfiableCalculationJob(concept); QHash *workHash = optKPSetClassificationItem->getWorkItemHash(); CClassifierStatistics *ontClassStat = optKPSetClassificationItem->getClassifierStatistics(); if (ontClassStat) { ontClassStat->incCalculatedTestedSatisfiableCount(1); } workItem = new CClassClassificationComputationItem(satCalcJob,concept); workHash->insertMulti(satCalcJob,workItem); workOntItemHash.insert(workItem,optKPSetClassificationItem); QHash* conRefLinkDataHash = optKPSetClassificationItem->getConceptReferenceLinkingDataHash(); cint64 extFlags = CSatisfiableTaskClassificationMessageAdapter::EFEXTRACTALL; // TODO: set extraction flags satCalcJob->setSatisfiableClassificationMessageAdapter(new CSatisfiableTaskClassificationMessageAdapter(concept,optKPSetClassificationItem->getOntology(),this,conRefLinkDataHash,extFlags)); optKPSetClassificationItem->incCurrentCalculatingCount(); if (optKPSetClassificationItem->getIndividualDependenceTrackingCollector()) { satCalcJob->setSatisfiableTaskIndividualDependenceTrackingAdapter(new CSatisfiableTaskIndividualDependenceTrackingAdapter(optKPSetClassificationItem->getIndividualDependenceTrackingCollector(),nextSatTestItem)); } processCalculationJob(satCalcJob,optKPSetClassificationItem,workItem); ++mCreatedCalculationTaskCount; return true; } bool COptimizedKPSetClassSubsumptionClassifierThread::calculateSubsumption(COptimizedKPSetClassOntologyClassificationItem *optKPSetClassificationItem, COptimizedKPSetClassTestingItem* subsumedItem, COptimizedKPSetClassTestingItem* possSubsumerItem, COptimizedKPSetClassPossibleSubsumptionData* possSubsumData) { CSatisfiableCalculationJob* satCalcJob = nullptr; CClassClassificationComputationItem *workItem = 0; ++mOrderedSubsumptionCalculationCount; CConcept* subsumedConcept = subsumedItem->getTestingConcept(); CConcept* subsumerConcept = possSubsumerItem->getTestingConcept(); bool isSubsumptionFlag = false; bool precheckedSubsum = false; #ifdef OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGB QString iriClassNameString1 = CIRIName::getRecentIRIName(subsumedConcept->getClassNameLinker()); QString iriClassNameString2 = CIRIName::getRecentIRIName(subsumerConcept->getClassNameLinker()); #endif #ifdef OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGSTATUSDESCRIPTION statUpdateMutex.lock(); statusString = QString("Calculating, is '%1' subsumed by '%2'").arg(iriClassNameString1).arg(iriClassNameString2); statUpdateMutex.unlock(); #endif #ifdef OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGLOGOUTPUT LOG(INFO,getLogDomain(),QString("Calculating whether '%1' is subsumed by '%2'").arg(iriClassNameString1).arg(iriClassNameString2),this); #endif #ifdef OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCOUTOUTPUT cout<getClassifierStatistics(); if (possSubsumData && possSubsumData->isSubsumptionKnown()) { return false; } else if (possSubsumData && subsumedItem->hasSubsumerConceptItem(possSubsumerItem)) { possSubsumData->setSubsumptionConfirmed(true); return false; } else if (mConfPossSubsumPseudoModelTest && fastPseudoModelSubsumptionClassPrecheckTest(optKPSetClassificationItem,subsumedItem,possSubsumerItem,&isSubsumptionFlag)) { if (ontClassStat) { ontClassStat->incPseudoModelMergedTestedSubsumptionCount(1); } return false; } CSatisfiableCalculationJobGenerator satCalcJobGen(optKPSetClassificationItem->getOntology()); satCalcJob = satCalcJobGen.getSatisfiableCalculationJob(subsumedConcept,false,subsumerConcept,true); QHash *workHash = optKPSetClassificationItem->getWorkItemHash(); if (ontClassStat) { ontClassStat->incCalculatedTestedSubsumptionCount(1); ontClassStat->incToldSubsumptionCount(1); } workItem = new CClassClassificationComputationItem(satCalcJob,subsumerConcept,subsumedConcept); workHash->insertMulti(satCalcJob,workItem); workOntItemHash.insert(workItem,optKPSetClassificationItem); QHash* conRefLinkDataHash = optKPSetClassificationItem->getConceptReferenceLinkingDataHash(); cint64 extFlags = CSatisfiableTaskClassificationMessageAdapter::EFEXTRACTSUBSUMERSOTHERNODES | CSatisfiableTaskClassificationMessageAdapter::EFEXTRACTPOSSIBLESUBSUMERSROOTNODE | CSatisfiableTaskClassificationMessageAdapter::EFEXTRACTPOSSIBLESUBSUMERSOTHERNODES | CSatisfiableTaskClassificationMessageAdapter::EFEXTRACTOTHERNODESMULTIPLEDEPENDENCY; // TODO: set extraction flags satCalcJob->setSatisfiableClassificationMessageAdapter(new CSatisfiableTaskClassificationMessageAdapter(subsumedConcept,optKPSetClassificationItem->getOntology(),this,conRefLinkDataHash,extFlags)); if (optKPSetClassificationItem->getIndividualDependenceTrackingCollector()) { satCalcJob->setSatisfiableTaskIndividualDependenceTrackingAdapter(new CSatisfiableTaskIndividualDependenceTrackingAdapter(optKPSetClassificationItem->getIndividualDependenceTrackingCollector(),subsumedItem)); } optKPSetClassificationItem->incCurrentCalculatingCount(); processCalculationJob(satCalcJob,optKPSetClassificationItem,workItem); optKPSetClassificationItem->incCalculatedPossibleSubsumerCount(); ++mCreatedCalculationTaskCount; return true; } CIndividualSaturationProcessNode* COptimizedKPSetClassSubsumptionClassifierThread::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 COptimizedKPSetClassSubsumptionClassifierThread::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* COptimizedKPSetClassSubsumptionClassifierThread::getAssociatedSaturationCacheEntry(COptimizedKPSetClassTestingItem* classConItem) { CCacheEntry* cacheEntry = classConItem->getFastSatisfiabilityTestedSaturationCacheEntry(); if (!cacheEntry) { CConcept* concept = classConItem->getTestingConcept(); CIndividualSaturationProcessNode* satNode = getSaturationIndividualNodeForConcept(concept,false); cacheEntry = mSatNodeExpCacheReader->getCacheEntry(satNode); classConItem->setFastSatisfiabilityTestedSaturationCacheEntry(cacheEntry); } return cacheEntry; } bool COptimizedKPSetClassSubsumptionClassifierThread::fastSatisfiableOnlySubClassPrecheckTest(COptimizedKPSetClassOntologyClassificationItem *optKPSetClassificationItem, COptimizedKPSetClassTestingItem* nextSatTestItem, bool* isSatisfiableFlag) { QHash* conceptSatItemHash = optKPSetClassificationItem->getConceptSatisfiableTestItemHash(); CBOXHASH* triggerImpHash = optKPSetClassificationItem->getOntology()->getTBox()->getTriggerImplicationHash(false); CConcept* concept = nextSatTestItem->getTestingConcept(); 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* superClassConcept = nullptr; if (!opLinkerIt->isNegated() && (firstOpCode == CCATOM || firstOpCode == CCSUB || firstOpCode == CCEQ)) { superClassConcept = firstConcept; } if ((!triggerImpHash || !triggerImpHash->contains(concept)) && superClassConcept) { COptimizedKPSetClassTestingItem* superClassConItem = conceptSatItemHash->value(superClassConcept); if (superClassConItem && superClassConItem->isSatisfiableTested()) { if (!triggerImpHash || !triggerImpHash->contains(superClassConcept)) { CCacheEntry* superCacheEntry = getAssociatedSaturationCacheEntry(superClassConItem); if (!hasCachedSaturationIndividualNodeAssociatedExpansionProplematicConcept(superCacheEntry,concept)) { nextSatTestItem->setFastSatisfiabilityTestedSaturationCacheEntry(superCacheEntry); nextSatTestItem->setSuccessfullyFastSatisfiabilityTested(true); QList* subsumedSubsumingConList = superClassConItem->getSubsumingConceptItemList(); for (QList::const_iterator it = subsumedSubsumingConList->constBegin(), itEnd = subsumedSubsumingConList->constEnd(); it != itEnd; ++it) { COptimizedKPSetClassTestingItem* subsumedItem = (*it); if (nextSatTestItem != subsumedItem && superClassConItem != subsumedItem) { nextSatTestItem->addSubsumingConceptItem(subsumedItem); } } nextSatTestItem->addSubsumingConceptItem(superClassConItem); satFlag = superClassConItem->getSatisfiableTestedResult(); testComplete = true; if (superClassConItem->isClassPseudoModelInitalized()) { CClassificationClassPseudoModel* superClassPMModel = superClassConItem->getClassPseudoModel(); CClassificationClassPseudoModel* classPMModel = nextSatTestItem->getClassPseudoModel(); CTempMemoryPoolContainerAllocationManager tempMemoryPoolConAllocMan(mContext.getMemoryPoolAllocationManager()); CContext* tmpContext = CObjectParameterizingAllocator< CContextBase,CMemoryAllocationManager* >::allocateAndConstructAndParameterize(&tempMemoryPoolConAllocMan,&tempMemoryPoolConAllocMan); CClassificationClassPseudoModelHash* pmModelHash = CObjectParameterizingAllocator< CClassificationClassPseudoModelHash,CContext* >::allocateAndConstructAndParameterize(&tempMemoryPoolConAllocMan,tmpContext); pmModelHash->initPseudoModelHash(superClassPMModel->getPseudoModelHash()); CClassificationClassPseudoModelData* pmModelData = pmModelHash->getPseudoModelData(0,true); CClassificationClassPseudoModelConceptMap* pmModelConMap = pmModelData->getPseudoModelConceptMap(true); CClassificationClassPseudoModelConceptData& pmModelConData = (*pmModelConMap)[CConceptTagComparer(concept)]; pmModelConData.setDeterministic(true); optKPSetClassificationItem->addMemoryPools(tempMemoryPoolConAllocMan.takeMemoryPools()); classPMModel->setPseudoModelHash(pmModelHash); nextSatTestItem->setClassPseudoModelInitalized(true); } if (superClassConItem->isPossibleSubsumptionMapInitialized()) { COptimizedKPSetClassPossibleSubsumptionMap* superPosSubsumMap = superClassConItem->getPossibleSubsumptionMap(false); if (superPosSubsumMap && !nextSatTestItem->isPossibleSubsumptionMapInitialized()) { COptimizedKPSetClassPossibleSubsumptionMap* subPosSubsumMap = nextSatTestItem->getPossibleSubsumptionMap(true); for (COptimizedKPSetClassPossibleSubsumptionMap::const_iterator it = superPosSubsumMap->constBegin(), itEnd = superPosSubsumMap->constEnd(); it != itEnd; ++it) { CConcept* con = it.key().getConcept(); COptimizedKPSetClassPossibleSubsumptionData* data = it.value(); if (data->isSubsumptionUnknown() && !nextSatTestItem->hasSubsumerConceptItem(data->getClassItem()) && nextSatTestItem != data->getClassItem()) { COptimizedKPSetClassPossibleSubsumptionData* possSubsumData = new COptimizedKPSetClassPossibleSubsumptionData(data->getClassItem()); subPosSubsumMap->insert(CConceptTagComparer(con),possSubsumData); incRemainingPossibleSubsumptionTestingCount(optKPSetClassificationItem,subPosSubsumMap); } } } nextSatTestItem->setPossibleSubsumptionMapInitialized(true); } } } } } } } else if (concept->getOperatorCode() == CCATOM) { COptimizedKPSetClassTestingItem* topClassConItem = optKPSetClassificationItem->getTopConceptSatisfiableTestItem(); if (topClassConItem->isPossibleSubsumptionMapInitialized()) { CCacheEntry* topCacheEntry = getAssociatedSaturationCacheEntry(topClassConItem); if (!hasCachedSaturationIndividualNodeAssociatedExpansionProplematicConcept(topCacheEntry,concept)) { nextSatTestItem->setFastSatisfiabilityTestedSaturationCacheEntry(topCacheEntry); nextSatTestItem->setSuccessfullyFastSatisfiabilityTested(true); satFlag = true; testComplete = true; CClassificationClassPseudoModel* classPMModel = nextSatTestItem->getClassPseudoModel(); CTempMemoryPoolContainerAllocationManager tempMemoryPoolConAllocMan(mContext.getMemoryPoolAllocationManager()); CContext* tmpContext = CObjectParameterizingAllocator< CContextBase,CMemoryAllocationManager* >::allocateAndConstructAndParameterize(&tempMemoryPoolConAllocMan,&tempMemoryPoolConAllocMan); CClassificationClassPseudoModelHash* pmModelHash = CObjectParameterizingAllocator< CClassificationClassPseudoModelHash,CContext* >::allocateAndConstructAndParameterize(&tempMemoryPoolConAllocMan,tmpContext); CClassificationClassPseudoModelData* pmModelData = pmModelHash->getPseudoModelData(0,true); CClassificationClassPseudoModelConceptMap* pmModelConMap = pmModelData->getPseudoModelConceptMap(true); CClassificationClassPseudoModelConceptData& pmModelConData = (*pmModelConMap)[CConceptTagComparer(concept)]; pmModelConData.setDeterministic(true); optKPSetClassificationItem->addMemoryPools(tempMemoryPoolConAllocMan.takeMemoryPools()); classPMModel->setPseudoModelHash(pmModelHash); nextSatTestItem->setClassPseudoModelInitalized(true); COptimizedKPSetClassPossibleSubsumptionMap* superPosSubsumMap = topClassConItem->getPossibleSubsumptionMap(false); if (superPosSubsumMap && !nextSatTestItem->isPossibleSubsumptionMapInitialized()) { COptimizedKPSetClassPossibleSubsumptionMap* subPosSubsumMap = nextSatTestItem->getPossibleSubsumptionMap(true); for (COptimizedKPSetClassPossibleSubsumptionMap::const_iterator it = superPosSubsumMap->constBegin(), itEnd = superPosSubsumMap->constEnd(); it != itEnd; ++it) { CConcept* con = it.key().getConcept(); COptimizedKPSetClassPossibleSubsumptionData* data = it.value(); if (data->isSubsumptionUnknown() && !nextSatTestItem->hasSubsumerConceptItem(data->getClassItem()) && nextSatTestItem != data->getClassItem()) { COptimizedKPSetClassPossibleSubsumptionData* possSubsumData = new COptimizedKPSetClassPossibleSubsumptionData(data->getClassItem()); subPosSubsumMap->insert(CConceptTagComparer(con),possSubsumData); incRemainingPossibleSubsumptionTestingCount(optKPSetClassificationItem,subPosSubsumMap); } } } nextSatTestItem->setPossibleSubsumptionMapInitialized(true); OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); } } } if (satFlag && isSatisfiableFlag) { *isSatisfiableFlag = true; } return testComplete; } void COptimizedKPSetClassSubsumptionClassifierThread::incRemainingPossibleSubsumptionTestingCount(COptimizedKPSetClassOntologyClassificationItem *optKPSetClassificationItem, COptimizedKPSetClassPossibleSubsumptionMap* posSubsumMap) { optKPSetClassificationItem->incPossibleSubsumerCount(); optKPSetClassificationItem->incRemainingPossibleSubsumptionTestsCount(); posSubsumMap->incRemainingPossibleSubsumptionCount(); ++totalToSubsumTestCount; } void COptimizedKPSetClassSubsumptionClassifierThread::decRemainingPossibleSubsumptionTestingCount(COptimizedKPSetClassOntologyClassificationItem *optKPSetClassificationItem, COptimizedKPSetClassPossibleSubsumptionMap* posSubsumMap, bool subsumptionConfirmed) { if (subsumptionConfirmed) { optKPSetClassificationItem->incTruePossibleSubsumerCount(); } else { optKPSetClassificationItem->incFalsePossibleSubsumerCount(); } optKPSetClassificationItem->decRemainingPossibleSubsumptionTestsCount(); posSubsumMap->decRemainingPossibleSubsumptionCount(); ++subsumTestedCount; } bool COptimizedKPSetClassSubsumptionClassifierThread::fastPseudoModelSubsumptionClassPrecheckTest(COptimizedKPSetClassOntologyClassificationItem *optSubClassItem, COptimizedKPSetClassTestingItem* subsumedItem, COptimizedKPSetClassTestingItem* subsumerItem, bool* isSubsumptionFlag) { if (subsumedItem->isClassPseudoModelInitalized() && subsumerItem->isClassPseudoModelInitalized()) { CClassificationClassPseudoModel* subsumedPM = subsumedItem->getClassPseudoModel(); CClassificationClassPseudoModel* subsumerPM = subsumerItem->getClassPseudoModel(); CClassificationClassPseudoModelHash* subsumedPMHash = subsumedPM->getPseudoModelHash(); CClassificationClassPseudoModelHash* subsumerPMHash = subsumerPM->getPseudoModelHash(); CClassificationClassPseudoModelData* subsumedPMData = subsumedPMHash->getPseudoModelData(0,false); CClassificationClassPseudoModelData* subsumerPMData = subsumerPMHash->getPseudoModelData(0,false); if (subsumedPMData && subsumerPMData) { bool isSubSumPossible = isPseudoModelSubsumerPossible(optSubClassItem,subsumedPMData,subsumedPMHash,subsumerPMData,subsumerPMHash); if (!isSubSumPossible) { if (isSubsumptionFlag) { *isSubsumptionFlag = false; } return true; } } return false; } return false; } bool COptimizedKPSetClassSubsumptionClassifierThread::isPseudoModelSubsumerPossible(COptimizedKPSetClassOntologyClassificationItem *optSubClassItem, CClassificationClassPseudoModelData* subsumedPMData, CClassificationClassPseudoModelHash* subsumedPMHash, CClassificationClassPseudoModelData* subsumerPMData, CClassificationClassPseudoModelHash* subsumerPMHash) { if (subsumedPMData->hasValidConceptMap() && subsumerPMData->hasValidConceptMap()) { CClassificationClassPseudoModelConceptMap* subsumedConMap = subsumedPMData->getPseudoModelConceptMap(false); CClassificationClassPseudoModelConceptMap* subsumerConMap = subsumerPMData->getPseudoModelConceptMap(false); if (subsumedConMap && subsumerConMap) { CClassificationClassPseudoModelConceptMap::const_iterator it1 = subsumerConMap->constBegin(), it1End = subsumerConMap->constEnd(); CClassificationClassPseudoModelConceptMap::const_iterator it2 = subsumedConMap->constBegin(), it2End = subsumedConMap->constEnd(); while (it1 != it1End && it2 != it2End) { CConcept* concept1 = it1.key().getConcept(); CConcept* concept2 = it2.key().getConcept(); cint64 con1Tag = concept1->getConceptTag(); cint64 con2Tag = concept2->getConceptTag(); if (con2Tag < con1Tag) { ++it2; } else if (con2Tag == con1Tag) { ++it1; ++it2; } else if (con2Tag > con1Tag) { if (it1.value().isDeterministic()) { // in the possible subsumed model is missing a concept, subsumption is not possible return false; } ++it1; } } while (it1 != it1End) { if (it1.value().isDeterministic()) { return false; } ++it1; } } } if (subsumedPMData->hasValidRoleMap() && subsumerPMData->hasValidRoleMap()) { CClassificationClassPseudoModelRoleMap* subsumedRoleMap = subsumedPMData->getPseudoModelRoleMap(false); CClassificationClassPseudoModelRoleMap* subsumerRoleMap = subsumerPMData->getPseudoModelRoleMap(false); if (subsumedRoleMap && subsumerRoleMap) { CClassificationClassPseudoModelRoleMap::const_iterator it1 = subsumerRoleMap->constBegin(), it1End = subsumerRoleMap->constEnd(); CClassificationClassPseudoModelRoleMap::const_iterator it2 = subsumedRoleMap->constBegin(), it2End = subsumedRoleMap->constEnd(); while (it1 != it1End && it2 != it2End) { CRole* role1 = it1.key().getRole(); CRole* role2 = it2.key().getRole(); cint64 role1Tag = role1->getRoleTag(); cint64 role2Tag = role2->getRoleTag(); if (role2Tag < role1Tag) { ++it2; } else if (role2Tag == role1Tag) { const CClassificationClassPseudoModelRoleData& role1Data = it1.value(); const CClassificationClassPseudoModelRoleData& role2Data = it2.value(); if (!role1Data.isPossibleSubsumerOf(role2Data)) { // some cardinalities are not satisfy the subsumption condition return false; } cint64 succ1ID = role1Data.getSuccessorModelID(); cint64 succ2ID = role2Data.getSuccessorModelID(); CClassificationClassPseudoModelData* succ1ModelData = subsumerPMHash->getPseudoModelData(succ1ID,false); CClassificationClassPseudoModelData* succ2ModelData = subsumedPMHash->getPseudoModelData(succ2ID,false); if (succ1ModelData && succ2ModelData) { if (!isPseudoModelSubsumerPossible(optSubClassItem,succ2ModelData,subsumedPMHash,succ1ModelData,subsumerPMHash)) { return false; } } ++it1; ++it2; } else if (role2Tag > role1Tag) { if (it1.value().isDeterministic()) { // in the possible subsumed model is missing a concept, subsumption is not possible return false; } ++it1; } } while (it1 != it1End) { if (it1.value().isDeterministic()) { return false; } ++it1; } } } return true; } CSubsumptionClassifierThread *COptimizedKPSetClassSubsumptionClassifierThread::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,false); return this; } bool COptimizedKPSetClassSubsumptionClassifierThread::processToldClassificationMessage(COntologyClassificationItem *ontClassItem, CClassificationMessageData* messageDataLinker, CMemoryPool* memoryPools) { COptimizedKPSetClassOntologyClassificationItem *optKPSetClassificationItem = (COptimizedKPSetClassOntologyClassificationItem *)ontClassItem; OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); CClassificationMessageData* messageDataLinkerIt = messageDataLinker; while (messageDataLinkerIt) { CClassificationMessageData* messageData = messageDataLinkerIt; if (messageData->getClassificationMessageDataType() == CClassificationMessageData::TELLCLASSSUBSUMPTION) { ++mStatProcesedSubsumMessCount; CClassificationClassSubsumptionMessageData* subsumMessageData = (CClassificationClassSubsumptionMessageData*)messageData; CConcept* subsumedConcept = subsumMessageData->getSubsumedConcept(); CCLASSSUBSUMPTIONMESSAGELIST* subsumerList = subsumMessageData->getClassSubsumerList(); COptimizedKPSetClassTestingItem* subsumedItem = nullptr; subsumedItem = optKPSetClassificationItem->getConceptSatisfiableTestItem(subsumedConcept); //QString iriClassNameString = CIRIName::getRecentIRIName(subsumedItem->getTestingConcept()->getClassNameLinker()); //if (iriClassNameString == "http://www.owllink.org/testsuite/galen#LowerLobeOfLeftLung") { // bool bug = true; //} COptimizedKPSetClassPossibleSubsumptionMap* possSubsumMap = subsumedItem->getPossibleSubsumptionMap(false); OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); if (subsumerList) { for (CCLASSSUBSUMPTIONMESSAGELIST::const_iterator it = subsumerList->constBegin(), itEnd = subsumerList->constEnd(); it != itEnd; ++it) { CConcept* subsumerConcept(*it); COptimizedKPSetClassTestingItem* subsumerItem = optKPSetClassificationItem->getConceptSatisfiableTestItem(subsumerConcept); if (subsumedItem != subsumerItem) { subsumedItem->addSubsumingConceptItem(subsumerItem); if (possSubsumMap) { COptimizedKPSetClassPossibleSubsumptionData* possSubsumData = possSubsumMap->value(subsumerConcept,nullptr); if (possSubsumData) { if (!possSubsumData->isSubsumptionConfirmed()) { possSubsumData->setSubsumptionConfirmed(true); if (possSubsumData->isUpdateRequired()) { prunePossibleSubsumptions(optKPSetClassificationItem,subsumedItem,possSubsumData); } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); } } } propagateDownSubsumption(optKPSetClassificationItem,subsumedItem,subsumerItem); } } } //if (!possSubsumMap || !possSubsumMap->hasRemainingPossibleSubsumptions()) { subsumedItem->setResultSatisfiableDerivated(true); //} } else if (messageData->getClassificationMessageDataType() == CClassificationMessageData::TELLCLASSINITIALIZEPOSSIBLESUBSUM) { ++mStatProcesedPossSubsumInitMessCount; CClassificationInitializePossibleClassSubsumptionMessageData* possSubsumMessageData = (CClassificationInitializePossibleClassSubsumptionMessageData*)messageData; CConcept* subsumedConcept = possSubsumMessageData->getSubsumedConcept(); CCLASSPOSSIBLESUBSUMPTIONMESSAGELIST* possSubsumerList = possSubsumMessageData->getClassPossibleSubsumerList(); bool eqConceptsNonCandidatePossSubsumers = possSubsumMessageData->hasEqConceptsNonCandidatePossSubsumers(); CCLASSPOSSIBLESUBSUMPTIONMESSAGELIST* eqConNonCandPossSubsumerList = possSubsumMessageData->getClassEqConceptNonCandidatePossibleSubsumerList(); #ifdef OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGB QString iriClassNameString = CIRIName::getRecentIRIName(subsumedConcept->getClassNameLinker()); possSubsumInitConList.append(iriClassNameString); #endif COptimizedKPSetClassTestingItem* subsumedItem = nullptr; subsumedItem = optKPSetClassificationItem->getConceptSatisfiableTestItem(subsumedConcept); QSet* equivConNonCandidateSet = optKPSetClassificationItem->getEquivaltentConceptNonCandidateSet(); COptimizedKPSetClassPossibleSubsumptionMap* possSubsumMap = subsumedItem->getPossibleSubsumptionMap(false); if (equivConNonCandidateSet->isEmpty() && (!possSubsumerList || possSubsumerList->empty())) { if (possSubsumMap) { for (COptimizedKPSetClassPossibleSubsumptionMap::const_iterator it = possSubsumMap->constBegin(), itEnd = possSubsumMap->constEnd(); it != itEnd; ++it) { COptimizedKPSetClassPossibleSubsumptionData* possSubsumData = it.value(); if (possSubsumData->isSubsumptionUnknown()) { possSubsumData->setSubsumptionInvalid(true); if (possSubsumData->isUpdateRequired()) { prunePossibleSubsumptions(optKPSetClassificationItem,subsumedItem,possSubsumData); } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); } } } } else { if (!subsumedItem->isPossibleSubsumptionMapInitialized() || possSubsumMap) { possSubsumMap = subsumedItem->getPossibleSubsumptionMap(true); CBOXHASH* equivConCandidateHash = optKPSetClassificationItem->getEquivalentConceptCandidateHash(); if (possSubsumMap->isEmpty()) { // initialize the possible subsumption map if (possSubsumerList) { for (CCLASSPOSSIBLESUBSUMPTIONMESSAGELIST::const_iterator it = possSubsumerList->constBegin(), itEnd = possSubsumerList->constEnd(); it != itEnd; ++it) { CClassificationInitializePossibleClassSubsumptionData* possSubsumDataIt = *it; if (possSubsumDataIt->isPossibleSubsumerValid()) { CConcept* possSubsumConcept = possSubsumDataIt->getPossibleSubsumerConcept(); if (possSubsumConcept->getOperatorCode() != CCEQ || !equivConCandidateHash->contains(possSubsumConcept)) { COptimizedKPSetClassTestingItem* possSubsumItem = optKPSetClassificationItem->getConceptSatisfiableTestItem(possSubsumConcept); if (!subsumedItem->hasSubsumerConceptItem(possSubsumItem) && subsumedItem != possSubsumItem) { COptimizedKPSetClassPossibleSubsumptionData* possSubsumData = new COptimizedKPSetClassPossibleSubsumptionData(possSubsumItem); possSubsumMap->insert(CConceptTagComparer(possSubsumConcept),possSubsumData); incRemainingPossibleSubsumptionTestingCount(optKPSetClassificationItem,possSubsumMap); OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); } } } } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); if (eqConceptsNonCandidatePossSubsumers) { if (eqConNonCandPossSubsumerList) { for (CCLASSPOSSIBLESUBSUMPTIONMESSAGELIST::const_iterator it = eqConNonCandPossSubsumerList->constBegin(), itEnd = eqConNonCandPossSubsumerList->constEnd(); it != itEnd; ++it) { CConcept* eqConcept = *it; COptimizedKPSetClassTestingItem* possEqSubsumItem = optKPSetClassificationItem->getConceptSatisfiableTestItem(eqConcept); if (!subsumedItem->hasSubsumerConceptItem(possEqSubsumItem) && subsumedItem != possEqSubsumItem) { if (!possSubsumMap->contains(CConceptTagComparer(eqConcept))) { COptimizedKPSetClassPossibleSubsumptionData* possSubsumData = new COptimizedKPSetClassPossibleSubsumptionData(possEqSubsumItem); possSubsumMap->insert(CConceptTagComparer(eqConcept),possSubsumData); incRemainingPossibleSubsumptionTestingCount(optKPSetClassificationItem,possSubsumMap); } } } } } else { for (QSet::const_iterator it = equivConNonCandidateSet->constBegin(), itEnd = equivConNonCandidateSet->constEnd(); it != itEnd; ++it) { CConcept* eqConcept = *it; COptimizedKPSetClassTestingItem* possEqSubsumItem = optKPSetClassificationItem->getConceptSatisfiableTestItem(eqConcept); if (!subsumedItem->hasSubsumerConceptItem(possEqSubsumItem) && subsumedItem != possEqSubsumItem) { if (!possSubsumMap->contains(CConceptTagComparer(eqConcept))) { COptimizedKPSetClassPossibleSubsumptionData* possSubsumData = new COptimizedKPSetClassPossibleSubsumptionData(possEqSubsumItem); possSubsumMap->insert(CConceptTagComparer(eqConcept),possSubsumData); incRemainingPossibleSubsumptionTestingCount(optKPSetClassificationItem,possSubsumMap); } } } } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); // prune ancestor items QSet* upPropSet = subsumedItem->getUpPropagationItemSet(); for (QSet::const_iterator it = upPropSet->constBegin(), itEnd = upPropSet->constEnd(); it != itEnd; ++it) { COptimizedKPSetClassTestingItem* upPropItem = *it; COptimizedKPSetClassPossibleSubsumptionMap* upPropItemPossSubsumMap = upPropItem->getPossibleSubsumptionMap(false); if (upPropItemPossSubsumMap) { COptimizedKPSetClassPossibleSubsumptionMap::const_iterator itPoss = possSubsumMap->constBegin(), itPossEnd = possSubsumMap->constEnd(); COptimizedKPSetClassPossibleSubsumptionMap::const_iterator itUpPoss = upPropItemPossSubsumMap->constBegin(), itUpPossEnd = upPropItemPossSubsumMap->constEnd(); while (itPoss != itPossEnd && itUpPoss != itUpPossEnd) { CConcept* possCon = itPoss.key().getConcept(); CConcept* possUpCon = itUpPoss.key().getConcept(); if (possCon->getConceptTag() == possUpCon->getConceptTag()) { ++itPoss; ++itUpPoss; } else if (possCon->getConceptTag() < possUpCon->getConceptTag()) { ++itPoss; } else if (possCon->getConceptTag() > possUpCon->getConceptTag()) { COptimizedKPSetClassPossibleSubsumptionData* upPossData = itUpPoss.value(); if (!subsumedItem->hasSubsumerConceptItem(upPossData->getClassItem()) && subsumedItem != upPossData->getClassItem()) { if (!upPossData->isSubsumptionInvalided()) { upPossData->setSubsumptionInvalid(true); if (upPossData->isUpdateRequired()) { prunePossibleSubsumptions(optKPSetClassificationItem,upPropItem,upPossData); } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); } } ++itUpPoss; } } while (itUpPoss != itUpPossEnd) { COptimizedKPSetClassPossibleSubsumptionData* upPossData = itUpPoss.value(); if (!subsumedItem->hasSubsumerConceptItem(upPossData->getClassItem()) && subsumedItem != upPossData->getClassItem()) { if (!upPossData->isSubsumptionInvalided()) { upPossData->setSubsumptionInvalid(true); if (upPossData->isUpdateRequired()) { prunePossibleSubsumptions(optKPSetClassificationItem,upPropItem,upPossData); } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); } } ++itUpPoss; } } } // prune descendant items QSet* downPropSet = subsumedItem->getDownPropagationItemSet(); for (QSet::const_iterator it = downPropSet->constBegin(), itEnd = downPropSet->constEnd(); it != itEnd; ++it) { COptimizedKPSetClassTestingItem* downPropItem = *it; COptimizedKPSetClassPossibleSubsumptionMap* downPropItemPossSubsumMap = downPropItem->getPossibleSubsumptionMap(false); if (downPropItemPossSubsumMap) { COptimizedKPSetClassPossibleSubsumptionMap::const_iterator itPoss = possSubsumMap->constBegin(), itPossEnd = possSubsumMap->constEnd(); COptimizedKPSetClassPossibleSubsumptionMap::const_iterator itDownPoss = downPropItemPossSubsumMap->constBegin(), itDownPossEnd = downPropItemPossSubsumMap->constEnd(); while (itPoss != itPossEnd && itDownPoss != itDownPossEnd) { CConcept* possCon = itPoss.key().getConcept(); CConcept* possDownCon = itDownPoss.key().getConcept(); if (possCon->getConceptTag() == possDownCon->getConceptTag()) { ++itPoss; ++itDownPoss; } else if (possDownCon->getConceptTag() < possCon->getConceptTag()) { ++itDownPoss; } else if (possDownCon->getConceptTag() > possCon->getConceptTag()) { COptimizedKPSetClassPossibleSubsumptionData* possData = itPoss.value(); if (!downPropItem->hasSubsumerConceptItem(possData->getClassItem()) && downPropItem != possData->getClassItem()) { if (!possData->isSubsumptionInvalided()) { possData->setSubsumptionInvalid(true); if (possData->isUpdateRequired()) { prunePossibleSubsumptions(optKPSetClassificationItem,subsumedItem,possData); } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); } } ++itPoss; } } while (itPoss != itPossEnd) { COptimizedKPSetClassPossibleSubsumptionData* possData = itDownPoss.value(); if (!downPropItem->hasSubsumerConceptItem(possData->getClassItem()) && downPropItem != possData->getClassItem()) { if (!possData->isSubsumptionInvalided()) { possData->setSubsumptionInvalid(true); if (possData->isUpdateRequired()) { prunePossibleSubsumptions(optKPSetClassificationItem,subsumedItem,possData); } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); } } ++itPoss; } } else if (downPropItem->isPossibleSubsumptionMapInitialized()) { for (COptimizedKPSetClassPossibleSubsumptionMap::const_iterator itPoss = possSubsumMap->constBegin(), itPossEnd = possSubsumMap->constEnd(); itPoss != itPossEnd; ++itPoss) { COptimizedKPSetClassPossibleSubsumptionData* possData = itPoss.value(); if (!downPropItem->hasSubsumerConceptItem(possData->getClassItem()) && downPropItem != possData->getClassItem()) { if (!possData->isSubsumptionInvalided()) { possData->setSubsumptionInvalid(true); if (possData->isUpdateRequired()) { prunePossibleSubsumptions(optKPSetClassificationItem,subsumedItem,possData); } } } } } } } else { // prune the possible subsumption map COptimizedKPSetClassPossibleSubsumptionMap::const_iterator itPoss = possSubsumMap->constBegin(), itPossEnd = possSubsumMap->constEnd(); if (possSubsumerList) { CCLASSPOSSIBLESUBSUMPTIONMESSAGELIST::const_iterator itNew = possSubsumerList->constBegin(), itNewEnd = possSubsumerList->constEnd(); while (itPoss != itPossEnd && itNew != itNewEnd) { COptimizedKPSetClassPossibleSubsumptionData* possData = itPoss.value(); CConcept* possCon = itPoss.key().getConcept(); CClassificationInitializePossibleClassSubsumptionData* possNewSubsumDataIt = *itNew; if (possNewSubsumDataIt->isPossibleSubsumerValid()) { CConcept* newCon = possNewSubsumDataIt->getPossibleSubsumerConcept(); if (possCon->getConceptTag() == newCon->getConceptTag()) { ++itPoss; ++itNew; } else if (possCon->getConceptTag() < newCon->getConceptTag()) { if (possCon->getOperatorCode() != CCEQ) { if (!possData->isSubsumptionInvalided()) { possData->setSubsumptionInvalid(true); if (possData->isUpdateRequired()) { prunePossibleSubsumptions(optKPSetClassificationItem,subsumedItem,possData); } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); } } ++itPoss; } else if (possCon->getConceptTag() > newCon->getConceptTag()) { ++itNew; } } else { ++itNew; } } } while (itPoss != itPossEnd) { COptimizedKPSetClassPossibleSubsumptionData* possData = itPoss.value(); CConcept* possCon = itPoss.key().getConcept(); if (possCon->getOperatorCode() != CCEQ) { if (!possData->isSubsumptionInvalided()) { possData->setSubsumptionInvalid(true); if (possData->isUpdateRequired()) { prunePossibleSubsumptions(optKPSetClassificationItem,subsumedItem,possData); } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); } } ++itPoss; } } } } subsumedItem->setPossibleSubsumptionMapInitialized(true); } else if (messageData->getClassificationMessageDataType() == CClassificationMessageData::TELLCLASSUPDATEPOSSIBLESUBSUM) { ++mStatProcesedPossSubsumUpdateMessCount; CClassificationUpdatePossibleClassSubsumptionMessageData* possSubsumMessageData = (CClassificationUpdatePossibleClassSubsumptionMessageData*)messageData; CConcept* subsumedConcept = possSubsumMessageData->getSubsumedConcept(); COptimizedKPSetClassTestingItem* subsumedItem = nullptr; subsumedItem = optKPSetClassificationItem->getConceptSatisfiableTestItem(subsumedConcept); COptimizedKPSetClassPossibleSubsumptionMap* possSubsumMap = subsumedItem->getPossibleSubsumptionMap(false); if (possSubsumMap && !possSubsumMap->empty()) { possSubsumMap = subsumedItem->getPossibleSubsumptionMap(true); for (COptimizedKPSetClassPossibleSubsumptionMap::const_iterator it = possSubsumMap->constBegin(), itEnd = possSubsumMap->constEnd(); it != itEnd; ++it) { COptimizedKPSetClassPossibleSubsumptionData* possSubsumData = it.value(); if (possSubsumData->isUpdateRequired()) { prunePossibleSubsumptions(optKPSetClassificationItem,subsumedItem,possSubsumData); OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); } } } } else if (messageData->getClassificationMessageDataType() == CClassificationMessageData::TELLCLASSPSEUDOMODELIDENTIFIERS) { ++mStatProcesedPseudoModelMessCount; CClassificationPseudoModelIdentifierMessageData* pmMessageData = (CClassificationPseudoModelIdentifierMessageData*)messageData; CConcept* pmConcept = pmMessageData->getPseudoModelConcept(); CMemoryPool* pmMemoryPools = pmMessageData->getPseudoModelMemoryPools(); CClassificationClassPseudoModelHash* pmHash = pmMessageData->getPseudoModelHash(); COptimizedKPSetClassTestingItem* pmItem = nullptr; pmItem = optKPSetClassificationItem->getConceptSatisfiableTestItem(pmConcept); pmItem->getClassPseudoModel()->setPseudoModelHash(pmHash); pmItem->setClassPseudoModelInitalized(true); optKPSetClassificationItem->addMemoryPools(pmMemoryPools); } messageDataLinkerIt = messageDataLinkerIt->getNext(); } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); return true; } bool COptimizedKPSetClassSubsumptionClassifierThread::interpreteToldSubsumptionResult(COntologyClassClassificationItem *ontClassItem, const QList > &subSumRelList, bool isSubSum) { CConcept *lastConcept = nullptr; COptimizedKPSetClassOntologyClassificationItem *optKPSetClassificationItem = (COptimizedKPSetClassOntologyClassificationItem *)ontClassItem; COptimizedKPSetClassTestingItem* 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 = optKPSetClassificationItem->getConceptSatisfiableTestItem(subsumerConcept); } CConcept *subsumedConcept = it->second; if (isSubSum) { COptimizedKPSetClassTestingItem* subsumedItem = optKPSetClassificationItem->getConceptSatisfiableTestItem(subsumedConcept); subsumerItem->addSubsumingConceptItem(subsumedItem); } } return true; } bool COptimizedKPSetClassSubsumptionClassifierThread::interpreteSubsumptionResult(COntologyClassClassificationItem *ontClassItem, CConcept *subsumedConcept, CConcept *subsumerConcept, bool isSubsumption) { COptimizedKPSetClassOntologyClassificationItem *optKPSetClassificationItem = (COptimizedKPSetClassOntologyClassificationItem *)ontClassItem; ++mInterpretedSubsumptionCalculationCount; CConcept* candidateConcept = subsumerConcept; if (subsumerConcept->getOperatorCode() == CCEQ) { candidateConcept = optKPSetClassificationItem->getEquivalentConceptCandidateHash()->value(subsumerConcept); if (!candidateConcept) { candidateConcept = subsumerConcept; } } optKPSetClassificationItem->decRunningPossibleSubsumptionTestsCount(); COptimizedKPSetClassTestingItem* subsumedItem = optKPSetClassificationItem->getConceptSatisfiableTestItem(subsumedConcept); COptimizedKPSetClassTestingItem* subsumerItem = optKPSetClassificationItem->getConceptSatisfiableTestItem(subsumerConcept); //QString iriClassNameString1 = CIRIName::getRecentIRIName(subsumedConcept->getClassNameLinker()); //QString iriClassNameString2 = CIRIName::getRecentIRIName(subsumerConcept->getClassNameLinker()); //if (iriClassNameString1 == "http://krono.act.uji.es/people/Ernesto/qimage-ontology/OntologyQimage.owl#Image_type" && iriClassNameString2 == "http://krono.act.uji.es/people/Ernesto/qimage-ontology/QimageUJIDescriptions.owl#Image_with_uji_office_door") { // bool bug = false; // if (bug) { // calculateSubsumption(optKPSetClassificationItem, subsumedItem, subsumerItem, nullptr); // return false; // } //} //if (iriClassNameString1 == "http://www.bootstrep.eu/ontology/GRO#BindingOfProteinToProteinBindingSiteOfDNA" && iriClassNameString2 == "http://www.bootstrep.eu/ontology/GRO#DNAProteinInteraction") { // bool isSubsumptionFlag = false; // if (fastPseudoModelSubsumptionClassPrecheckTest(optKPSetClassificationItem,subsumedItem,subsumerItem,&isSubsumptionFlag)) { // if (isSubsumptionFlag != isSubsumption) { // while (true) { // fastPseudoModelSubsumptionClassPrecheckTest(optKPSetClassificationItem,subsumedItem,subsumerItem,&isSubsumptionFlag); // } // } // } //} COptimizedKPSetClassTestingItem* topItem = optKPSetClassificationItem->getTopConceptSatisfiableTestItem(); COptimizedKPSetClassPossibleSubsumptionMap* possSubsumMap = subsumedItem->getPossibleSubsumptionMap(false); COptimizedKPSetClassPossibleSubsumptionData* possSubsumData = nullptr; if (possSubsumMap) { possSubsumData = possSubsumMap->value(candidateConcept); } if (isSubsumption) { optKPSetClassificationItem->incCalculatedTruePossibleSubsumerCount(); if (possSubsumData) { possSubsumData->setSubsumptionConfirmed(true); } subsumedItem->addSubsumingConceptItem(subsumerItem); subsumedItem->addUpPropagationItem(subsumerItem); subsumerItem->addDownPropagationItem(subsumedItem); propagateDownSubsumption(optKPSetClassificationItem,subsumedItem,subsumerItem); } else { //if (CIRIName::getRecentIRIName(possSubsumData->getClassItem()->getTestingConcept()->getClassNameLinker()) == "http://www.loria.fr/~coulet/ontology/snpontology/version1.6/snpontology_full.owl#haplotype") { // LOG(ERROR,getLogDomain(),logTr("Calcualted non subsumption with haplotype for item %1.").arg(CIRIName::getRecentIRIName(subsumedItem->getTestingConcept()->getClassNameLinker())),getLogObject()); // bool bug = true; //} optKPSetClassificationItem->incCalculatedFalsePossibleSubsumerCount(); if (possSubsumData) { possSubsumData->setSubsumptionInvalid(true); } } if (possSubsumData && possSubsumData->isUpdateRequired()) { prunePossibleSubsumptions(optKPSetClassificationItem,subsumedItem,possSubsumData); OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); } 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->getRemainingPossibleSubsumptionClassTestingSet(); remTestingSet->remove(subsumedItem); } } } } if (mConfPossSubsumCalcOrderBottomUp) { if (currentItemSet->contains(subsumerItem)) { currentItemSet->remove(subsumerItem); if (subsumerItem->hasRemainingPossibleSubsumedItems()) { QSet* remPossSubsumedItemSet = subsumerItem->getPossibleSubsumedSet(false); QList* remPossSubsumedItemList = subsumerItem->getPossibleSubsumedList(); nextItemList->prepend(subsumerItem); QSet* upPropSet = subsumedItem->getUpPropagationItemSet(); for (QSet::const_iterator itUp = upPropSet->constBegin(), itUpEnd = upPropSet->constEnd(); itUp != itUpEnd; ++itUp) { COptimizedKPSetClassTestingItem* upItem = *itUp; if (remPossSubsumedItemSet->contains(upItem)) { remPossSubsumedItemList->prepend(upItem); } } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectReferenced(optKPSetClassificationItem)); } else { QSet* remTestingSet = optKPSetClassificationItem->getRemainingPossibleSubsumptionClassTestingSet(); remTestingSet->remove(subsumerItem); OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectReferenced(optKPSetClassificationItem)); } } } return true; } bool COptimizedKPSetClassSubsumptionClassifierThread::prunePossibleSubsumptions(COptimizedKPSetClassOntologyClassificationItem *optKPSetClassificationItem, COptimizedKPSetClassTestingItem* item, COptimizedKPSetClassPossibleSubsumptionData* possSubsumData) { //if (possSubsumData->isSubsumptionInvalided()) { // //if (CIRIName::getRecentIRIName(item->getTestingConcept()->getClassNameLinker()) == "http://www.w3.org/2002/07/owl#Thing") { // if (CIRIName::getRecentIRIName(possSubsumData->getClassItem()->getTestingConcept()->getClassNameLinker()) == "http://www.loria.fr/~coulet/ontology/snpontology/version1.6/snpontology_full.owl#haplotype") { // LOG(ERROR,getLogDomain(),logTr("Pruned haplotype for item %1.").arg(CIRIName::getRecentIRIName(item->getTestingConcept()->getClassNameLinker())),getLogObject()); // bool bug = true; // } // //} //} if (possSubsumData->isUpdateRequired()) { COptimizedKPSetClassPossibleSubsumptionMap* possSubsumMap = item->getPossibleSubsumptionMap(false); possSubsumData->setSubsumptionUpdated(true); decRemainingPossibleSubsumptionTestingCount(optKPSetClassificationItem,possSubsumMap,true); if (possSubsumData->isSubsumptionConfirmed()) { // is subsuming COptimizedKPSetClassTestingItem* subsumerItem = possSubsumData->getClassItem(); CConcept* subsumerConcept = subsumerItem->getTestingConcept(); // establish the subsumption for all successor nodes QSet* downPropSet = item->getDownPropagationItemSet(); for (QSet::const_iterator it = downPropSet->constBegin(), itEnd = downPropSet->constEnd(); it != itEnd; ++it) { COptimizedKPSetClassTestingItem* downPropItem = *it; pruneDownSubsumption(optKPSetClassificationItem,downPropItem,subsumerConcept); } if (subsumerConcept->getOperatorCode() == CCEQ) { CConcept* candidateConcept = optKPSetClassificationItem->getEquivalentConceptCandidateHash()->value(subsumerConcept); if (candidateConcept) { for (QSet::const_iterator it = downPropSet->constBegin(), itEnd = downPropSet->constEnd(); it != itEnd; ++it) { COptimizedKPSetClassTestingItem* downPropItem = *it; pruneDownSubsumption(optKPSetClassificationItem,downPropItem,candidateConcept); } } } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); return true; } else { // is not subsuming COptimizedKPSetClassTestingItem* notSubsumerItem = possSubsumData->getClassItem(); CConcept* notSubsumerConcept = notSubsumerItem->getTestingConcept(); // establish the subsumption for all successor nodes QSet* upPropSet = item->getUpPropagationItemSet(); for (QSet::const_iterator it = upPropSet->constBegin(), itEnd = upPropSet->constEnd(); it != itEnd; ++it) { COptimizedKPSetClassTestingItem* upPropItem = *it; pruneUpNotSubsumption(optKPSetClassificationItem,upPropItem,notSubsumerConcept); } if (notSubsumerConcept->getOperatorCode() == CCEQ) { CConcept* candidateConcept = optKPSetClassificationItem->getEquivalentConceptCandidateHash()->value(notSubsumerConcept); if (candidateConcept) { for (QSet::const_iterator it = upPropSet->constBegin(), itEnd = upPropSet->constEnd(); it != itEnd; ++it) { COptimizedKPSetClassTestingItem* upPropItem = *it; pruneUpNotSubsumption(optKPSetClassificationItem,upPropItem,candidateConcept); } } } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(testDebugPossibleSubsumerCorrectCounted(optKPSetClassificationItem)); return true; } } return false; } bool COptimizedKPSetClassSubsumptionClassifierThread::propagateDownSubsumption(COptimizedKPSetClassOntologyClassificationItem *optKPSetClassificationItem, COptimizedKPSetClassTestingItem* item, COptimizedKPSetClassTestingItem* subsumerItem) { bool propagated = false; QSet* downPropSet = item->getDownPropagationItemSet(); for (QSet::const_iterator it = downPropSet->constBegin(), itEnd = downPropSet->constEnd(); it != itEnd; ++it) { COptimizedKPSetClassTestingItem* downPropItem = *it; if (!downPropItem->hasSubsumerConceptItem(subsumerItem) && downPropItem != subsumerItem) { downPropItem->addSubsumingConceptItem(subsumerItem); propagateDownSubsumption(optKPSetClassificationItem,downPropItem,subsumerItem); propagated = true; } } return propagated; } bool COptimizedKPSetClassSubsumptionClassifierThread::pruneDownSubsumption(COptimizedKPSetClassOntologyClassificationItem *optKPSetClassificationItem, COptimizedKPSetClassTestingItem* item, CConcept* subsumerConcept) { COptimizedKPSetClassPossibleSubsumptionMap* possSubsumMap = item->getPossibleSubsumptionMap(false); if (possSubsumMap) { COptimizedKPSetClassPossibleSubsumptionData* possSubsumData = possSubsumMap->value(subsumerConcept); 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) { COptimizedKPSetClassTestingItem* downPropItem = *it; pruneDownSubsumption(optKPSetClassificationItem,downPropItem,subsumerConcept); } return true; } } return false; } bool COptimizedKPSetClassSubsumptionClassifierThread::pruneUpNotSubsumption(COptimizedKPSetClassOntologyClassificationItem *optKPSetClassificationItem, COptimizedKPSetClassTestingItem* item, CConcept* notSubsumerConcept) { COptimizedKPSetClassPossibleSubsumptionMap* possSubsumMap = item->getPossibleSubsumptionMap(false); if (possSubsumMap) { COptimizedKPSetClassPossibleSubsumptionData* possSubsumData = possSubsumMap->value(notSubsumerConcept); 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) { COptimizedKPSetClassTestingItem* upPropItem = *it; pruneUpNotSubsumption(optKPSetClassificationItem,upPropItem,notSubsumerConcept); } return true; } } return false; } bool COptimizedKPSetClassSubsumptionClassifierThread::interpreteSatisfiableResult(COntologyClassClassificationItem *ontClassItem, CConcept *satisfiableConcept, bool isSatis) { COptimizedKPSetClassOntologyClassificationItem *optKPSetClassificationItem = (COptimizedKPSetClassOntologyClassificationItem *)ontClassItem; CClassifierStatistics *ontClassStat = optKPSetClassificationItem->getClassifierStatistics(); if (ontClassStat) { ontClassStat->incToldSatisfiableCount(1); } ++satTestedCount; optKPSetClassificationItem->decRunningSatisfiableTestsCount(); COptimizedKPSetClassTestingItem* satTestedItem = optKPSetClassificationItem->getConceptSatisfiableTestItem(satisfiableConcept); //if (CIRIName::getRecentIRIName(satisfiableConcept->getClassNameLinker()) == "http://www.w3.org/TR/2003/CR-owl-guide-20030818/wine#WineFlavor" && !isSatis || unsatComputed) { // bool bug = true; // unsatComputed = true; // if (!isSatis) { // unsatCount++; // } else { // satCount++; // } // calculateSatisfiable(optKPSetClassificationItem,satTestedItem); // return false; //} satTestedItem->setSatisfiableTested(true); satTestedItem->setSatisfiableTestedResult(isSatis); COptimizedKPSetClassTestingItem* topItem = optKPSetClassificationItem->getTopConceptSatisfiableTestItem(); if (isSatis) { // update processing lists #ifdef OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGB QString iriClassNameString = CIRIName::getRecentIRIName(satisfiableConcept->getClassNameLinker()); satTestedConList.append(iriClassNameString); #endif #ifdef OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGLOGOUTPUT LOG(INFO,getLogDomain(),QString("[%1 / %2] Calculated: '%3' is satisfiable").arg(satTestedCount).arg(totalToSatTestClassCount).arg(iriClassNameString),this); #endif #ifdef OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGSTATUSDESCRIPTION statUpdateMutex.lock(); statusString = QString("Interpreting, '%1' is satisfiable").arg(iriClassNameString); statUpdateMutex.unlock(); #endif #ifdef OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCOUTOUTPUT cout<addSatisfiableConceptItem(satTestedItem); } else { CTaxonomy *tax = optKPSetClassificationItem->getTaxonomy(); if (topItem) { tax->setConceptSatisfiable(satisfiableConcept,false); } else { tax->getBottomHierarchyNode()->addEquivalentConcept(satisfiableConcept); tax->updateNodeEquivalences(tax->getBottomHierarchyNode()); } } QList* nextItemList = optKPSetClassificationItem->getNextSatisfiableTestingItemList(); QSet* nextCandItemSet = optKPSetClassificationItem->getNextCandidateSatisfiableTestingItemSet(); QSet* remainingCandItemSet = optKPSetClassificationItem->getRemainingCandidateSatisfiableTestingItemSet(); QList* subSumItemList = satTestedItem->getSubsumingConceptItemList(); QList* succItemList = satTestedItem->getSuccessorItemList(); for (QList::const_iterator it = succItemList->constBegin(), itEnd = succItemList->constEnd(); it != itEnd; ++it) { COptimizedKPSetClassTestingItem* succItem = *it; if (!isSatis) { succItem->setResultUnsatisfiableDerivated(true); } else { for (QList::const_iterator itSubsum = subSumItemList->constBegin(), itSubsumEnd = subSumItemList->constEnd(); itSubsum != itSubsumEnd; ++itSubsum) { COptimizedKPSetClassTestingItem* subusmerItem = *itSubsum; if (succItem != subusmerItem) { succItem->addSubsumingConceptItem(subusmerItem); } } } succItem->decUnprocessedPredecessorItems(); if (succItem->hasOnlyProcessedPredecessorItems()) { nextItemList->append(succItem); } else { nextCandItemSet->insert(succItem); } } return false; } bool COptimizedKPSetClassSubsumptionClassifierThread::interpreteTestResults(CTestCalculatedCallbackEvent *testResult) { CSatisfiableCalculationJob *satCalcJob = testResult->getSatisfiableCalculationJob(); bool testSat = testResult->getTestResultSatisfiable(); CClassClassificationComputationItem *workItem = (CClassClassificationComputationItem*)testResult->getClassificationWorkItem(); ++mRecievedCallbackCount; 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); } else if (workItem->isConceptSubsumptionTest()) { interpreteSubsumptionResult(ontClassItem,workItem->getSubsumedTestedConcept(),workItem->getSubsumerTestedConcept(),!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) { ontClassItem->reuseCalculationStatisticsCollection(statisticCollection); } #ifdef OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGTAXONOMYCOUTOUTPUT QString taxString = taxonomy->getConceptHierarchyString(); cout<isTaxonomyConstructed() && !ontClassItem->isTaxonomyConstructionFailed()) { #ifdef OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGLOGOUTPUT LOG(INFO,getLogDomain(),QString("Building Class Taxonomy"),this); #endif CTaxonomy *taxonomy = ontClassItem->getTaxonomy(); CConcreteOntology *ontology = ontClassItem->getOntology(); LOG(INFO,getLogDomain(),logTr("Starting Transitive Reduction for Ontology '%1'.").arg(ontology->getTerminologyName()),getLogObject()); // build taxonomy COptimizedKPSetClassOntologyClassificationItem *optKPSetClassificationItem = (COptimizedKPSetClassOntologyClassificationItem *)ontClassItem; QList* satItemList = optKPSetClassificationItem->getSatisfiableConceptItemList(); if (mConfWriteDebuggingData) { createDebugKPSetString(optKPSetClassificationItem, "./Debugging/Classification/classkpsets-final.txt"); } OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGCONSISTENCYTEST(createDebugKPSetString(optKPSetClassificationItem,"./Debugging/Classification/classkpsets-final.txt")); CTaxonomy *tax = optKPSetClassificationItem->getTaxonomy(); QList itemList; COptimizedKPSetClassTestingItem* topItem = optKPSetClassificationItem->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) { COptimizedKPSetClassTestingItem* subsumedConceptItem = *subsumedIt; // mark as equivalent subsumedConceptItem->setEquivalentItem(true); topHierNode->addEquivalentConcept(subsumedConceptItem->getTestingConcept()); tax->updateNodeEquivalences(topHierNode); } } LOG(INFO,getLogDomain(),logTr("Sorting classes for Ontology '%1'.").arg(ontology->getTerminologyName()),getLogObject()); for (QList::const_iterator it = satItemList->constBegin(), itEnd = satItemList->constEnd(); it != itEnd; ++it) { COptimizedKPSetClassTestingItem* item = *it; //QString iriClassNameString = CIRIName::getRecentIRIName(item->getTestingConcept()->getClassNameLinker()); //if (iriClassNameString == "http://ontology.dumontierlab.com/UnitRaisedToPower") { // bool bug = true; //} if (!item->isEquivalentItem() && item != topItem) { CHierarchyNode* itemNode = tax->getHierarchyNode(item->getTestingConcept(),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) { COptimizedKPSetClassTestingItem* subsumedConceptItem = *subsumedIt; cint64 subsumedItemSubsumingCount = subsumedConceptItem->getSubsumingConceptItemCount(); if (subsumedItemSubsumingCount == itemSubsumingCount) { // mark as equivalent subsumedConceptItem->setEquivalentItem(true); itemNode->addEquivalentConcept(subsumedConceptItem->getTestingConcept()); tax->updateNodeEquivalences(itemNode); } else { break; } } } } } 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) { COptimizedKPSetClassTestingItem* item = *it; //QString iriClassNameString = CIRIName::getRecentIRIName(item->getTestingConcept()->getClassNameLinker()); //if (iriClassNameString == "http://usefulinc.com/ns/doap#Project") { // bool bug = true; //} if (!item->isEquivalentItem() && item != topItem) { cint64 itemSubsumingCount = item->getSubsumingConceptItemCount(); CHierarchyNode* itemHierNode = item->getSatisfiableConceptHierarchyNode(); 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) { COptimizedKPSetClassTestingItem* subsumedConceptItem = *subsumedIt; cint64 subsumedItemSubsumingCount = subsumedConceptItem->getSubsumingConceptItemCount(); 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) { COptimizedKPSetClassTestingItem* 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) { COptimizedKPSetClassTestingItem* subsumedConceptItem = *subsumedIt; if (!subsumedConceptItem->isEquivalentItem()) { bool predOfOnePrevParent = false; if (searchForMoreParents) { for (QList::const_iterator parentIt = parentItemList.constBegin(), parentItEnd = parentItemList.constEnd(); parentIt != parentItEnd && !predOfOnePrevParent; ++parentIt) { COptimizedKPSetClassTestingItem* 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) { COptimizedKPSetClassTestingItem* item = *it; if (!item->isPredecessorItem() && !item->isEquivalentItem()) { CHierarchyNode* itemHierNode = item->getSatisfiableConceptHierarchyNode(); bottomHierNode->makeParent(itemHierNode); } } LOG(INFO,getLogDomain(),logTr("Collect statistics for Ontology '%1'.").arg(ontology->getTerminologyName()),getLogObject()); #ifdef OPTIMIZEDKPSETCLASSCLASSIFIERDEBUGSTATUSDESCRIPTION statUpdateMutex.lock(); statusString = QString("Finished ontology classification"); statUpdateMutex.unlock(); #endif CClassification* classification = ontology->getClassification(); if (classification) { CClassConceptClassification* classConClassification = ontClassItem->getClassConceptClassification(); addClassificationStatistics(ontClassItem,classConClassification); if (ontClassItem->getIndividualDependenceTrackingCollector()) { classConClassification->setDependentIndividualsTracking(ontClassItem->getIndividualDependenceTrackingCollector()->getExtendingIndividualDependenceTracking()); } classConClassification->setClassConceptTaxonomy(taxonomy); CClassificationStatisticsCollectionStrings* classifStatCollStrings = ontClassItem->getClassificationStatisticsCollectionStrings(); classConClassification->setClassificationStatistics(classifStatCollStrings); classification->setClassConceptClassification(classConClassification); } ontology->setConceptTaxonomy(taxonomy); ontClassItem->setHasRemainingTests(false); taxonomy->setTaxonomyComplete(true); --mClassificationCount; LOG(INFO,getLogDomain(),logTr("Ontology '%1' classified.").arg(ontology->getTerminologyName()),getLogObject()); LOG(INFO,getLogDomain(),logTr("Used %1 satisfiable tests, %2 pseudo model merged subsumption tests and %3 calculated subsumption tests.").arg(ontClassItem->getCalcedSatisfiableCount()).arg(ontClassItem->getClassifierStatistics()->getPseudoModelMergedTestedSubsumptionCount()).arg(ontClassItem->getClassifierStatistics()->getCalculatedTestedSubsumptionCount()),getLogObject()); LOG(INFO,getLogDomain(),logTr("Confirmed %1 of %2 possible subsumer concepts.").arg(optKPSetClassificationItem->getTruePossibleSubsumerCount()).arg(optKPSetClassificationItem->getPossibleSubsumerCount()),getLogObject()); LOG(INFO,getLogDomain(),logTr("Confirmed %1 and invalidated %2 possible subsumer concepts with calculation.").arg(optKPSetClassificationItem->getCalculatedTruePossibleSubsumerCount()).arg(optKPSetClassificationItem->getFalsePossibleSubsumerCount()),getLogObject()); } ontClassItem->submitTaxonomyConstructed(); ontClassItem->doClassifiedCallback(); return true; } bool COptimizedKPSetClassSubsumptionClassifierThread::addClassificationStatistics(COntologyClassClassificationItem *ontClassItem, CClassConceptClassification* classConClassification) { 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-derivation-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-derivation-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()); classifStatCollStrings->addProcessingStatistics("class-classification-time",ontClassItem->getInitializationTime()->elapsed()); COntologyProcessingStatistics* ontProcStats = ontClassItem->getClassificationProcessingStep()->getProcessingStatistics(true); ontProcStats->setProcessingCountStatisticValue("class-classification-time",ontClassItem->getInitializationTime()->elapsed()); COptimizedKPSetClassOntologyClassificationItem *optKPSetClassificationItem = dynamic_cast(ontClassItem); if (optKPSetClassificationItem) { addIndividualDependencyTrackingStatistics(optKPSetClassificationItem); } return true; } COptimizedKPSetClassSubsumptionClassifierThread* COptimizedKPSetClassSubsumptionClassifierThread::addIndividualDependencyTrackingStatistics(COptimizedKPSetClassOntologyClassificationItem *optKPSetClassificationItem, const QString& classificationTypeString) { if (optKPSetClassificationItem->getIndividualDependenceTrackingCollector()) { CClassificationStatisticsCollectionStrings* classifStatCollStrings = optKPSetClassificationItem->getClassificationStatisticsCollectionStrings(); CIndividualDependenceTracking* indiDepTack = optKPSetClassificationItem->getIndividualDependenceTrackingCollector()->getExtendingIndividualDependenceTracking(); if (indiDepTack) { classifStatCollStrings->addProcessingStatistics(QString("%1-tracked-node-dependency-size").arg(classificationTypeString),indiDepTack->getDependenceSize()); classifStatCollStrings->addProcessingStatistics(QString("%1-tracked-node-dependency-count").arg(classificationTypeString),1); } } return this; } }; // end namespace Classifier }; // end namespace Reasoner }; // end namespace Konclude