Debian Codegraph @

Source/Reasoner/Realizer/CIncrementalKPSetOntologyConceptRealizingThread.cpp

raw
1 /*
2 * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
3 *
4 * This file is part of the reasoning system Konclude.
5 * For details and support, see <http://konclude.com/>.
6 *
7 * Konclude is free software: you can redistribute it and/or modify
8 * it under the terms of version 3 of the GNU Lesser General Public
9 * License (LGPLv3) as published by the Free Software Foundation.
10 *
11 * Konclude is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU (Lesser) General Public License for more details.
15 *
16 * You should have received a copy of the GNU (Lesser) General Public
17 * License along with Konclude. If not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21 #include "CIncrementalKPSetOntologyConceptRealizingThread.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Realizer {
29
30
31 CIncrementalKPSetOntologyConceptRealizingThread::CIncrementalKPSetOntologyConceptRealizingThread(CReasonerManager *reasonerManager) : COptimizedRepresentativeKPSetOntologyRealizingThread(reasonerManager) {
32 }
33
34 CIncrementalKPSetOntologyConceptRealizingThread::~CIncrementalKPSetOntologyConceptRealizingThread() {
35 }
36
37
38 COntologyRealizingItem* CIncrementalKPSetOntologyConceptRealizingThread::initializeOntologyRealizingItem(CConcreteOntology* ontology, CConfigurationBase* config) {
39 return COptimizedRepresentativeKPSetOntologyRealizingThread::initializeOntologyRealizingItem(ontology,config);
40 }
41
42 void CIncrementalKPSetOntologyConceptRealizingThread::readCalculationConfig(CConfigurationBase *config) {
43 COptimizedRepresentativeKPSetOntologyRealizingThread::readCalculationConfig(config);
44 }
45
46
47
48
49
50 bool CIncrementalKPSetOntologyConceptRealizingThread::isIndividualAffectedByIncrementalChanges(CIndividual* individual, COptimizedRepresentativeKPSetOntologyRealizingItem* reqConfPreCompItem) {
51 CConcreteOntology* ontology = reqConfPreCompItem->getOntology();
52
53 cint64 indiID = individual->getIndividualID();
54
55 CConcreteOntology* prevRealizedOntology = ontology->getIncrementalRevisionData()->getPreviousClassTypesRealizedOntology();
56 CConcreteOntology* prevConsOntology = ontology;
57 do {
58 CConsistence* prevCons = prevConsOntology->getConsistence();
59 CIncrementalConsistenceTaskData* incConsTaskData = dynamic_cast<CIncrementalConsistenceTaskData*>(prevCons->getConsistenceModelData());
60 if (incConsTaskData) {
61 if (incConsTaskData->getIndirectlyChangedNodeSet()->contains(indiID)) {
62 return true;
63 }
64 } else {
65 return true;
66 }
67 if (prevConsOntology != prevRealizedOntology) {
68 prevConsOntology = prevConsOntology->getIncrementalRevisionData()->getPreviousConsistentOntology();
69 }
70 } while (prevConsOntology && prevConsOntology != prevRealizedOntology);
71 return false;
72 }
73
74
75
76
77
78 bool CIncrementalKPSetOntologyConceptRealizingThread::isIndividualItemAffectedByIncrementalChanges(COptimizedKPSetIndividualItem* indiItem, COptimizedRepresentativeKPSetOntologyRealizingItem* reqConfPreCompItem) {
79 CIndividualDependenceTrackingCollector* indDepTrackingCollector = indiItem->getIndividualDependenceTrackingCollector();
80 if (indDepTrackingCollector) {
81 CIndividualDependenceTracking* indiDepTracking = indDepTrackingCollector->getExtendingIndividualDependenceTracking();
82
83 CConcreteOntology* ontology = reqConfPreCompItem->getOntology();
84 CConcreteOntology* prevRealizedOntology = ontology->getIncrementalRevisionData()->getPreviousClassTypesRealizedOntology();
85 CConcreteOntology* prevConsOntology = ontology;
86 do {
87 CConsistence* prevCons = prevConsOntology->getConsistence();
88 CIncrementalConsistenceTaskData* incConsTaskData = dynamic_cast<CIncrementalConsistenceTaskData*>(prevCons->getConsistenceModelData());
89 if (incConsTaskData) {
90 if (indiDepTracking && indiDepTracking->areIndividualsAffected(incConsTaskData)) {
91 return true;
92 }
93 } else {
94 return true;
95 }
96 if (prevConsOntology != prevRealizedOntology) {
97 prevConsOntology = prevConsOntology->getIncrementalRevisionData()->getPreviousConsistentOntology();
98 }
99 } while (prevConsOntology && prevConsOntology != prevRealizedOntology);
100
101 }
102 return false;
103 }
104
105
106
107
108 bool CIncrementalKPSetOntologyConceptRealizingThread::initializeIndividualProcessingKPSetsFromConsistencyData(COptimizedRepresentativeKPSetOntologyRealizingItem* reqConfPreCompItem) {
109
110
111 /*CConcreteOntology* ontology = reqConfPreCompItem->getOntology();
112 CConcreteOntology* prevRealizedOntology = ontology->getIncrementalRevisionData()->getPreviousClassTypesRealizedOntology();
113 CRealization* prevRealization = prevRealizedOntology->getRealization();
114
115 COptimizedRepresentativeKPSetOntologyRealizingItem* prevConRealItem = (COptimizedRepresentativeKPSetOntologyRealizingItem*)prevRealization->getConceptRealization();
116
117
118
119 CConcreteOntology* prevConsOntology = ontology->getIncrementalRevisionData()->getPreviousConsistentOntology();
120
121
122 cint64 previousReusedIndiCalculationsCount = 0;
123 cint64 newInitializedIndiCalculationsCount = 0;
124
125 CIndividualVector* indiVec = ontology->getABox()->getIndividualVector(false);
126 if (indiVec) {
127 CIndividualProcessNodeVector* indiProcVector = nullptr;
128 CConsistence* consistence = reqConfPreCompItem->getOntology()->getConsistence();
129 if (consistence) {
130 CConsistenceData* consData = consistence->getConsistenceModelData();
131 if (consData) {
132 CConsistenceTaskData* consTaskData = dynamic_cast<CConsistenceTaskData*>(consData);
133 CSatisfiableCalculationTask* satConsTask = consTaskData->getCompletionGraphCachedSatisfiableTask();
134 if (!satConsTask) {
135 satConsTask = consTaskData->getDeterministicSatisfiableTask();
136 }
137 if (satConsTask) {
138 CProcessingDataBox* procDataBox = satConsTask->getProcessingDataBox();
139 if (procDataBox) {
140 indiProcVector = procDataBox->getIndividualProcessNodeVector();
141 }
142 }
143 }
144 }
145 CIndividualVector* prevIndiVec = prevRealizedOntology->getABox()->getIndividualVector(false);
146
147
148 QList<COptimizedKPSetConceptInstancesItem*> equivClassList;
149 initializeEquivalentClassList(&equivClassList,reqConfPreCompItem);
150
151 QHash<CConcept*,COptimizedKPSetConceptInstancesItem*>* conInstItemHash = reqConfPreCompItem->getConceptInstancesItemHash();
152
153 QHash<CIndividual*,QList<CIndividual*> > individualPossibleSameIndividualListHash;
154
155 CBOXSET<CIndividual*>* activeIndividualSet = reqConfPreCompItem->getOntology()->getABox()->getActiveIndividualSet(false);
156
157 cint64 indiCount = indiVec->getItemCount();
158 for (cint64 indiID = 0; indiID < indiCount; ++indiID) {
159
160 CIndividual* individual = indiVec->getData(indiID);
161 if (individual && !individual->isAnonymousIndividual() && !reqConfPreCompItem->hasIndividualInstantiatedItem(individual) && activeIndividualSet->contains(individual)) {
162
163
164 QList<COptimizedKPSetConceptInstancesItem*> knownInstancesList;
165 QList<COptimizedKPSetConceptInstancesItem*> possibleInstancesList;
166
167 QList<CIndividual*> knownSameIndividualList;
168 QList<CIndividual*> possibleSameIndividualList;
169
170 COptimizedKPSetIndividualItem* prevIndiItem = prevConRealItem->getIndividualInstantiatedItem(individual,false);
171 if (!prevIndiItem) {
172 CIndividual* prevIndi = prevIndiVec->getData(indiID);
173 prevIndiItem = prevConRealItem->getIndividualInstantiatedItem(prevIndi,false);
174 }
175
176 bool newRealisationRequired = false;
177 if (!prevIndiItem) {
178 newRealisationRequired = true;
179 } else {
180 if (isIndividualAffectedByIncrementalChanges(individual,reqConfPreCompItem)) {
181 newRealisationRequired = true;
182 } else {
183 if (isIndividualItemAffectedByIncrementalChanges(prevIndiItem,reqConfPreCompItem)) {
184 newRealisationRequired = true;
185 }
186 }
187 }
188
189 if (newRealisationRequired) {
190 ++newInitializedIndiCalculationsCount;
191 extractKnownPossibleIndividualDataFromConsistencyData(individual,&knownInstancesList,&possibleInstancesList,&knownSameIndividualList,&possibleSameIndividualList,indiProcVector,equivClassList,reqConfPreCompItem);
192 } else {
193 ++previousReusedIndiCalculationsCount;
194 QSet<CIndividual*>* prevKnownSameIndiSet = prevIndiItem->getKnownSameIndividualSet();
195 for (QSet<CIndividual*>::const_iterator it = prevKnownSameIndiSet->constBegin(), itEnd = prevKnownSameIndiSet->constEnd(); it != itEnd; ++it) {
196 CIndividual* prevKnownSameIndi = *it;
197 knownSameIndividualList.append(prevKnownSameIndi);
198 }
199 COptimizedKPSetConceptInstancesHash* prevKnownPossConInstHash = prevIndiItem->getKnownPossibleInstancesHash();
200 for (COptimizedKPSetConceptInstancesHash::const_iterator it = prevKnownPossConInstHash->constBegin(), itEnd = prevKnownPossConInstHash->constEnd(); it != itEnd; ++it) {
201 COptimizedKPSetConceptInstancesItem* instItem = it.key();
202 const COptimizedKPSetConceptInstancesHashData& instItemData = it.value();
203 if (instItemData.mInstanceItemData->mKnownInstance) {
204 COptimizedKPSetConceptInstancesItem* instantiatedItem = conInstItemHash->value(instItem->getHierarchyNode()->getOneEquivalentConcept());
205 knownInstancesList.append(instantiatedItem);
206 }
207 }
208 }
209
210 initializeKPSetsForIndividual(reqConfPreCompItem,individual,knownInstancesList,possibleInstancesList,knownSameIndividualList);
211
212 if (!possibleSameIndividualList.isEmpty()) {
213 individualPossibleSameIndividualListHash.insert(individual,possibleSameIndividualList);
214 }
215 }
216 }
217
218 if (!individualPossibleSameIndividualListHash.isEmpty()) {
219 QSet<COptimizedKPSetIndividualItem*> singleIndividualSet;
220 for (QHash<CIndividual*,QList<CIndividual*> >::const_iterator it = individualPossibleSameIndividualListHash.constBegin(), itEnd = individualPossibleSameIndividualListHash.constEnd(); it != itEnd; ++it) {
221 CIndividual* individual = it.key();
222 COptimizedKPSetIndividualItem* individualItem = reqConfPreCompItem->getIndividualInstantiatedItem(individual,false);
223 if (!singleIndividualSet.contains(individualItem)) {
224 singleIndividualSet.insert(individualItem);
225 const QList<CIndividual*> possibleSameIndividualList = it.value();
226 initializeSamePossibleIndividuals(reqConfPreCompItem,individualItem,possibleSameIndividualList);
227 }
228 }
229 }
230
231 }
232
233
234 COntologyProcessingStatistics* ontProcStats = reqConfPreCompItem->getRealizeSameIndividualsProcessingStep()->getProcessingStepData()->getProcessingStatistics(true);
235 ontProcStats->setProcessingCountStatisticValue("incremental-realization-previously-reused-individual-calculations-count",previousReusedIndiCalculationsCount);
236 ontProcStats->setProcessingCountStatisticValue("incremental-realization-newly-initialized-individual-calculations-count",newInitializedIndiCalculationsCount);
237 */
238
239 return true;
240 }
241
242
243
244 COptimizedRepresentativeKPSetOntologyRealizingThread* CIncrementalKPSetOntologyConceptRealizingThread::addRealizationStatistics(COptimizedRepresentativeKPSetOntologyRealizingItem* reqConfPreCompItem, CRealizingTestingStep* ontProcStep) {
245 COntologyProcessingStatistics* ontProcStats = ontProcStep->getProcessingStepData()->getProcessingStatistics(true);
246 ontProcStats->setProcessingCountStatisticValue("incremental-realization-time",reqConfPreCompItem->getInitializationTime()->elapsed());
247 if (reqConfPreCompItem->getRealizeConceptProcessingStep() == ontProcStep) {
248 ontProcStats->setProcessingCountStatisticValue("incremental-realization-concept-instances-possible-testing-count",reqConfPreCompItem->getTestedPossibleConceptInstancesCount());
249 ontProcStats->setProcessingCountStatisticValue("incremental-realization-concept-instances-time",reqConfPreCompItem->getInitializationTime()->elapsed());
250 addIndividualDependencyTrackingStatistics(reqConfPreCompItem,ontProcStep,"incremental-realization-concept-instances");
251 } else if (reqConfPreCompItem->getRealizeSameIndividualsProcessingStep() == ontProcStep) {
252 ontProcStats->setProcessingCountStatisticValue("incremental-realization-same-individuals-possible-testing-count",reqConfPreCompItem->getTestedPossibleSameIndividualsCount());
253 addIndividualDependencyTrackingStatistics(reqConfPreCompItem,ontProcStep,"incremental-realization-same-individuals");
254 }
255 return this;
256 }
257
258
259 }; // end namespace Realizer
260
261 }; // end namespace Reasoner
262
263 }; // end namespace Konclude