iam-git / WellMet (public) (License: MIT) (since 2021-08-31) (hash sha1)
WellMet is pure Python framework for spatial structural reliability analysis. Or, more specifically, for "failure probability estimation and detection of failure surfaces by adaptive sequential decomposition of the design domain".
Clone URLs: https://rocketgit.com/user/iam-git/WellMet ssh://rocketgit@ssh.rocketgit.com/user/iam-git/WellMet git://git.rocketgit.com/user/iam-git/WellMet
release trunk
List of commits:
Subject Hash Author Date (UTC)
dicebox.circumtri: implement new brand CirQTri box 5879b8ad6317c65aa9481b59f76b6159f19e247a I am 2023-02-09 01:29:10
simplex.FullCubatureIntegration: store simplex probabilities in sorted dicts c0da90731ff3ede47d9b4eec0ad9b28a29027167 I am 2023-02-09 01:23:14
dicebox.circumtri: exploratory: even better idea 811ab11cd7172ff4a3807992f4928be2e8068ec0 I am 2023-02-08 15:31:23
dicebox.circumtri: exploratory, new idea 526d3f6185887ff48a341b0705d74dde4d15ca87 I am 2023-02-08 03:03:41
dicebox.circumtri: exploratory 806063d2e223c812280dc4845153450dd47faed3 I am 2023-02-06 17:15:15
dicebox.circumtri: exploratory efed2589f642d502f30e80f0e9b45dfeecd1c7c7 I am 2023-02-06 13:40:24
dicebox.circumtri: exploratory - again 34d3f4e47420e1c1e26b09570fb44d3270194751 I am 2023-02-06 12:50:45
qt_gui.qt_dicebox: change default q of circumtri classes 9fd5855e5d7cacf80d27fb383dd18a92d60e138b I am 2023-02-06 12:30:27
dicebox.circumtri: tune up exploratory rule one more time bfaa8d65bd13956252a6a25382c621aca7a33e3f I am 2023-02-06 12:05:00
convex_hull.QHull.is_outside: mark everything as outside until convex hull is created beecd924a63603868807a8a603cbeb04857e5cde I am 2023-02-06 12:03:35
dicebox.circumtri: get_exploratory_radius: turn it up some more ecd638ca90bac88df515cf803a103e350b08041e I am 2023-02-03 10:58:37
mplot: ongoing ad-hoc changes fd71b93abee959231ffd76324cf2fbc0b3bbbdfe I am 2023-02-02 17:59:27
dicebox.circumtri: change default q setting 2a9bdc6604113462a935d409bca429b49ac52cbc I am 2023-02-02 11:55:41
dicebox.circumtri: minor change in explore radia 9aa06dc11be7c935dd47715c0aa53b401be951d4 I am 2023-02-01 23:37:13
dicebox.circumtri: exploratory: another iteration 78c849a2c1b07a55f87d32e3cd6570db222a50b6 I am 2023-02-01 01:02:00
dicebox: new experimental explore() 1d570ef1dcc66b9b1015bd6c1f6877e1405e676c I am 2023-02-01 00:34:57
mplot: improve GRaph; draw vertex estimator only in convergence diagram 5c22e808e4c6cabd8e0d077d5f295eea93957582 I am 2023-01-31 18:02:00
simplex.TopologyAnalysis: implement postprocessing 5b8d6c87bd18e06e2e3e1aa651ebccc6d9ed2e69 I am 2023-01-30 20:59:59
testcases.testcases_nD_papers: add low pf nonlinear oscillator setting 4a75d5ec830f88c35a91e53898e416e568e3913c I am 2023-01-30 16:13:17
qt_gui.qt_plot: replace dropped np.int by int 197cbc3f6cf7ef92fc092a1e026cbace609eaabe I am 2023-01-28 18:07:43
Commit 5879b8ad6317c65aa9481b59f76b6159f19e247a - dicebox.circumtri: implement new brand CirQTri box
Author: I am
Author date (UTC): 2023-02-09 01:29
Committer name: I am
Committer date (UTC): 2023-02-09 01:29
Parent(s): c0da90731ff3ede47d9b4eec0ad9b28a29027167
Signer:
Signing key:
Signing status: N
Tree: 97a87a29fcc7ef87f51d4b58537a46fbdff7a1d1
File Lines added Lines deleted
wellmet/dicebox/circumtri.py 411 220
wellmet/qt_gui/qt_dicebox.py 37 21
File wellmet/dicebox/circumtri.py changed (mode: 100644) (index 5ec94df..c1aa60d)
... ... class _CircumTri(_Exploration):
64 64
65 65 def __str__(bx): def __str__(bx):
66 66 return "%s(%s)"%(bx.__class__.__name__, str(bx.init_parameters())) return "%s(%s)"%(bx.__class__.__name__, str(bx.init_parameters()))
67
68
69 def refine(bx):
70 if len(bx.candidates_index):
71 # return node with the greatest potential
72 key, value = bx.potential_index.peekitem()
73 return bx.candidates_index[key]
74 else:
75 bx._logger(msg='refine called, but triangulation does not exist yet. Fallback to random sample')
76 return bx.f_model(1)
77
78
79 def holyday(bx):
80 if len(bx.candidates_index):
81 # return node with the greatest potential
82 key, value = bx.global_potential_index.peekitem()
83 return bx.candidates_index[key]
84 else:
85 bx._logger(msg='triangulation does not exist yet. Fallback to random sample')
86 return bx.f_model(1)
87
88 def regen(bx):
89 """
90 regen() recreates data structures of the box.
91 It shouldn't be called without reason, changed distribution, settings or so.
92 """
93
94 #оӵ шайтан регенираци лэзьиз
95 bx._logger(msg='regeneration started')
96
97 bx.candidates_index.clear()
98 bx.potential_index.clear()
99 bx.global_potential_index.clear()
100
101 bx._regen_outside()
102 bx._regen_inside()
103
104 bx.to_explore = 1
105 bx.to_refine = 0
106 if bx.nsim > 0:
107 bx.pf_estimation = bx.get_pf_estimation() #č updates p_mixed
108 bx.update_exploration_ratio()
109
110 bx._nsim = bx.nsim
111
112
113 67
114 68 def __len__(bx): def __len__(bx):
115 69 return bx.sample_box.nsim return bx.sample_box.nsim
 
... ... class _CircumTri(_Exploration):
151 105 bx.sample_box.add_sample(input_sample) bx.sample_box.add_sample(input_sample)
152 106 bx.increment(bx.sample_box[bx._nsim:]) bx.increment(bx.sample_box[bx._nsim:])
153 107 bx._nsim = bx.nsim bx._nsim = bx.nsim
154
155
156 def update_exploration_ratio(bx):
157 bx.to_explore += bx.pf_estimation.outside / (bx.pf_estimation.nfacets + 1)
158 if bx.pf_estimation.max_potential > 0:
159 bx.to_refine += bx.pf_estimation.mix / bx.pf_estimation.mixed_simplices
160
161 108
162 109
163 110 def get_exploratory_radius(bx): def get_exploratory_radius(bx):
 
... ... class _CircumTri(_Exploration):
171 118 return r return r
172 119
173 120
174 #č teď je to kolbek, který volá Triangulation
175 def _on_safe_added(bx, simplex, indices, vertices_model, nodes, vol):
176
177 try:
178 circum_center = bx.CC.get_circumcenter(vertices_model)
179 except BaseException as e:
180 bx._logger(repr(e), msg='CircumCenter error')
181 return
182 r = distance.euclidean(circum_center, vertices_model[0])
183 circum_node = bx.f_model.new_sample(circum_center, space=bx.tri_space)
184 #č můžeme nechat numpy pole z jednoho prvku. Můžeme zredukovat na float
185 #circum_pdf = circum_node.pdf(bx.tri_space)
186 circum_pdf = float(circum_node.pdf(bx.tri_space))
187
188
189 #PDF = bx.Tri.PDF[indices]
190 #max_PDF = np.max(PDF)
191
192 circum_potential = r**bx.nvar * circum_pdf #**bx.psi_q * max_PDF**(1-bx.psi_q)
193
194 if not np.isfinite(circum_potential):
195 return
196
197 # max_node_potential = -np.inf
198 # if not bx.circumcenters_only:
199 # dr = distance.cdist(nodes.G, [circum_center]).reshape(-1)
200 # nodes_pdf = nodes.pdf(bx.tri_space)
201 # node_potentials = (r - dr)**bx.nvar * nodes_pdf#**bx.psi_q * PDF[i]**(1-bx.psi_q)
202 #
203 # max_node = np.argmax(node_potentials)
204 # max_node_potential = node_potentials[max_node]
205 #
206 # if max_node_potential > circum_potential:
207 # result_node = nodes[max_node]
208 # result_potential = max_node_potential
209 # else:
210 result_node = circum_node
211 result_potential = circum_potential
212
213 if bx.store_candidates_metainformation:
214 result_node = CandyNodes(result_node)
215 result_node.potential = result_potential
216
217 bx.candidates_index[simplex] = result_node
218 bx.global_potential_index[simplex] = result_potential
219
220
221 121
222 #č teď je to kolbek, který volá Triangulation
223 def _on_mixed_added(bx, simplex, indices, vertices_model, nodes, _vol, fr, wfr, _mfpdf):
224
225 try:
226 circum_center = bx.CC.get_circumcenter(vertices_model)
227 except BaseException as e:
228 bx._logger(repr(e), msg='CircumCenter error')
229 return
230 r = distance.euclidean(circum_center, vertices_model[0])
231 circum_node = bx.f_model.new_sample(circum_center, space=bx.tri_space)
232 #č můžeme nechat numpy pole z jednoho prvku. Můžeme zredukovat na float
233 #circum_pdf = circum_node.pdf(bx.tri_space)
234 circum_pdf = float(circum_node.pdf(bx.tri_space))
235
236
237 failsi = bx.Tri.failsi[indices]
238 PDF = bx.Tri.PDF[indices]
239 max_PDF = np.max(PDF)
240
241 circum_potential = r**bx.nvar * circum_pdf**bx.psi_q * max_PDF**(1-bx.psi_q)
242
243 if not np.isfinite(circum_potential):
244 return
245
246
247
248 max_node_potential = -np.inf
249 if not bx.circumcenters_only:
250 tree = KDTree(vertices_model, compact_nodes=False, balanced_tree=False)
251
252 #č konkretně tato třída je pevně napojena na G prostor
253 #č ale bacha, kbyby se to změnilo...
254 dd, ii = tree.query(nodes.G, k=2)
255
256 failsi_pair = failsi[ii]
257 mask = np.logical_xor(failsi_pair[:,0], failsi_pair[:,1])
258 #mask = np.sum(failsi[ii], axis=1) == 1
259 if np.any(mask):
260 nodes = nodes[mask]
261
262 dr = distance.cdist(nodes.G, [circum_center]).reshape(-1)
263 nodes_pdf = nodes.pdf(bx.tri_space)
264 #č nejdřív rouška, pak slice. V tomto pořadí numpy to zvladné bez alokací
265 i = ii[mask][:,0]
266 node_potentials = (r - dr)**bx.nvar * nodes_pdf**bx.psi_q * PDF[i]**(1-bx.psi_q)
267
268 max_node = np.argmax(node_potentials)
269 max_node_potential = node_potentials[max_node]
270
271
272 if max_node_potential > circum_potential:
273 result_node = nodes[max_node]
274 result_potential = max_node_potential
275 else:
276 result_node = circum_node
277 result_potential = circum_potential
278
279 if bx.store_candidates_metainformation:
280 result_node = CandyNodes(result_node)
281 result_node.potential = result_potential
282
283 bx.candidates_index[simplex] = result_node
284 bx.potential_index[simplex] = result_potential
285 if bx.holydays:
286 bx.global_potential_index[simplex] = result_potential
287
288
289
290
291
292 # callback
293 #č sx.on_delete_simplex(indices=indices)
294 def _invalidate_simplex(bx, simplex):
295 bx.potential_index.pop(simplex, None)
296 bx.global_potential_index.pop(simplex, None)
297 bx.candidates_index.pop(simplex, None)
298 122
299 123
300 124
 
... ... class _CircumTri(_Exploration):
343 167 #č lze přípustit chybu triangulace #č lze přípustit chybu triangulace
344 168 bx._logger(msg='triangulation failed') bx._logger(msg='triangulation failed')
345 169
346
347
348 def increment(bx, input_sample):
349 #č tri - Deloneho triangulace
350 if "tri" in dir(bx):
351 bx.Tri.update()
352 else:
353 bx._regen_inside()
354
355 a, b, _sample = bx.convex_hull.get_exploration_vector()
356 critical_r = -b
357
358 coming_r = a @ input_sample.G.T
359
360 if bx._nsim > 1 and np.any(coming_r > critical_r):
361 bx.to_explore = 0
362 bx.convex_hull.update()
363 bx.estimate_outside()
364 elif np.any(bx.convex_hull.is_outside(input_sample)):
365 bx.to_refine = 0
366 bx.convex_hull.update()
367 bx.estimate_outside()
368 else:
369 bx.to_refine = 0
370
371 bx.pf_estimation = bx.get_pf_estimation()
372 bx.box_estimations.append(bx.pf_estimation)
373 bx.update_exploration_ratio()
374
375
376 170
377 171 def is_mixed(bx, simplices=None): def is_mixed(bx, simplices=None):
378 172
 
... ... class _CircumTri(_Exploration):
466 260
467 261 inside = bx.shell_estimation.inside inside = bx.shell_estimation.inside
468 262
469 if len(bx.candidates_index):
470 __key, max_potential = bx.potential_index.peekitem()
471 else:
472 max_potential = -1
473
474 if 'tri' in dir(bx):
263 if 'Tri' in dir(bx):
475 264 tri_estimation = bx.Tri.get_pf_estimation() tri_estimation = bx.Tri.get_pf_estimation()
476 265
477 bx.p_mixed = tri_estimation.mix
266 mixed = tri_estimation.mix
267 failure = tri_estimation.failure
478 268
479 269 if not bx.holydays: if not bx.holydays:
480 success = inside - tri_estimation.failure - tri_estimation.mix
270 success = inside - mixed - failure
481 271 p_sum = 1 p_sum = 1
482 272 else: else:
483 273 success = tri_estimation.success success = tri_estimation.success
484 274 outside = bx.shell_estimation.outside outside = bx.shell_estimation.outside
485 p_sum = outside + tri_estimation.failure + bx.p_mixed + success
275 p_sum = outside + failure + mixed + success
486 276
487 277 return bx.Estimation(bx.nsim, #č musíme sami lepit nové etikety, neboť return bx.Estimation(bx.nsim, #č musíme sami lepit nové etikety, neboť
488 278 *bx.get_outside_estimation(), *bx.get_outside_estimation(),
 
... ... class _CircumTri(_Exploration):
493 283
494 284 *bx.get_tri_radia(), *bx.get_tri_radia(),
495 285 p_sum, p_sum,
496 max_potential
286 bx.get_max_potential()
497 287 ) )
498 288
499 289
 
... ... class _CircumTri(_Exploration):
509 299
510 300 success = tri_estimation[0] success = tri_estimation[0]
511 301 failure = tri_estimation[1] failure = tri_estimation[1]
512 bx.p_mixed = mixed = tri_estimation[2]
302 mixed = tri_estimation[2]
513 303
514 304 return bx.Estimation(bx.nsim, #č musíme sami lepit nové etikety, neboť return bx.Estimation(bx.nsim, #č musíme sami lepit nové etikety, neboť
515 305 *bx.get_outside_estimation(), *bx.get_outside_estimation(),
 
... ... class _CircumTri(_Exploration):
533 323
534 324 *bx.get_tri_radia(), *bx.get_tri_radia(),
535 325 1, 1,
536 max_potential
326 bx.get_max_potential()
537 327 ) )
538 328
539 329
 
... ... class _CircumTri(_Exploration):
542 332
543 333
544 334
545 class CircumTri(_CircumTri):
335
336 class CirQTri(_CircumTri):
337
338 def __init__(bx, sample_box, scheme, convex_hull_degree=5,
339 q=1, holydays=0):
340
341 bx.sample_box = sample_box
342 bx.convex_hull_degree = convex_hull_degree
343 bx.scheme = scheme
344
345 bx.tri_space = 'G'
346
347 bx.Estimation = QTriEstimation
348 bx.q = q
349 bx.holydays = holydays
350
351 bx.sball = sball.Sball(bx.nvar)
352
353
354 #č přece ponechame složku pro uživatelské odhady
355 #č stm kód může semka něco ukladat
356 bx.estimations = []
357
358 #č vítejte nové uložiště odhadů.
359 #č Odhady z stm kódu už ale nemají na tohle sahat
360 if hasattr(bx, 'filename'):
361 bx.box_estimations = Store.create(bx.filename + "_qtri", bx.Estimation)
362 else:
363 bx.box_estimations = []
364
365 bx.CC = sx.CircumCenter(sample_box.nvar)
366
367 bx.regen()
368
369
370 def init_parameters(bx):
371 """
372 Returns dictionary of parameters the DiceBox was initialized with
373 """
374 return {'sample_box':bx.sample_box, 'scheme':bx.scheme.name,
375 'convex_hull_degree':bx.convex_hull_degree,
376 'q':bx.q, 'holydays':bx.holydays}
377
378
379 def _regen_outside(bx):
380 facet_scheme = quadpy.tn.grundmann_moeller(bx.nvar - 1, bx.convex_hull_degree)
381 bx.convex_hull = khull.QHull(bx.f_model, space='G', incremental=True,
382 auto_update=False, tn_scheme=facet_scheme)
383
384 #č konečně mám pořádnou stejtful třídu
385 #č pokud mám aspoň jednu tečku, tak už je mi šuma
386 #č zda se konvexní obálka vytvořila, či nikoliv
387 if bx.nsim > 0:
388 bx.estimate_outside()
389
390
391 def estimate_outside(bx):
392 #č konečně mám pořádnou stejtful třídu
393 #č pokud mám aspoň jednu tečku, tak už je mi šuma
394 #č zda se konvexní obálka vytvořila, či nikoliv
395
396 #č Máme úkol:
397 #č 1. Získat odhady a uložit je, abychom nemuseli opakovaně integrovat,
398 #č dokud se neobjeví nějaký nový vzorek zvenku.
399 bx.shell_estimation = bx.convex_hull.get_convex_hull_estimation()
400 bx.shell_stats = bx.shell_estimation # simple trick
401
402
403 def get_outside_estimation(bx):
404 return bx.shell_estimation[1:]
405
406
407 def get_circum_node(bx, simplex):
408 indices = np.array(simplex)
409 vertices_model = bx.Tri.tri.points[indices]
410 try:
411 circum_center = bx.CC.get_circumcenter(vertices_model)
412 except BaseException as e:
413 bx._logger(repr(e), msg='CircumCenter error')
414 circum_center = np.mean(vertices_model, axis=0)
415
416 if not np.all(np.isfinite(circum_center)):
417 raise
418
419 length2 = np.sum(np.square(circum_center))
420 if length2 > bx.pf_estimation.R**2:
421 bx._logger(circum_center,
422 msg='Circumcenter lies too far away from the origin. The radial distance is reduced')
423 circum_center /= np.sqrt(length2)
424 circum_center *= bx.get_exploratory_radius()
425
426 circum_node = bx.f_model.new_sample(circum_center, space=bx.tri_space)
427 return circum_node
428
429
430 def refine(bx):
431 if "Tri" in dir(bx):
432 # get the greatest mixed simplex
433 key, __value = bx.Tri.mixed_simplex_probabilities.peekitem()
434 return bx.get_circum_node(key)
435 else:
436 bx._logger(msg='refine called, but triangulation does not exist yet. Fallback to a random sample')
437 return bx.f_model(1)
438
439
440 def holyday(bx):
441 if "Tri" in dir(bx) and len(bx.Tri.safe_simplex_probabilities):
442 # return node with the greatest potential
443 key, __value = bx.Tri.safe_simplex_probabilities.peekitem()
444 return bx.get_circum_node(key)
445 else:
446 bx._logger(msg='Fallback to random sample')
447 return bx.f_model(1)
448
449 def regen(bx):
450 """
451 regen() recreates data structures of the box.
452 It shouldn't be called without reason, changed distribution, settings or so.
453 """
454
455 #оӵ шайтан регенираци лэзьиз
456 bx._logger(msg='regeneration started')
457
458 bx._regen_outside()
459 bx._regen_inside()
460
461 bx.to_explore = 1
462 bx.to_refine = 0
463 if bx.nsim > 0:
464 bx.pf_estimation = bx.get_pf_estimation()
465 bx.update_exploration_ratio()
466
467 bx._nsim = bx.nsim
468
469
470
471 def get_max_potential(bx):
472 if "Tri" in dir(bx):
473 # get the greatest mixed simplex
474 __key, value = bx.Tri.mixed_simplex_probabilities.peekitem()
475 return value
476 else:
477 return -1
478
479 def update_exploration_ratio(bx):
480 bx.to_explore = stats.norm.sf(bx.pf_estimation.r)
481 bx.to_refine = bx.get_max_potential()
482
483
484 #č teď je to kolbek, který volá Triangulation
485 def _on_safe_added(bx, simplex, indices, vertices_model, nodes, vol):
486 pass
487
488
489 #č teď je to kolbek, který volá Triangulation
490 def _on_mixed_added(bx, simplex, indices, vertices_model, nodes, _vol, fr, wfr, _mfpdf):
491 pass
492
493 # callback
494 #č sx.on_delete_simplex(indices=indices)
495 def _invalidate_simplex(bx, simplex):
496 pass
497
498
499 def increment(bx, input_sample):
500 #č tri - Deloneho triangulace
501 if "tri" in dir(bx):
502 bx.Tri.update()
503 else:
504 bx._regen_inside()
505
506 if np.any(bx.convex_hull.is_outside(input_sample)):
507 bx.convex_hull.update()
508 bx.estimate_outside()
509
510 bx.pf_estimation = bx.get_pf_estimation()
511 bx.box_estimations.append(bx.pf_estimation)
512 bx.update_exploration_ratio()
513
514
515
516
517 class _PsiTri:
518 def refine(bx):
519 if len(bx.candidates_index):
520 # return node with the greatest potential
521 key, value = bx.potential_index.peekitem()
522 return bx.candidates_index[key]
523 else:
524 bx._logger(msg='refine called, but triangulation does not exist yet. Fallback to random sample')
525 return bx.f_model(1)
526
527
528 def holyday(bx):
529 if len(bx.candidates_index):
530 # return node with the greatest potential
531 key, value = bx.global_potential_index.peekitem()
532 return bx.candidates_index[key]
533 else:
534 bx._logger(msg='triangulation does not exist yet. Fallback to random sample')
535 return bx.f_model(1)
536
537 def regen(bx):
538 """
539 regen() recreates data structures of the box.
540 It shouldn't be called without reason, changed distribution, settings or so.
541 """
542
543 #оӵ шайтан регенираци лэзьиз
544 bx._logger(msg='regeneration started')
545
546 bx.candidates_index.clear()
547 bx.potential_index.clear()
548 bx.global_potential_index.clear()
549
550 bx._regen_outside()
551 bx._regen_inside()
552
553 bx.to_explore = 1
554 bx.to_refine = 0
555 if bx.nsim > 0:
556 bx.pf_estimation = bx.get_pf_estimation() #č updates p_mixed
557 bx.update_exploration_ratio()
558
559 bx._nsim = bx.nsim
560
561
562 def get_max_potential(bx):
563 if len(bx.candidates_index):
564 __key, max_potential = bx.potential_index.peekitem()
565 else:
566 max_potential = -1
567 return max_potential
568
569
570
571 def update_exploration_ratio(bx):
572 bx.to_explore += bx.pf_estimation.outside / (bx.pf_estimation.nfacets + 1)
573 if bx.pf_estimation.max_potential > 0:
574 bx.to_refine += bx.pf_estimation.mix / bx.pf_estimation.mixed_simplices
575
576
577 #č teď je to kolbek, který volá Triangulation
578 def _on_safe_added(bx, simplex, indices, vertices_model, nodes, vol):
579
580 try:
581 circum_center = bx.CC.get_circumcenter(vertices_model)
582 except BaseException as e:
583 bx._logger(repr(e), msg='CircumCenter error')
584 return
585 r = distance.euclidean(circum_center, vertices_model[0])
586 circum_node = bx.f_model.new_sample(circum_center, space=bx.tri_space)
587 #č můžeme nechat numpy pole z jednoho prvku. Můžeme zredukovat na float
588 #circum_pdf = circum_node.pdf(bx.tri_space)
589 circum_pdf = float(circum_node.pdf(bx.tri_space))
590
591
592 #PDF = bx.Tri.PDF[indices]
593 #max_PDF = np.max(PDF)
594
595 circum_potential = r**bx.nvar * circum_pdf #**bx.psi_q * max_PDF**(1-bx.psi_q)
596
597 if not np.isfinite(circum_potential):
598 return
599
600 # max_node_potential = -np.inf
601 # if not bx.circumcenters_only:
602 # dr = distance.cdist(nodes.G, [circum_center]).reshape(-1)
603 # nodes_pdf = nodes.pdf(bx.tri_space)
604 # node_potentials = (r - dr)**bx.nvar * nodes_pdf#**bx.psi_q * PDF[i]**(1-bx.psi_q)
605 #
606 # max_node = np.argmax(node_potentials)
607 # max_node_potential = node_potentials[max_node]
608 #
609 # if max_node_potential > circum_potential:
610 # result_node = nodes[max_node]
611 # result_potential = max_node_potential
612 # else:
613 result_node = circum_node
614 result_potential = circum_potential
615
616 if bx.store_candidates_metainformation:
617 result_node = CandyNodes(result_node)
618 result_node.potential = result_potential
619
620 bx.candidates_index[simplex] = result_node
621 bx.global_potential_index[simplex] = result_potential
622
623
624
625 #č teď je to kolbek, který volá Triangulation
626 def _on_mixed_added(bx, simplex, indices, vertices_model, nodes, _vol, fr, wfr, _mfpdf):
627
628 try:
629 circum_center = bx.CC.get_circumcenter(vertices_model)
630 except BaseException as e:
631 bx._logger(repr(e), msg='CircumCenter error')
632 return
633 r = distance.euclidean(circum_center, vertices_model[0])
634 circum_node = bx.f_model.new_sample(circum_center, space=bx.tri_space)
635 #č můžeme nechat numpy pole z jednoho prvku. Můžeme zredukovat na float
636 #circum_pdf = circum_node.pdf(bx.tri_space)
637 circum_pdf = float(circum_node.pdf(bx.tri_space))
638
639
640 failsi = bx.Tri.failsi[indices]
641 PDF = bx.Tri.PDF[indices]
642 max_PDF = np.max(PDF)
643
644 circum_potential = r**bx.nvar * circum_pdf**bx.psi_q * max_PDF**(1-bx.psi_q)
645
646 if not np.isfinite(circum_potential):
647 return
648
649
650
651 max_node_potential = -np.inf
652 if not bx.circumcenters_only:
653 tree = KDTree(vertices_model, compact_nodes=False, balanced_tree=False)
654
655 #č konkretně tato třída je pevně napojena na G prostor
656 #č ale bacha, kbyby se to změnilo...
657 dd, ii = tree.query(nodes.G, k=2)
658
659 failsi_pair = failsi[ii]
660 mask = np.logical_xor(failsi_pair[:,0], failsi_pair[:,1])
661 #mask = np.sum(failsi[ii], axis=1) == 1
662 if np.any(mask):
663 nodes = nodes[mask]
664
665 dr = distance.cdist(nodes.G, [circum_center]).reshape(-1)
666 nodes_pdf = nodes.pdf(bx.tri_space)
667 #č nejdřív rouška, pak slice. V tomto pořadí numpy to zvladné bez alokací
668 i = ii[mask][:,0]
669 node_potentials = (r - dr)**bx.nvar * nodes_pdf**bx.psi_q * PDF[i]**(1-bx.psi_q)
670
671 max_node = np.argmax(node_potentials)
672 max_node_potential = node_potentials[max_node]
673
674
675 if max_node_potential > circum_potential:
676 result_node = nodes[max_node]
677 result_potential = max_node_potential
678 else:
679 result_node = circum_node
680 result_potential = circum_potential
681
682 if bx.store_candidates_metainformation:
683 result_node = CandyNodes(result_node)
684 result_node.potential = result_potential
685
686 bx.candidates_index[simplex] = result_node
687 bx.potential_index[simplex] = result_potential
688 if bx.holydays:
689 bx.global_potential_index[simplex] = result_potential
690
691
692
693
694
695 # callback
696 #č sx.on_delete_simplex(indices=indices)
697 def _invalidate_simplex(bx, simplex):
698 bx.potential_index.pop(simplex, None)
699 bx.global_potential_index.pop(simplex, None)
700 bx.candidates_index.pop(simplex, None)
701
702
703 def increment(bx, input_sample):
704 #č tri - Deloneho triangulace
705 if "tri" in dir(bx):
706 bx.Tri.update()
707 else:
708 bx._regen_inside()
709
710 a, b, _sample = bx.convex_hull.get_exploration_vector()
711 critical_r = -b
712
713 coming_r = a @ input_sample.G.T
714
715 if bx._nsim > 1 and np.any(coming_r > critical_r):
716 bx.to_explore = 0
717 bx.convex_hull.update()
718 bx.estimate_outside()
719 elif np.any(bx.convex_hull.is_outside(input_sample)):
720 bx.to_refine = 0
721 bx.convex_hull.update()
722 bx.estimate_outside()
723 else:
724 bx.to_refine = 0
725
726 bx.pf_estimation = bx.get_pf_estimation()
727 bx.box_estimations.append(bx.pf_estimation)
728 bx.update_exploration_ratio()
729
730
731
732
733
734
735
736 class CircumTri(_CircumTri, _PsiTri):
546 737
547 738 #č míží nám sampling_space: Ghull umí vzorkovat outside pouze v G prostoru #č míží nám sampling_space: Ghull umí vzorkovat outside pouze v G prostoru
548 739 #č quadpy umístí integráční bodíky v prostoru triangulace. #č quadpy umístí integráční bodíky v prostoru triangulace.
 
... ... class CircumTri(_CircumTri):
691 882
692 883
693 884
694 class QTri(_CircumTri):
885 class QTri(_CircumTri, _PsiTri):
695 886
696 887 def __init__(bx, sample_box, convex_hull_degree=5, tri_degree=5, def __init__(bx, sample_box, convex_hull_degree=5, tri_degree=5,
697 888 q=10, psi_q=0.5, circumcenters_only=True, q=10, psi_q=0.5, circumcenters_only=True,
File wellmet/qt_gui/qt_dicebox.py changed (mode: 100644) (index 77af739..918f362)
... ... import numpy as np
3 3 from .. import schemes from .. import schemes
4 4 from ..candybox import CandyBox from ..candybox import CandyBox
5 5 from ..dicebox.goal import Goal, Razitko, DiceBox from ..dicebox.goal import Goal, Razitko, DiceBox
6 from ..dicebox.circumtri import CircumTri, QTri
6 from ..dicebox.circumtri import CirQTri, CircumTri, QTri
7 7 from ..dicebox._exploration import DumbExploration from ..dicebox._exploration import DumbExploration
8 8 import pyqtgraph as pg import pyqtgraph as pg
9 9 from pyqtgraph.Qt import QtCore, QtWidgets from pyqtgraph.Qt import QtCore, QtWidgets
 
... ... class CircumTriWidget(pg.parametertree.ParameterTree):
249 249
250 250
251 251
252 class NaiveCircumTriWidget(pg.parametertree.ParameterTree):
252 class CirQTriWidget(pg.parametertree.ParameterTree):
253 253 def __init__(self, wt, parent=None): def __init__(self, wt, parent=None):
254 254 self.box = wt self.box = wt
255 255 super().__init__(parent=parent, showHeader=False) super().__init__(parent=parent, showHeader=False)
 
... ... class NaiveCircumTriWidget(pg.parametertree.ParameterTree):
261 261 tschemes = schemes.get_tn_keys(self.box.nvar) tschemes = schemes.get_tn_keys(self.box.nvar)
262 262 params.append({'name': 'scheme', 'type': 'list', \ params.append({'name': 'scheme', 'type': 'list', \
263 263 'title': "cubature scheme", \ 'title': "cubature scheme", \
264 'values': tschemes, 'value': 'stroud_tn_2_1b'})
264 'values': tschemes, 'value': 'stroud_tn_3_6b'})
265 265 params.append({'name': 'degree', 'type': 'int', \ params.append({'name': 'degree', 'type': 'int', \
266 266 'title': "degree",\ 'title': "degree",\
267 267 'limits': (0, float('inf')), 'value': 5, 'default': 5,\ 'limits': (0, float('inf')), 'value': 5, 'default': 5,\
268 268 'tip': "Used only with Grundmann-Möller and Silvester cubaturas"}) 'tip': "Used only with Grundmann-Möller and Silvester cubaturas"})
269 269
270 params.append({'name': 'tri_space', 'type': 'list', 'value': 'G', \
271 'title': "triangulation space", 'values': spaces})
272 params.append({'name': 'entropy_mode', 'type': 'list', 'value': 'weighted', \
273 'title': "entropy mode", \
274 'values': ['none', 'simple', 'weighted']})
275 params.append({'name': 'shell_budget', 'type': 'int', \
276 'title': "shell budget", \
277 'limits': (1, float('inf')), 'value': 1000, 'default': 1000,\
278 'tip': "Number of annulus candidates"})
270 params.append({'name': 'convex_hull_degree', 'type': 'int', \
271 'title': "facet degree",\
272 'limits': (0, float('inf')), 'value': 5, 'default': 5,\
273 'tip': "Degree of Grundmann-Möller cubature"})
274
275 params.append({'name': 'q', 'type': 'float',
276 'limits': (0, float('inf')), 'value': 1, 'default': self.box.nvar,
277 'tip': '"Agressiveness" of exploration'})
279 278
280 params.append({'name': 'outer_budget', 'type': 'int', \
281 'title': "Outer budget", \
282 'limits': (1, float('inf')), 'value': 100, 'default': 100,\
283 'tip': "Number of candidates nodes outside of circumscribed d-ball"})
279 params.append({'name': 'holydays', 'type': 'int', \
280 'title': "holydays", \
281 'limits': (0, float('inf')), 'value': 0, 'default': 10,\
282 'tip': "Every n-th point is an screening point. 0 to switch off"})
284 283
285 284
286 285 ### Create tree of Parameter objects ### Create tree of Parameter objects
 
... ... class NaiveCircumTriWidget(pg.parametertree.ParameterTree):
291 290 #self.param.sigValueChanging.connect(self.param_changing) #self.param.sigValueChanging.connect(self.param_changing)
292 291 self.param = pg.parametertree.Parameter.create(name='params', type='group', children=params) self.param = pg.parametertree.Parameter.create(name='params', type='group', children=params)
293 292
293 p = self.param.child('scheme')
294 p.sigValueChanged.connect(self.scheme_changed)
295
296 #č podle implicitně nastavené scheme
297 self.param.child('degree').hide()
298
294 299 #č branima sa rekurzii #č branima sa rekurzii
295 300 #оӵ рекурзилы пезьдэт! #оӵ рекурзилы пезьдэт!
296 301 self.param_values = self.param.getValues() self.param_values = self.param.getValues()
297 302
303 def scheme_changed(self, parameter):
304 scheme = parameter.value()
305 if scheme in ('Grundmann-Möller', 'Silvester open', 'Silvester closed'):
306 self.param.child('degree').show()
307 else:
308 self.param.child('degree').hide()
309
298 310 def __getattr__(self, attr): def __getattr__(self, attr):
299 311 #č na teoreticky možnou rěkurziju vykašleme #č na teoreticky možnou rěkurziju vykašleme
300 312 #оӵ рекурзия уз луы #оӵ рекурзия уз луы
 
... ... class NaiveCircumTriWidget(pg.parametertree.ParameterTree):
306 318
307 319 scheme = schemes.get_tn_scheme(self.scheme, self.box.nvar, self.degree) scheme = schemes.get_tn_scheme(self.scheme, self.box.nvar, self.degree)
308 320
309 self.box.sample_box = CircumTri(
321 self.box.sample_box = CirQTri(
310 322 self.box.sample_box, #č rekurze) self.box.sample_box, #č rekurze)
311 323 scheme, scheme,
312 tri_space=self.tri_space,
313 entropy_mode=self.entropy_mode,
314 shell_budget=self.shell_budget,
315 outer_budget=self.outer_budget,
324 convex_hull_degree=self.convex_hull_degree,
325 q=self.q,
326 holydays=self.holydays
316 327 ) )
317 328
318 329
 
... ... class SetupDiceBoxWidget(pg.LayoutWidget):
589 600 #č aby je nám Python nehodil #č aby je nám Python nehodil
590 601 self.tabs = [] self.tabs = []
591 602
603
604 box_widget = CirQTriWidget(self.box, self)
605 self.tab_widget.addTab(box_widget, "CirQTri")
606 self.tabs.append(box_widget)
607
592 608 box_widget = QTriWidget(self.box, self) box_widget = QTriWidget(self.box, self)
593 609 self.tab_widget.addTab(box_widget, "QTri") self.tab_widget.addTab(box_widget, "QTri")
594 610 self.tabs.append(box_widget) self.tabs.append(box_widget)
Hints:
Before first commit, do not forget to setup your git environment:
git config --global user.name "your_name_here"
git config --global user.email "your@email_here"

Clone this repository using HTTP(S):
git clone https://rocketgit.com/user/iam-git/WellMet

Clone this repository using ssh (do not forget to upload a key first):
git clone ssh://rocketgit@ssh.rocketgit.com/user/iam-git/WellMet

Clone this repository using git:
git clone git://git.rocketgit.com/user/iam-git/WellMet

You are allowed to anonymously push to this repository.
This means that your pushed commits will automatically be transformed into a merge request:
... clone the repository ...
... make some changes and some commits ...
git push origin main