Debian Codegraph @

Source/Reasoner/Kernel/Task/CCalculationConfigurationExtension.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 "CCalculationConfigurationExtension.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Kernel {
29
30 namespace Task {
31
32 CCalculationConfigurationExtension::CCalculationConfigurationExtension(CConfigurationBase *fixedCollectingConfiguration, qint64 configID)
33 : CLocalConfigurationFixedExtension((fixedCollectingConfiguration)?fixedCollectingConfiguration->getConfigurationGroup():0,configID) {
34 addCollectedConfigurations(fixedCollectingConfiguration);
35 mConfDependencyTrackingChecked = false;
36 mConfBackjumpingChecked = false;
37 mConfSatCachingChecked = false;
38 mConfUnsatCachingChecked = false;
39 mConfProxyIndividualsChecked = false;
40 mConfMinimizeMergingBranchesChecked = false;
41 mConfSatCacheSingleLevelWritingChecked = false;
42 mConfUnsatCacheSingleLevelWritingChecked = false;
43 mConfUnsatCacheTestedConceptWritingChecked = false;
44 mConfPseudoModelRuleEssentialCheckingChecked = false;
45 mConfClassPseudoModelSubsumptionMergingChecked = false;
46 mConfSpecializedAutomateRuleChecked = false;
47 mConfSubSetBlockingChecked = false;
48 mConfOptimizedBlockingChecked = false;
49 mConfEqualSetBlockingChecked = false;
50 mConfPairwiseEqualSetBlockingChecked = false;
51 mConfAncestorBlockingSearchChecked = false;
52 mConfAnywhereBlockingSearchChecked = false;
53 mConfAnywhereBlockingCandidateHashSearchChecked = false;
54 mConfSemanticBranchingChecked = false;
55 mConfAtomicSemanticBranchingChecked = false;
56 mConfBranchTriggeringChecked = false;
57 mConfStrictIndiNodeProcessingChecked = false;
58 mConfIDIndiPriorizationChecked = false;
59 mConfPropagateNodeProcessedChecked = false;
60 mConfDirectRulePreprocessingChecked = false;
61 mConfLazyNewNominalCreationChecked = false;
62 mConfConsistenceRestrictedNonStictProcessingChecked = false;
63 mConfUniqueNameAssumptionChecked = false;
64
65 mConfSatisfiableExpansionCacheRetrievalChecked = false;
66 mConfSatisfiableExpansionCacheConceptExpansionChecked = false;
67 mConfSatisfiableExpansionCacheSatisfiableBlockingChecked = false;
68 mConfSatisfiableExpansionCacheWritingChecked = false;
69
70 mConfSignatureMirroringBlockingChecked = false;
71 mConfSignatureSavingChecked = false;
72 mConfSkipANDConceptsChecked = false;
73 mConfCompletionGraphCachingChecked = false;
74 mConfDelayedCompletionGraphCachingReactivationChecked = false;
75 mConfForceNodesRecreationForRepeatedIndividualProcessingChecked = false;
76 mConfAvoidRepeatedIndividualProcessingChecked = false;
77
78 mConfUnsatCachingUseNodeSignatureSetChecked = false;
79 mConfUnsatCachingUseFullNodeDependencyChecked = false;
80 mConfPairwiseMergingChecked = false;
81 mConfSaturationPilingChecked = false;
82 mConfCompGraphReuseCacheRetrievalChecked = false;
83 mConfCompGraphDeterministicReuseChecked = false;
84 mConfCompGraphNonDeterministicReuseChecked = false;
85 mConfAnywhereBlockingCoreConceptCandidateHashSearchChecked = false;
86 mConfRepresentativePropagationChecked = false;
87 mConfDebuggingWriteDataChecked = false;
88 mConfDebuggingWriteDataCompletionTasksChecked = false;
89 mConfDebuggingWriteDataSaturationTasksChecked = false;
90 mConfDebuggingWriteDataOnlyOnSatisfiabilityChecked = false;
91 mConfDebuggingWriteDataForConsistencyTestsChecked = false;
92 mConfDebuggingWriteDataForClassificationTestsChecked = false;
93 mConfDebuggingWriteDataForAnsweringPropagationTestsChecked = false;
94 mConfDebuggingWriteDataForIncrementalExpansionTestsChecked = false;
95 mConfDebuggingWriteDataForRepresentativeCacheRecomputationTestsChecked = false;
96 mConfDebuggingWriteDataForAllTestsChecked = false;
97
98 mConfSuccessorConceptSaturationExpansionChecked = false;
99 mConfSaturationCachingChecked = false;
100 mConfSaturationCriticalConceptTestingChecked = false;
101 mConfSaturationDirectCriticalToInsufficientChecked = false;
102 mConfSaturationSuccessorExtensionChecked = false;
103 mConfSaturationCachingWithNominalsByReactivationChecked = false;
104 mConfNominalSaturationChecked = false;
105 mEquivalentAlternativesSaturationMergingChecked = false;
106 mConfSaturationExpansionSatisfiabilityCacheWritingChecked = false;
107 mConfSaturationUnsatisfiabilityCacheWritingChecked = false;
108 mDatatypeReasoningChecked = false;
109 mComputedTypesCachingChecked = false;
110 mConstructionIndividualNodeMergingChecked = false;
111 mConfIndividualsBackendCacheLoadingChecked = false;
112
113 mSaturationReferredNodeManyConceptCountChecked = false;
114 mSaturationManyConceptReferredNodeCountProcessLimitChecked = false;
115 mSaturationReferredNodeConceptCountProcessLimitChecked = false;
116 mSaturationReferredNodeUnprocessedCountProcessLimitChecked = false;
117 mSaturationReferredNodeCheckingDepthChecked = false;
118 mConfForceManyConceptSaturationChecked = false;
119 mMaxRecProConceptCountChecked = false;
120
121 mNewMergingsBackendOnlyInferringNeighbourExpansionChecked = false;
122 mAllowBackendNeighbourExpansionBlockingChecked = false;
123 mAllowBackendSuccessorExpansionBlockingChecked = false;
124 mOccurrenceStatisticsCollectionChecked = false;
125 mGeneratingTestQueriesChecked = false;
126 mBlockingTestsIgnoringCompletionGraphCachedNonBlockedNodesChecked = false;
127
128 mBackendCriticalNeighbourRepresentativeExpansionDelayingChecked = false;
129 mBackendCriticalNeighbourExpansionLimitationChecked = false;
130 mBackendCriticalNeighbourExpansionReusingChecked = false;
131 mBackendCriticalNeighbourExpansionLateDynamicReusingChecked = false;
132 mBackendCriticalNeighbourExpansionLimitChecked = false;
133 mBackendExpansionLimitReachedReuseActivationChecked = false;
134 mBackendCriticalNeighbourExpansionPriorityReductionCountChecked = false;
135 mBackendCriticalNeighbourDirectExpansionLimitChecked = false;
136 mBackendCriticalNeighbourDirectExpansionOverCriticalReductionSizeChecked = false;
137 mBackendCriticalNeighbourExpansionIndividualsBatchSizeChecked = false;
138 mBackendCriticalNeighbourExpansionRolesBatchSizeChecked = false;
139 mBackendExpansionReuseActivationNeighbourIndividualCountChecked = false;
140 mBackendExpansionReuseActivationSameIndividualCountChecked = false;
141 mBackendDelayedSameInitializationCopyingChecked = false;
142 mDefaultIndividualPrecomputationCountChecked = false;
143
144 mBackendCardinalityNeighbourExpansionRepresentativeCountingChecked = false;
145 mBackendExpandDeterministicallyMergedHandledNeighboursChecked = false;
146
147 mBackendOnlyDeterministicRepresentativeIndividualDataConsiderationChecked = false;
148 }
149
150
151 CCalculationConfigurationExtension::CCalculationConfigurationExtension(CCalculationConfigurationExtension *previousLocalCalcExtension, CConfigurationBase *fixedCollectingConfiguration, qint64 configID)
152 : CLocalConfigurationFixedExtension(previousLocalCalcExtension,configID) {
153 addCollectedConfigurations(fixedCollectingConfiguration);
154 }
155
156 CCalculationConfigurationExtension::~CCalculationConfigurationExtension() {
157 }
158
159
160
161 bool CCalculationConfigurationExtension::isDependencyTrackingActivated() {
162 if (!mConfDependencyTrackingChecked) {
163 bool tmpConfig = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.DependencyTracking",true);
164 tmpConfig |= isBackjumpingActivated() | isSingleLevelUnsatisfiableCacheWritingActivated();
165 mConfDependencyTrackingActivated = tmpConfig;
166 mConfDependencyTrackingChecked = true;
167 }
168 return mConfDependencyTrackingActivated;
169 }
170
171 bool CCalculationConfigurationExtension::isBackjumpingActivated() {
172 if (!mConfBackjumpingChecked) {
173 mConfBackjumpingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.Backjumping",true);
174 mConfBackjumpingChecked = true;
175 }
176 return mConfBackjumpingActivated;
177 }
178
179 bool CCalculationConfigurationExtension::isSatisfiableCacheRetrievalActivated() {
180 if (!mConfSatCachingChecked) {
181 mConfSatCachingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.SatisfiableCacheRetrieval",true);
182 mConfSatCachingChecked = true;
183 }
184 return mConfSatCachingActivated;
185 }
186
187 bool CCalculationConfigurationExtension::isUnsatisfiableCacheRetrievalActivated() {
188 if (!mConfUnsatCachingChecked) {
189 mConfUnsatCachingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.UnsatisfiableCacheRetrieval",true);
190 mConfUnsatCachingChecked = true;
191 }
192 return mConfUnsatCachingActivated;
193 }
194
195 bool CCalculationConfigurationExtension::isProxyIndividualsActivated() {
196 if (!mConfProxyIndividualsChecked) {
197 mConfProxyIndividualsActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.ProxyIndividuals",true);
198 mConfProxyIndividualsChecked = true;
199 }
200 return mConfProxyIndividualsActivated;
201 }
202
203 bool CCalculationConfigurationExtension::isMinimizeMergingBranchesActivated() {
204 if (!mConfMinimizeMergingBranchesChecked) {
205 mConfMinimizeMergingBranchesActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.MinimizedMergingBranches",true);
206 mConfMinimizeMergingBranchesChecked = true;
207 }
208 return mConfMinimizeMergingBranchesActivated;
209 }
210
211 bool CCalculationConfigurationExtension::isSingleLevelUnsatisfiableCacheWritingActivated() {
212 if (!mConfUnsatCacheSingleLevelWritingChecked) {
213 mConfUnsatCacheSingleLevelWritingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.UnsatisfiableCacheSingleLevelWriting",true);
214 mConfUnsatCacheSingleLevelWritingChecked = true;
215 }
216 return mConfUnsatCacheSingleLevelWritingActivated;
217 }
218
219
220 bool CCalculationConfigurationExtension::isTestedConceptUnsatisfiableCacheWritingActivated() {
221 if (!mConfUnsatCacheTestedConceptWritingChecked) {
222 mConfUnsatCacheTestedConceptWritingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.UnsatisfiableCacheTestingConceptWriting",true);
223 mConfUnsatCacheTestedConceptWritingChecked = true;
224 }
225 return mConfUnsatCacheTestedConceptWritingActivated;
226 }
227
228 bool CCalculationConfigurationExtension::isSingleLevelSatisfiableCacheWritingActivated() {
229 if (!mConfSatCacheSingleLevelWritingChecked) {
230 mConfSatCacheSingleLevelWritingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.SatisfiableCacheSingleLevelWriting",true);
231 mConfSatCacheSingleLevelWritingChecked = true;
232 }
233 return mConfSatCacheSingleLevelWritingActivated;
234 }
235
236 bool CCalculationConfigurationExtension::isPseudoModelRuleEssentialCheckingActivated() {
237 if (!mConfPseudoModelRuleEssentialCheckingChecked) {
238 mConfPseudoModelRuleEssentialCheckingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.PseudoModelEssentialRuleChecking",true);
239 mConfPseudoModelRuleEssentialCheckingChecked = true;
240 }
241 return mConfPseudoModelRuleEssentialCheckingActivated;
242 }
243
244 bool CCalculationConfigurationExtension::isClassificationPseudoModelSubsumptionMergingActivated() {
245 if (!mConfClassPseudoModelSubsumptionMergingChecked) {
246 mConfClassPseudoModelSubsumptionMergingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.PseudoModelSubsumptionMerging",true);
247 mConfClassPseudoModelSubsumptionMergingChecked = true;
248 }
249 return mConfClassPseudoModelSubsumptionMergingActivated;
250 }
251
252
253 bool CCalculationConfigurationExtension::isSpecializedAutomateRuleActivated() {
254 if (!mConfSpecializedAutomateRuleChecked) {
255 mConfSpecializedAutomateRuleActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.SpezializedAutomateRule",true);
256 mConfSpecializedAutomateRuleChecked = true;
257 }
258 return mConfSpecializedAutomateRuleActivated;
259 }
260
261
262
263 bool CCalculationConfigurationExtension::isSubSetBlockingActivated() {
264 if (!mConfSubSetBlockingChecked) {
265 mConfSubSetBlockingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.SubSetBlockingTest",false);
266 mConfSubSetBlockingChecked = true;
267 }
268 return mConfSubSetBlockingActivated;
269 }
270
271 bool CCalculationConfigurationExtension::isOptimizedBlockingActivated() {
272 if (!mConfOptimizedBlockingChecked) {
273 mConfOptimizedBlockingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.OptimizedBlockingTest",true);
274 if (!isSubSetBlockingActivated() && !isEqualSetBlockingActivated() && !isPairwiseEqualSetBlockingActivated()) {
275 mConfOptimizedBlockingActivated = true;
276 }
277 mConfOptimizedBlockingChecked = true;
278 }
279 return mConfOptimizedBlockingActivated;
280 }
281
282 bool CCalculationConfigurationExtension::isEqualSetBlockingActivated() {
283 if (!mConfEqualSetBlockingChecked) {
284 mConfEqualSetBlockingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.EqualSetBlockingTest",false);
285 mConfEqualSetBlockingChecked = true;
286 }
287 return mConfEqualSetBlockingActivated;
288 }
289
290 bool CCalculationConfigurationExtension::isPairwiseEqualSetBlockingActivated() {
291 if (!mConfPairwiseEqualSetBlockingChecked) {
292 mConfPairwiseEqualSetBlockingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.PairwiseEqualSetBlockingTest",false);
293 mConfPairwiseEqualSetBlockingChecked = true;
294 }
295 return mConfPairwiseEqualSetBlockingActivated;
296 }
297
298 bool CCalculationConfigurationExtension::isAncestorBlockingSearchActivated() {
299 if (!mConfAncestorBlockingSearchChecked) {
300 mConfAncestorBlockingSearchActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.AncestorBlockingSearch",false);
301 if (!isAnywhereBlockingSearchActivated() && !isAnywhereBlockingCandidateHashSearchActivated() && !isAnywhereBlockingCoreConceptCandidateHashSearchActivated()) {
302 mConfAncestorBlockingSearchActivated = true;
303 }
304 mConfAncestorBlockingSearchChecked = true;
305 }
306 return mConfAncestorBlockingSearchActivated;
307 }
308
309 bool CCalculationConfigurationExtension::isAnywhereBlockingSearchActivated() {
310 if (!mConfAnywhereBlockingSearchChecked) {
311 mConfAnywhereBlockingSearchActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.AnywhereBlockingSearch",false);
312 mConfAnywhereBlockingSearchChecked = true;
313 }
314 return mConfAnywhereBlockingSearchActivated;
315 }
316
317 bool CCalculationConfigurationExtension::isAnywhereBlockingCandidateHashSearchActivated() {
318 if (!mConfAnywhereBlockingCandidateHashSearchChecked) {
319 mConfAnywhereBlockingCandidateHashSearchActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.AnywhereCandidateHashBlockingSearch",true);
320 mConfAnywhereBlockingCandidateHashSearchChecked = true;
321 }
322 return mConfAnywhereBlockingCandidateHashSearchActivated;
323 }
324
325 bool CCalculationConfigurationExtension::isSemanticBranchingActivated() {
326 if (!mConfSemanticBranchingChecked) {
327 mConfSemanticBranchingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.SemanticBranching",false);
328 mConfSemanticBranchingChecked = true;
329 }
330 return mConfSemanticBranchingActivated;
331 }
332
333 bool CCalculationConfigurationExtension::isAtomicSemanticBranchingActivated() {
334 if (!mConfAtomicSemanticBranchingChecked) {
335 mConfAtomicSemanticBranchingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.AtomicSemanticBranching",true);
336 mConfAtomicSemanticBranchingChecked = true;
337 }
338 return mConfAtomicSemanticBranchingActivated;
339 }
340
341 bool CCalculationConfigurationExtension::isBranchTriggeringActivated() {
342 if (!mConfBranchTriggeringChecked) {
343 mConfBranchTriggeringActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.BranchTriggering",true);
344 mConfBranchTriggeringChecked = true;
345 }
346 return mConfBranchTriggeringActivated;
347 }
348
349 bool CCalculationConfigurationExtension::isStrictIndiNodeProcessingActivated() {
350 if (!mConfStrictIndiNodeProcessingChecked) {
351 mConfStrictIndiNodeProcessingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.StrictIndividualNodeProcessingOrder",true);
352 mConfStrictIndiNodeProcessingChecked = true;
353 }
354 return mConfStrictIndiNodeProcessingActivated;
355 }
356
357 bool CCalculationConfigurationExtension::isIDIndiPriorizationActivated() {
358 if (!mConfIDIndiPriorizationChecked) {
359 mConfIDIndiPriorizationActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.IndividualNodeIDPriorization",true);
360 mConfIDIndiPriorizationChecked = true;
361 }
362 return mConfIDIndiPriorizationActivated;
363 }
364
365 bool CCalculationConfigurationExtension::isPropagateNodeProcessedActivated() {
366 if (!mConfPropagateNodeProcessedChecked) {
367 mConfPropagateNodeProcessedActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.ProcessedIndividualNodePropagation",false);
368 if (!isStrictIndiNodeProcessingActivated()) {
369 mConfPropagateNodeProcessedActivated = true;
370 }
371 mConfPropagateNodeProcessedChecked = true;
372 }
373 return mConfPropagateNodeProcessedActivated;
374 }
375
376
377 bool CCalculationConfigurationExtension::isDirectRulePreprocessingActivated() {
378 if (!mConfDirectRulePreprocessingChecked) {
379 mConfDirectRulePreprocessingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.DirectRulePreprocessing",true);
380 mConfDirectRulePreprocessingChecked = true;
381 }
382 return mConfDirectRulePreprocessingActivated;
383 }
384
385
386 bool CCalculationConfigurationExtension::isLazyNewNominalCreationActivated() {
387 if (!mConfLazyNewNominalCreationChecked) {
388 mConfLazyNewNominalCreationActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.LazyNewMergingNominalCreation",true);
389 mConfLazyNewNominalCreationChecked = true;
390 }
391 return mConfLazyNewNominalCreationActivated;
392 }
393
394 bool CCalculationConfigurationExtension::isConsistenceRestrictedNonStictProcessingActivated() {
395 if (!mConfConsistenceRestrictedNonStictProcessingChecked) {
396 mConfConsistenceRestrictedNonStictProcessingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.ConsistenceRestrictedNonStrictProcessing",true);
397 mConfConsistenceRestrictedNonStictProcessingChecked = true;
398 }
399 return mConfConsistenceRestrictedNonStictProcessingActivated;
400 }
401
402 bool CCalculationConfigurationExtension::isUniqueNameAssumptionActivated() {
403 if (!mConfUniqueNameAssumptionChecked) {
404 mConfUniqueNameAssumptionActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.UniqueNameAssumption",false);
405 mConfUniqueNameAssumptionChecked = true;
406 }
407 return mConfUniqueNameAssumptionActivated;
408 }
409
410 bool CCalculationConfigurationExtension::isSatisfiableExpansionCacheRetrievalActivated() {
411 if (!mConfSatisfiableExpansionCacheRetrievalChecked) {
412 mConfSatisfiableExpansionCacheRetrievalActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.SatisfiableExpansionCacheRetrieval",true);
413 mConfSatisfiableExpansionCacheRetrievalChecked = true;
414 }
415 return mConfSatisfiableExpansionCacheRetrievalActivated;
416 }
417
418 bool CCalculationConfigurationExtension::isSatisfiableExpansionCacheConceptExpansionActivated() {
419 if (!mConfSatisfiableExpansionCacheConceptExpansionChecked) {
420 mConfSatisfiableExpansionCacheConceptExpansionActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.SatisfiableExpansionCacheConceptExpansion",true);
421 mConfSatisfiableExpansionCacheConceptExpansionChecked = true;
422 }
423 return mConfSatisfiableExpansionCacheConceptExpansionActivated;
424 }
425
426 bool CCalculationConfigurationExtension::isSatisfiableExpansionCacheSatisfiableBlockingActivated() {
427 if (!mConfSatisfiableExpansionCacheSatisfiableBlockingChecked) {
428 mConfSatisfiableExpansionCacheSatisfiableBlockingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.SatisfiableExpansionCacheSatisfiableBlocking",true);
429 mConfSatisfiableExpansionCacheSatisfiableBlockingChecked = true;
430 }
431 return mConfSatisfiableExpansionCacheSatisfiableBlockingActivated;
432 }
433
434 bool CCalculationConfigurationExtension::isSatisfiableExpansionCacheWritingActivated() {
435 if (!mConfSatisfiableExpansionCacheWritingChecked) {
436 mConfSatisfiableExpansionCacheWritingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.SatisfiableExpansionCacheWriting",true);
437 mConfSatisfiableExpansionCacheWritingChecked = true;
438 }
439 return mConfSatisfiableExpansionCacheWritingActivated;
440 }
441
442 bool CCalculationConfigurationExtension::isSignatureMirroringBlockingActivated() {
443 if (!mConfSignatureMirroringBlockingChecked) {
444 mConfSignatureMirroringBlockingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.SignatureMirroringBlocking",true);
445 mConfSignatureMirroringBlockingChecked = true;
446 }
447 return mConfSignatureMirroringBlockingActivated;
448 }
449
450 bool CCalculationConfigurationExtension::isSignatureSavingActivated() {
451 if (!mConfSignatureSavingChecked) {
452 mConfSignatureSavingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.SignatureSaving",true);
453 mConfSignatureSavingChecked = true;
454 }
455 return mConfSignatureSavingActivated;
456 }
457
458 bool CCalculationConfigurationExtension::isSkipANDConceptsActivated() {
459 if (!mConfSkipANDConceptsChecked) {
460 mConfSkipANDConceptsActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.ANDConceptSkipping",false);
461 mConfSkipANDConceptsChecked = true;
462 }
463 return mConfSkipANDConceptsActivated;
464 }
465
466 bool CCalculationConfigurationExtension::isCompletionGraphCachingActivated() {
467 if (!mConfCompletionGraphCachingChecked) {
468 mConfCompletionGraphCachingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.CompletionGraphCaching",true);
469 mConfCompletionGraphCachingChecked = true;
470 }
471 return mConfCompletionGraphCachingActivated;
472 }
473
474
475
476 bool CCalculationConfigurationExtension::isDelayedCompletionGraphCachingReactivationActivated() {
477 if (!mConfDelayedCompletionGraphCachingReactivationChecked) {
478 mConfDelayedCompletionGraphCachingReactivationActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.DelayedCompletionGraphCachingReactivation",false);
479 mConfDelayedCompletionGraphCachingReactivationChecked = true;
480 }
481 return mConfDelayedCompletionGraphCachingReactivationActivated;
482 }
483
484
485
486 bool CCalculationConfigurationExtension::isForceNodesRecreationForRepeatedIndividualProcessingActivated() {
487 if (!mConfForceNodesRecreationForRepeatedIndividualProcessingChecked) {
488 mConfForceNodesRecreationForRepeatedIndividualProcessingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.ForceNodesRecreationForRepeatedIndividualProcessing",true);
489 mConfForceNodesRecreationForRepeatedIndividualProcessingChecked = true;
490 }
491 return mConfForceNodesRecreationForRepeatedIndividualProcessingActivated;
492 }
493
494
495
496
497
498 bool CCalculationConfigurationExtension::isAvoidRepeatedIndividualProcessingActivated() {
499 if (!mConfAvoidRepeatedIndividualProcessingChecked) {
500 mConfAvoidRepeatedIndividualProcessingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.AvoidRepeatedIndividualProcessing",true);
501 mConfAvoidRepeatedIndividualProcessingChecked = true;
502 }
503 return mConfAvoidRepeatedIndividualProcessingActivated;
504 }
505
506
507
508
509
510
511
512 bool CCalculationConfigurationExtension::isIndividualsBackendCacheLoadingActivated() {
513 if (!mConfIndividualsBackendCacheLoadingChecked) {
514 mConfIndividualsBackendCacheLoadingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.IndividualsBackendCacheLoading",true);
515 mConfIndividualsBackendCacheLoadingChecked = true;
516 }
517 return mConfIndividualsBackendCacheLoadingActivated;
518 }
519
520
521
522
523
524 bool CCalculationConfigurationExtension::isUnsatisfiableCachingFullDependencyActivated() {
525 if (!mConfUnsatCachingUseFullNodeDependencyChecked) {
526 mConfUnsatCachingUseFullNodeDependencyActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.UnsatisfiableCachingFullDependency",false);
527 mConfUnsatCachingUseFullNodeDependencyChecked = true;
528 }
529 return mConfUnsatCachingUseFullNodeDependencyActivated;
530 }
531
532 bool CCalculationConfigurationExtension::isUnsatisfiableCachingFullSignatureActivated() {
533 if (!mConfUnsatCachingUseNodeSignatureSetChecked) {
534 mConfUnsatCachingUseNodeSignatureSetActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.UnsatisfiableCachingFullSignature",false);
535 mConfUnsatCachingUseNodeSignatureSetChecked = true;
536 }
537 return mConfUnsatCachingUseNodeSignatureSetActivated;
538 }
539
540 bool CCalculationConfigurationExtension::isPairwiseMergingActivated() {
541 if (!mConfPairwiseMergingChecked) {
542 mConfPairwiseMergingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.PairwiseMerging",false);
543 mConfPairwiseMergingChecked = true;
544 }
545 return mConfPairwiseMergingActivated;
546 }
547
548 bool CCalculationConfigurationExtension::isSaturationPilingActivated() {
549 if (!mConfSaturationPilingChecked) {
550 mConfSaturationPilingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.SaturationPiling",false);
551 mConfSaturationPilingChecked = true;
552 }
553 return mConfSaturationPilingActivated;
554 }
555
556
557
558 bool CCalculationConfigurationExtension::isCompletionGraphReuseCachingRetrievalActivated() {
559 if (!mConfCompGraphReuseCacheRetrievalChecked) {
560 mConfCompGraphReuseCacheRetrievalActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.CompletionGraphReuseCachingRetrieval",true);
561 mConfCompGraphReuseCacheRetrievalChecked = true;
562 }
563 return mConfCompGraphReuseCacheRetrievalActivated;
564 }
565
566
567 bool CCalculationConfigurationExtension::isCompletionGraphDeterministicReuseActivated() {
568 if (!mConfCompGraphDeterministicReuseChecked) {
569 mConfCompGraphDeterministicReuseActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.CompletionGraphDeterministicReuse",true);
570 mConfCompGraphDeterministicReuseChecked = true;
571 }
572 return mConfCompGraphDeterministicReuseActivated;
573 }
574
575
576 bool CCalculationConfigurationExtension::isCompletionGraphNonDeterministicReuseActivated() {
577 if (!mConfCompGraphNonDeterministicReuseChecked) {
578 mConfCompGraphNonDeterministicReuseActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.CompletionGraphNonDeterministicReuse",true);
579 mConfCompGraphNonDeterministicReuseChecked = true;
580 }
581 return mConfCompGraphNonDeterministicReuseActivated;
582 }
583
584
585 bool CCalculationConfigurationExtension::isAnywhereBlockingCoreConceptCandidateHashSearchActivated() {
586 if (!mConfAnywhereBlockingCoreConceptCandidateHashSearchChecked) {
587 mConfAnywhereBlockingCoreConceptCandidateHashSearchActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.AnywhereCoreConceptCandidateHashBlockingSearch",true);
588 mConfAnywhereBlockingCoreConceptCandidateHashSearchChecked = true;
589 }
590 return mConfAnywhereBlockingCoreConceptCandidateHashSearchActivated;
591 }
592
593
594 bool CCalculationConfigurationExtension::isRepresentativePropagationActivated() {
595 if (!mConfRepresentativePropagationChecked) {
596 mConfRepresentativePropagationActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.RepresentativePropagation",true);
597 mConfRepresentativePropagationChecked = true;
598 }
599 return mConfRepresentativePropagationActivated;
600 }
601
602
603 bool CCalculationConfigurationExtension::isDebuggingWriteDataActivated() {
604 if (!mConfDebuggingWriteDataChecked) {
605 mConfDebuggingWriteDataActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Debugging.WriteDebuggingData",false);
606 mConfDebuggingWriteDataChecked = true;
607 }
608 return mConfDebuggingWriteDataActivated;
609 }
610
611 bool CCalculationConfigurationExtension::isDebuggingWriteDataSaturationTasksActivated() {
612 if (!mConfDebuggingWriteDataSaturationTasksChecked) {
613 mConfDebuggingWriteDataSaturationTasksActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Debugging.WriteDebuggingDataSaturationTasks", false);
614 mConfDebuggingWriteDataSaturationTasksChecked = true;
615 }
616 return mConfDebuggingWriteDataSaturationTasksActivated;
617 }
618
619 bool CCalculationConfigurationExtension::isDebuggingWriteDataCompletionTasksActivated() {
620 if (!mConfDebuggingWriteDataCompletionTasksChecked) {
621 mConfDebuggingWriteDataCompletionTasksActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Debugging.WriteDebuggingDataCompletionTasks", false);
622 mConfDebuggingWriteDataCompletionTasksChecked = true;
623 }
624 return mConfDebuggingWriteDataCompletionTasksActivated;
625 }
626
627
628
629 bool CCalculationConfigurationExtension::isDebuggingWriteDataCompletionTasksOnlyOnSatisfiabilityActivated() {
630 if (!mConfDebuggingWriteDataOnlyOnSatisfiabilityChecked) {
631 mConfDebuggingWriteDataOnlyOnSatisfiabilityActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Debugging.WriteDebuggingDataCompletionTasksOnlyOnSatisfiability", false);
632 mConfDebuggingWriteDataOnlyOnSatisfiabilityChecked = true;
633 }
634 return mConfDebuggingWriteDataOnlyOnSatisfiabilityActivated;
635 }
636
637
638 bool CCalculationConfigurationExtension::isDebuggingWriteDataCompletionTasksForConsistencyTestsActivated() {
639 if (!mConfDebuggingWriteDataForConsistencyTestsChecked) {
640 mConfDebuggingWriteDataForConsistencyTestsActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Debugging.WriteDebuggingDataCompletionTasksForConsistencyTests", false);
641 mConfDebuggingWriteDataForConsistencyTestsChecked = true;
642 }
643 return mConfDebuggingWriteDataForConsistencyTestsActivated;
644 }
645
646
647 bool CCalculationConfigurationExtension::isDebuggingWriteDataCompletionTasksForClassificationTestsActivated() {
648 if (!mConfDebuggingWriteDataForClassificationTestsChecked) {
649 mConfDebuggingWriteDataForClassificationTestsActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Debugging.WriteDebuggingDataCompletionTasksForClassificationTests", false);
650 mConfDebuggingWriteDataForClassificationTestsChecked = true;
651 }
652 return mConfDebuggingWriteDataForClassificationTestsActivated;
653 }
654
655
656 bool CCalculationConfigurationExtension::isDebuggingWriteDataCompletionTasksForAnsweringPropagationTestsActivated() {
657 if (!mConfDebuggingWriteDataForAnsweringPropagationTestsChecked) {
658 mConfDebuggingWriteDataForAnsweringPropagationTestsActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Debugging.WriteDebuggingDataCompletionTasksForAnsweringPropagationTests", false);
659 mConfDebuggingWriteDataForAnsweringPropagationTestsChecked = true;
660 }
661 return mConfDebuggingWriteDataForAnsweringPropagationTestsActivated;
662 }
663
664 bool CCalculationConfigurationExtension::isDebuggingWriteDataCompletionTasksForIncrementalExpansionTestsActivated() {
665 if (!mConfDebuggingWriteDataForIncrementalExpansionTestsChecked) {
666 mConfDebuggingWriteDataForIncrementalExpansionTestsActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Debugging.WriteDebuggingDataCompletionTasksForIncrementalExpansionTests", false);
667 mConfDebuggingWriteDataForIncrementalExpansionTestsChecked = true;
668 }
669 return mConfDebuggingWriteDataForIncrementalExpansionTestsActivated;
670 }
671
672 bool CCalculationConfigurationExtension::isDebuggingWriteDataCompletionTasksForRepresentativeCacheRecomputationTestsActivated() {
673 if (!mConfDebuggingWriteDataForRepresentativeCacheRecomputationTestsChecked) {
674 mConfDebuggingWriteDataForRepresentativeCacheRecomputationTestsActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Debugging.WriteDebuggingDataCompletionTasksForRepresentativeCacheRecomputationTests", false);
675 mConfDebuggingWriteDataForRepresentativeCacheRecomputationTestsChecked = true;
676 }
677 return mConfDebuggingWriteDataForRepresentativeCacheRecomputationTestsActivated;
678 }
679
680 bool CCalculationConfigurationExtension::isDebuggingWriteDataCompletionTasksForAllTestsActivated() {
681 if (!mConfDebuggingWriteDataForAllTestsChecked) {
682 mConfDebuggingWriteDataForAllTestsActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Debugging.WriteDebuggingDataForAllTests", false);
683 mConfDebuggingWriteDataForAllTestsChecked = true;
684 }
685 return mConfDebuggingWriteDataForAllTestsActivated;
686 }
687
688
689
690
691
692
693
694
695
696
697
698 bool CCalculationConfigurationExtension::isSuccessorConceptSaturationExpansionActivated() {
699 if (!mConfSuccessorConceptSaturationExpansionChecked) {
700 mConfSuccessorConceptSaturationExpansionActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.SuccessorConceptSaturationExpansion",true);
701 mConfSuccessorConceptSaturationExpansionChecked = true;
702 }
703 return mConfSuccessorConceptSaturationExpansionActivated;
704 }
705
706
707 bool CCalculationConfigurationExtension::isSaturationCachingActivated() {
708 if (!mConfSaturationCachingChecked) {
709 mConfSaturationCachingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.SaturationCaching",true);
710 mConfSaturationCachingChecked = true;
711 }
712 return mConfSaturationCachingActivated;
713 }
714
715
716 bool CCalculationConfigurationExtension::isSaturationCriticalConceptTestingActivated() {
717 if (!mConfSaturationCriticalConceptTestingChecked) {
718 mConfSaturationCriticalConceptTestingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.SaturationCriticalConceptTesting",true);
719 mConfSaturationCriticalConceptTestingChecked = true;
720 }
721 return mConfSaturationCriticalConceptTestingActivated;
722 }
723
724
725 bool CCalculationConfigurationExtension::isSaturationDirectCriticalToInsufficientActivated() {
726 if (!mConfSaturationDirectCriticalToInsufficientChecked) {
727 mConfSaturationDirectCriticalToInsufficientActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.SaturationDirectCriticalToInsufficient",false);
728 mConfSaturationDirectCriticalToInsufficientChecked = true;
729 }
730 return mConfSaturationDirectCriticalToInsufficientActivated;
731 }
732
733
734 bool CCalculationConfigurationExtension::isSaturationSuccessorExtensionActivated() {
735 if (!mConfSaturationSuccessorExtensionChecked) {
736 mConfSaturationSuccessorExtensionActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.SaturationSuccessorExtension",false);
737 mConfSaturationSuccessorExtensionChecked = true;
738 }
739 return mConfSaturationSuccessorExtensionActivated;
740 }
741
742
743 bool CCalculationConfigurationExtension::isSaturationCachingWithNominalsByReactivationActivated() {
744 if (!mConfSaturationCachingWithNominalsByReactivationChecked) {
745 mConfSaturationCachingWithNominalsByReactivationActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.NominalSaturationCachingByNodeReactivation",false);
746 mConfSaturationCachingWithNominalsByReactivationChecked = true;
747 }
748 return mConfSaturationCachingWithNominalsByReactivationActivated;
749 }
750
751
752 bool CCalculationConfigurationExtension::isNominalSaturationActivated() {
753 if (!mConfNominalSaturationChecked) {
754 mConfNominalSaturationActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.NominalSaturation",true);
755 mConfNominalSaturationChecked = true;
756 }
757 return mConfNominalSaturationActivated;
758 }
759
760
761 bool CCalculationConfigurationExtension::isEquivalentAlternativesSaturationMergingActivated() {
762 if (!mEquivalentAlternativesSaturationMergingChecked) {
763 mEquivalentAlternativesSaturationMergingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.EquivalentAlternativesSaturationMerging",true);
764 mEquivalentAlternativesSaturationMergingChecked = true;
765 }
766 return mEquivalentAlternativesSaturationMergingActivated;
767 }
768
769
770 bool CCalculationConfigurationExtension::isSaturationExpansionSatisfiabilityCacheWritingActivated() {
771 if (!mConfSaturationExpansionSatisfiabilityCacheWritingChecked) {
772 mConfSaturationExpansionSatisfiabilityCacheWritingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.SaturationExpansionSatisfiabilityCacheWriting",true);
773 mConfSaturationExpansionSatisfiabilityCacheWritingChecked = true;
774 }
775 return mConfSaturationExpansionSatisfiabilityCacheWritingActivated;
776 }
777
778 bool CCalculationConfigurationExtension::isSaturationUnsatisfiabilityCacheWritingActivated() {
779 if (!mConfSaturationUnsatisfiabilityCacheWritingChecked) {
780 mConfSaturationUnsatisfiabilityCacheWritingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.SaturationExpansionSatisfiabilityCacheWriting",true);
781 mConfSaturationUnsatisfiabilityCacheWritingChecked = true;
782 }
783 return mConfSaturationUnsatisfiabilityCacheWritingActivated;
784 }
785
786
787 bool CCalculationConfigurationExtension::isDatatypeReasoningActivated() {
788 if (!mDatatypeReasoningChecked) {
789 mDatatypeReasoningActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.ComputedTypesCaching",true);
790 mDatatypeReasoningChecked = true;
791 }
792 return mDatatypeReasoningActivated;
793 }
794
795
796 bool CCalculationConfigurationExtension::isComputedTypesCachingActivated() {
797 if (!mComputedTypesCachingChecked) {
798 mComputedTypesCachingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.DatatypeReasoning",true);
799 mComputedTypesCachingChecked = true;
800 }
801 return mComputedTypesCachingActivated;
802 }
803
804
805
806 bool CCalculationConfigurationExtension::isConstructionIndividualNodeMergingActivated() {
807 if (!mConstructionIndividualNodeMergingChecked) {
808 mConstructionIndividualNodeMergingActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.ConstructionIndividualNodeMerging",true);
809 mConstructionIndividualNodeMergingChecked = true;
810 }
811 return mConstructionIndividualNodeMergingActivated;
812 }
813
814
815
816
817 cint64 CCalculationConfigurationExtension::getMaximumRecursiveProcessingConceptCount() {
818 if (!mMaxRecProConceptCountChecked) {
819 mMaxRecProConceptCount = CConfigDataReader::readConfigInteger(this,"Konclude.Calculation.MaximumRecursiveProcessingConceptCount",true);
820 mMaxRecProConceptCountChecked = true;
821 }
822 return mMaxRecProConceptCount;
823 }
824
825
826
827 cint64 CCalculationConfigurationExtension::getSaturationReferredNodeManyConceptCount() {
828 if (!mSaturationReferredNodeManyConceptCountChecked) {
829 mSaturationReferredNodeManyConceptCount = CConfigDataReader::readConfigInteger(this,"Konclude.Calculation.Optimization.SaturationReferredNodeManyConceptCount",true);
830 mSaturationReferredNodeManyConceptCountChecked = true;
831 }
832 return mSaturationReferredNodeManyConceptCount;
833 }
834
835 cint64 CCalculationConfigurationExtension::getSaturationManyConceptReferredNodeCountProcessLimit() {
836 if (!mSaturationManyConceptReferredNodeCountProcessLimitChecked) {
837 mSaturationManyConceptReferredNodeCountProcessLimit = CConfigDataReader::readConfigInteger(this,"Konclude.Calculation.Optimization.SaturationManyConceptReferredNodeCountProcessLimit",true);
838 mSaturationManyConceptReferredNodeCountProcessLimitChecked = true;
839 }
840 return mSaturationManyConceptReferredNodeCountProcessLimit;
841 }
842
843 cint64 CCalculationConfigurationExtension::getSaturationReferredNodeConceptCountProcessLimit() {
844 if (!mSaturationReferredNodeConceptCountProcessLimitChecked) {
845 mSaturationReferredNodeConceptCountProcessLimit = CConfigDataReader::readConfigInteger(this,"Konclude.Calculation.Optimization.SaturationReferredNodeConceptCountProcessLimit",true);
846 mSaturationReferredNodeConceptCountProcessLimitChecked = true;
847 }
848 return mSaturationReferredNodeConceptCountProcessLimit;
849 }
850
851 cint64 CCalculationConfigurationExtension::getSaturationReferredNodeUnprocessedCountProcessLimit() {
852 if (!mSaturationReferredNodeUnprocessedCountProcessLimitChecked) {
853 mSaturationReferredNodeUnprocessedCountProcessLimit = CConfigDataReader::readConfigInteger(this,"Konclude.Calculation.Optimization.SaturationReferredNodeUnprocessedCountProcessLimit",true);
854 mSaturationReferredNodeUnprocessedCountProcessLimitChecked = true;
855 }
856 return mSaturationReferredNodeUnprocessedCountProcessLimit;
857 }
858
859 cint64 CCalculationConfigurationExtension::getSaturationReferredNodeCheckingDepth() {
860 if (!mSaturationReferredNodeCheckingDepthChecked) {
861 mSaturationReferredNodeCheckingDepth = CConfigDataReader::readConfigInteger(this,"Konclude.Calculation.Optimization.SaturationReferredNodeCheckingDepth",true);
862 mSaturationReferredNodeCheckingDepthChecked = true;
863 }
864 return mSaturationReferredNodeCheckingDepth;
865 }
866
867
868 bool CCalculationConfigurationExtension::isForceManyConceptSaturationActivated() {
869 if (!mConfForceManyConceptSaturationChecked) {
870 mConfForceManyConceptSaturationActivated = CConfigDataReader::readConfigBoolean(this,"Konclude.Calculation.Optimization.ForceManyConceptNodeSaturation",true);
871 mConfForceManyConceptSaturationChecked = true;
872 }
873 return mConfForceManyConceptSaturationActivated;
874 }
875
876
877 bool CCalculationConfigurationExtension::isAllowBackendNeighbourExpansionBlockingActivated() {
878 if (!mAllowBackendNeighbourExpansionBlockingChecked) {
879 mAllowBackendNeighbourExpansionBlockingActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Calculation.Optimization.AllowBackendNeighbourExpansionBlocking", true);
880 mAllowBackendNeighbourExpansionBlockingChecked = true;
881 }
882 return mAllowBackendNeighbourExpansionBlockingActivated;
883 }
884
885 bool CCalculationConfigurationExtension::isNewMergingsBackendOnlyInferringNeighbourExpansionActivated() {
886 if (!mNewMergingsBackendOnlyInferringNeighbourExpansionChecked) {
887 mNewMergingsBackendOnlyInferringNeighbourExpansionActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Calculation.Optimization.NewMergingsBackendOnlyInferringNeighbourExpansion", true);
888 mNewMergingsBackendOnlyInferringNeighbourExpansionChecked = true;
889 }
890 return mNewMergingsBackendOnlyInferringNeighbourExpansionActivated;
891 }
892
893 bool CCalculationConfigurationExtension::isAllowBackendSuccessorExpansionBlockingActivated() {
894 if (!mAllowBackendSuccessorExpansionBlockingChecked) {
895 mAllowBackendSuccessorExpansionBlockingActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Calculation.Optimization.AllowBackendSuccessorExpansionBlocking", true);
896 mAllowBackendSuccessorExpansionBlockingChecked = true;
897 }
898 return mAllowBackendSuccessorExpansionBlockingActivated;
899 }
900
901
902 bool CCalculationConfigurationExtension::isOccurrenceStatisticsCollectionActivated() {
903 if (!mOccurrenceStatisticsCollectionChecked) {
904 mOccurrenceStatisticsCollectionActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Calculation.Optimization.OccurrenceStatisticsCollecting", true);
905 mOccurrenceStatisticsCollectionChecked = true;
906 }
907 return mOccurrenceStatisticsCollectionActivated;
908 }
909
910
911 bool CCalculationConfigurationExtension::isGeneratingTestQueriesActivated() {
912 if (!mGeneratingTestQueriesChecked) {
913 mGeneratingTestQueriesActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Test.ConjunctiveQueryGeneration.CompletionGraphRandomWalks", true);
914 mGeneratingTestQueriesChecked = true;
915 }
916 return mGeneratingTestQueriesActivated;
917 }
918
919 bool CCalculationConfigurationExtension::isBlockingTestsIgnoringCompletionGraphCachedNonBlockedNodesActivated() {
920 if (!mBlockingTestsIgnoringCompletionGraphCachedNonBlockedNodesChecked) {
921 mBlockingTestsIgnoringCompletionGraphCachedNonBlockedNodesActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Calculation.Optimization.BlockingTestsIgnoringCompletionGraphCachedNonBlockedNodes", true);
922 mBlockingTestsIgnoringCompletionGraphCachedNonBlockedNodesChecked = true;
923 }
924 return mBlockingTestsIgnoringCompletionGraphCachedNonBlockedNodesActivated;
925 }
926
927
928
929
930
931 bool CCalculationConfigurationExtension::isBackendCriticalNeighbourRepresentativeExpansionDelayingActivated() {
932 if (!mBackendCriticalNeighbourRepresentativeExpansionDelayingChecked) {
933 mBackendCriticalNeighbourRepresentativeExpansionDelayingActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Calculation.Optimization.BackendCriticalNeighbourRepresentativeExpansionDelaying", true);
934 mBackendCriticalNeighbourRepresentativeExpansionDelayingChecked = true;
935 }
936 return mBackendCriticalNeighbourRepresentativeExpansionDelayingActivated;
937 }
938
939
940 bool CCalculationConfigurationExtension::isBackendCriticalNeighbourExpansionLimitationActivated() {
941 if (!mBackendCriticalNeighbourExpansionLimitationChecked) {
942 mBackendCriticalNeighbourExpansionLimitationActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Calculation.Optimization.BackendCriticalNeighbourExpansionLimitation", true);
943 mBackendCriticalNeighbourExpansionLimitationChecked = true;
944 }
945 return mBackendCriticalNeighbourExpansionLimitationActivated;
946 }
947
948
949 bool CCalculationConfigurationExtension::isBackendCriticalNeighbourExpansionReusingActivated() {
950 if (!mBackendCriticalNeighbourExpansionReusingChecked) {
951 mBackendCriticalNeighbourExpansionReusingActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Calculation.Optimization.BackendCriticalNeighbourExpansionReusing", false);
952 mBackendCriticalNeighbourExpansionReusingChecked = true;
953 }
954 return mBackendCriticalNeighbourExpansionReusingActivated;
955 }
956
957 bool CCalculationConfigurationExtension::isBackendCriticalNeighbourExpansionLateDynamicReusingActivated() {
958 if (!mBackendCriticalNeighbourExpansionLateDynamicReusingChecked) {
959 mBackendCriticalNeighbourExpansionLateDynamicReusingActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Calculation.Optimization.BackendCriticalNeighbourExpansionLateDynamicReusing", false);
960 mBackendCriticalNeighbourExpansionLateDynamicReusingChecked = true;
961 }
962 return mBackendCriticalNeighbourExpansionLateDynamicReusingActivated;
963 }
964
965 bool CCalculationConfigurationExtension::isBackendExpansionLimitReachedReuseActivationActivated() {
966 if (!mBackendExpansionLimitReachedReuseActivationChecked) {
967 mBackendExpansionLimitReachedReuseActivationActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Calculation.Optimization.BackendExpansionLimitReachedReuseActivation", true);
968 mBackendExpansionLimitReachedReuseActivationChecked = true;
969 }
970 return mBackendExpansionLimitReachedReuseActivationActivated;
971 }
972
973
974 cint64 CCalculationConfigurationExtension::getBackendCriticalNeighbourExpansionLimit() {
975 if (!mBackendCriticalNeighbourExpansionLimitChecked) {
976 mBackendCriticalNeighbourExpansionLimit = CConfigDataReader::readConfigInteger(this, "Konclude.Calculation.Optimization.BackendCriticalNeighbourExpansionLimit", 15000);
977 mBackendCriticalNeighbourExpansionLimitChecked = true;
978 }
979 return mBackendCriticalNeighbourExpansionLimit;
980 }
981
982 cint64 CCalculationConfigurationExtension::getDefaultIndividualPrecomputationCount() {
983 if (!mDefaultIndividualPrecomputationCountChecked) {
984 mDefaultIndividualPrecomputationCount = CConfigDataReader::readConfigInteger(this, "Konclude.Calculation.Precomputation.TotalPrecomputor.IndividualsPrecompuationSize", 1500);
985 mDefaultIndividualPrecomputationCountChecked = true;
986 }
987 return mDefaultIndividualPrecomputationCount;
988 }
989
990 cint64 CCalculationConfigurationExtension::getBackendCriticalNeighbourExpansionPriorityReductionCount() {
991 if (!mBackendCriticalNeighbourExpansionPriorityReductionCountChecked) {
992 mBackendCriticalNeighbourExpansionPriorityReductionCount = CConfigDataReader::readConfigInteger(this, "Konclude.Calculation.Optimization.BackendCriticalNeighbourExpansionPriorityReductionCount", 12000);
993 mBackendCriticalNeighbourExpansionPriorityReductionCountChecked = true;
994 }
995 return mBackendCriticalNeighbourExpansionPriorityReductionCount;
996 }
997
998 cint64 CCalculationConfigurationExtension::getBackendCriticalNeighbourDirectExpansionLimit() {
999 if (!mBackendCriticalNeighbourDirectExpansionLimitChecked) {
1000 mBackendCriticalNeighbourDirectExpansionLimit = CConfigDataReader::readConfigInteger(this, "Konclude.Calculation.Optimization.BackendCriticalNeighbourDirectExpansionLimit", 10);
1001 mBackendCriticalNeighbourDirectExpansionLimitChecked = true;
1002 }
1003 return mBackendCriticalNeighbourDirectExpansionLimit;
1004 }
1005
1006 cint64 CCalculationConfigurationExtension::getBackendCriticalNeighbourDirectExpansionOverCriticalReductionSize() {
1007 if (!mBackendCriticalNeighbourDirectExpansionOverCriticalReductionSizeChecked) {
1008 mBackendCriticalNeighbourDirectExpansionOverCriticalReductionSize = CConfigDataReader::readConfigInteger(this, "Konclude.Calculation.Optimization.BackendCriticalNeighbourDirectExpansionOverCriticalReductionSize", 200);
1009 mBackendCriticalNeighbourDirectExpansionOverCriticalReductionSizeChecked = true;
1010 }
1011 return mBackendCriticalNeighbourDirectExpansionOverCriticalReductionSize;
1012 }
1013 cint64 CCalculationConfigurationExtension::getBackendCriticalNeighbourExpansionIndividualsBatchSize() {
1014 if (!mBackendCriticalNeighbourExpansionIndividualsBatchSizeChecked) {
1015 mBackendCriticalNeighbourExpansionIndividualsBatchSize = CConfigDataReader::readConfigInteger(this, "Konclude.Calculation.Optimization.BackendCriticalNeighbourExpansionIndividualsBatchSize", 3);
1016 mBackendCriticalNeighbourExpansionIndividualsBatchSizeChecked = true;
1017 }
1018 return mBackendCriticalNeighbourExpansionIndividualsBatchSize;
1019 }
1020
1021 cint64 CCalculationConfigurationExtension::getBackendCriticalNeighbourExpansionRolesBatchSize() {
1022 if (!mBackendCriticalNeighbourExpansionRolesBatchSizeChecked) {
1023 mBackendCriticalNeighbourExpansionRolesBatchSize = CConfigDataReader::readConfigInteger(this, "Konclude.Calculation.Optimization.BackendCriticalNeighbourExpansionRolesBatchSize", 5);
1024 mBackendCriticalNeighbourExpansionRolesBatchSizeChecked = true;
1025 }
1026 return mBackendCriticalNeighbourExpansionRolesBatchSize;
1027 }
1028
1029
1030 bool CCalculationConfigurationExtension::isBackendDelayedSameInitializationCopyingActivated() {
1031 if (!mBackendDelayedSameInitializationCopyingChecked) {
1032 mBackendDelayedSameInitializationCopyingActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Calculation.Optimization.BackendDelayedSameLabelInitializationCopying", true);
1033 mBackendDelayedSameInitializationCopyingChecked = true;
1034 }
1035 return mBackendDelayedSameInitializationCopyingActivated;
1036 }
1037
1038 bool CCalculationConfigurationExtension::isBackendOnlyDeterministicRepresentativeIndividualDataConsiderationActivated() {
1039 if (!mBackendOnlyDeterministicRepresentativeIndividualDataConsiderationChecked) {
1040 mBackendOnlyDeterministicRepresentativeIndividualDataConsiderationActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Calculation.Optimization.BackendOnlyDeterministicRepresentativeIndividualDataConsideration", true);
1041 mBackendOnlyDeterministicRepresentativeIndividualDataConsiderationChecked = true;
1042 }
1043 return mBackendOnlyDeterministicRepresentativeIndividualDataConsiderationActivated;
1044 }
1045
1046
1047
1048 cint64 CCalculationConfigurationExtension::getBackendExpansionReuseActivationNeighbourIndividualCount() {
1049 if (!mBackendExpansionReuseActivationNeighbourIndividualCountChecked) {
1050 mBackendExpansionReuseActivationNeighbourIndividualCount = CConfigDataReader::readConfigInteger(this, "Konclude.Calculation.Optimization.BackendExpansionReuseActivationNeighbourIndividualCount", 1);
1051 mBackendExpansionReuseActivationNeighbourIndividualCountChecked = true;
1052 }
1053 return mBackendExpansionReuseActivationNeighbourIndividualCount;
1054 }
1055
1056
1057 cint64 CCalculationConfigurationExtension::getBackendExpansionReuseActivationSameIndividualCount() {
1058 if (!mBackendExpansionReuseActivationSameIndividualCountChecked) {
1059 mBackendExpansionReuseActivationSameIndividualCount = CConfigDataReader::readConfigInteger(this, "Konclude.Calculation.Optimization.BackendExpansionReuseActivationSameIndividualCount", 1);
1060 mBackendExpansionReuseActivationSameIndividualCountChecked = true;
1061 }
1062 return mBackendExpansionReuseActivationSameIndividualCount;
1063 }
1064
1065
1066
1067 bool CCalculationConfigurationExtension::isBackendExpandDeterministicallyMergedHandledNeighboursActivated() {
1068 if (!mBackendExpandDeterministicallyMergedHandledNeighboursChecked) {
1069 mBackendExpandDeterministicallyMergedHandledNeighboursActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Calculation.Optimization.BackendExpandDeterministicallyMergedHandledNeighbours", true);
1070 mBackendExpandDeterministicallyMergedHandledNeighboursChecked = true;
1071 }
1072 return mBackendExpandDeterministicallyMergedHandledNeighboursActivated;
1073 }
1074
1075 bool CCalculationConfigurationExtension::isBackendCardinalityNeighbourExpansionRepresentativeCountingActivated() {
1076 if (!mBackendCardinalityNeighbourExpansionRepresentativeCountingChecked) {
1077 mBackendCardinalityNeighbourExpansionRepresentativeCountingActivated = CConfigDataReader::readConfigBoolean(this, "Konclude.Calculation.Optimization.BackendCriticalCardinalityCheckingNeighbourExpansionRepresentativeCounting", false);
1078 mBackendCardinalityNeighbourExpansionRepresentativeCountingChecked = true;
1079 }
1080 return mBackendCardinalityNeighbourExpansionRepresentativeCountingActivated;
1081 }
1082
1083
1084 }; // end namespace Task
1085
1086 }; // end namespace Kernel
1087
1088 }; // end namespace Reasoner
1089
1090 }; // end namespace Konclude