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)
voronoi: remove the code already moved to wireframe module fe57b4b699e8689d35afb510f704019152566f09 I am 2022-11-25 09:25:55
qt_gui.qt_pairwise.ContactWidget: show Qhull request at most once. db6af332a70786759692175384f4b7e779b4caca I am 2022-11-16 13:26:04
wireframe.LinearSolver: polytope handle hotfix bc48de3193ce9be482cc4dd068a26f48ea1e0203 I am 2022-11-16 13:24:41
qt_gui.qt_pairwise.ContactWidget: add LP methods 8dbd480ca80aabe1c7e0e689780767b78c86c1d1 I am 2022-11-16 11:33:32
wireframe: implement two LP solvers 8aecd55104ce85ccccf872ebef0052a5937415b5 I am 2022-11-16 11:32:31
qt_gui.qt_pairwise.ContactWidget: add Gabriel adjacency 86eaf302b176612fad072a2248e2c724d32be755 I am 2022-11-16 06:17:53
wireframe: implement Gabriel adjacency f0a74b4f28cec6c2ddc68d6811e0a812fc829d63 I am 2022-11-16 06:16:58
qt_gui.qt_pairwise.ContactWidget: reflect updated wireframe b00a9be23d92d999e0020426a7a5caa1206c5862 I am 2022-11-16 03:56:57
wireframe: implement LocalizedHull class 95c19144c5144461db241df1b2bd20d8950c8d57 I am 2022-11-16 03:55:59
qt_gui.qt_pairwise.ContactWidget: polish UI bd48c8a6342e20dac1d635b963dd44e62c371379 I am 2022-11-13 20:03:39
wireframe: add convex_slice() method efada4c62f88b6106c687217472e0b8c52374fed I am 2022-11-13 19:51:49
qt_gui.qt_pairwise.ContactWidget: finish widget and clean up 10753a104879d6b9c109735e959b18b5a60a4616 I am 2022-11-10 05:02:01
wireframe: finish and clean up module. implement DirectContact. f7ff9c02f25a3ed8fe04e99036da69766afa5a49 I am 2022-11-10 04:58:58
qt_gui.qt_pairwise.ContactWidget: implement Qhull check e362df1f8b87ab7c6a27643cd6f4091b9caec9a3 I am 2022-11-09 21:35:10
wireframe: add Qframe class cf52d85dd1663537cd8c52a98514c7d041913979 I am 2022-11-09 21:34:12
qt_gui.qt_pairwise: add auto arnge and auto levels controls 9bc2cf10a9a1695c2c1a5f6a9959f375d3808a71 I am 2022-11-09 18:16:47
qt_gui.qt_pairwise: set blue -1 by default. Add force_update option in Contact widget 7371575784df7fd41bd76ad29caf38f474a06a26 I am 2022-11-09 15:39:03
qt_gui.qt_pairwise: prepare Contact widget bfa78d7493f5eb04b6bd3a4ad26dd1a92d17a895 I am 2022-11-09 03:36:05
qt_gui.qt_pairwise: prepare more mouse event signals c60e613508480c68483b3d0d6ad6c876b27f539c I am 2022-11-08 01:55:14
qt_gui: introduce reworked matrix view window e28b95c5f418a7a3cea0cb84ca82b40275a71061 I am 2022-11-07 02:20:45
Commit fe57b4b699e8689d35afb510f704019152566f09 - voronoi: remove the code already moved to wireframe module
Author: I am
Author date (UTC): 2022-11-25 09:25
Committer name: I am
Committer date (UTC): 2022-11-25 09:25
Parent(s): db6af332a70786759692175384f4b7e779b4caca
Signer:
Signing key:
Signing status: N
Tree: 9abf75806f4cab8f384c4cb64499256ceaa39043
File Lines added Lines deleted
wellmet/voronoi.py 0 295
File wellmet/voronoi.py changed (mode: 100644) (index 30ee69b..ecfd279)
... ... from .IS_stat import IS
20 20 from .candynodes import CandyNodes from .candynodes import CandyNodes
21 21 from . import sball from . import sball
22 22
23
24
25
26
27
28
29 def is_line_convex(points, line_indices):
30 i, j = line_indices
31
32 X = points
33 __nsim, ndim = X.shape
34
35 basis = np.random.random((ndim, ndim))
36
37 #č QR rozklad jede po sloupcich
38 basis[:, 0] = X[j] - X[i]
39
40 for dim in range(1, ndim-1):
41 #č co jsem viděl, numpy matici Q normalizuje
42 #č a první sloupec zůstavá (skoro) tím samým, co byl před tím
43 basis[:, :dim+1], __ = np.linalg.qr(basis[:, :dim+1])
44
45 # get constrain
46 a = basis[:, dim]
47 #č nejak tuším, že v poslední dimenzi
48 #č znaménko normál musí být jednotné
49 a = a * -np.sign(a[-1])
50 b = X @ a
51 if np.max(b) - np.max(b[[i, j]]) < 1e-7:
52 return True
53 else:
54 idx = np.argmax(b)
55 basis[:, dim] = basis[:, 1]
56 basis[:, 1] = X[idx] - X[i]
57
58
59
60 for __ in range(ndim):
61 basis, __ = np.linalg.qr(basis)
62
63 # get constrain
64 a = basis[:, -1]
65 #č nejak tuším, že v poslední dimenzi
66 #č znaménko normál musí být jednotné
67 a = a * -np.sign(a[-1])
68 b = X @ a
69 if np.max(b) - np.max(b[[i, j]]) < 1e-7:
70 return True
71 else:
72 idx = np.argmax(b)
73 basis[:, 2:] = basis[:, 1:-1]
74 basis[:, 1] = X[idx] - X[i]
75
76 basis, __ = np.linalg.qr(basis)
77 a = basis[:, -1]
78 #č nejak tuším, že v poslední dimenzi
79 #č znaménko normál musí být jednotné
80 a = a * -np.sign(a[-1])
81 b = X @ a
82 return np.max(b) - np.max(b[[i, j]]) < 1e-7
83
84
85
86
87 class ConvexSolver:
88 """
89 č Hlavní pointa třídy:
90 č pokud dva body zvednuté na povrch convexního paraboloidu
91 č v prostoru ndim+1 (feature space, quadratic kernel)
92 č lze lineárně separovat (hyperrovinou) od ostatních bodů,
93 č znamená to, že v původním prostoru
94 č jejich Voroného buňky budou mít společnou stěnu (kontakt),
95 č neboli, což je totež, u Delone triangulace by měly společné simplexy
96
97 č nebudeme puntičkařit a pro jednoduchost předepíšeme,
98 č nechť dva body zájmu leží přímo v hyperrovině
99 č (bude to hlasít existence rozhraní i v degenerovaných případech
100 č jako např. tří teček na jedné přímce. Mně to ale nevadí)
101 """
102 def __init__(self, points):
103 nsim, ndim = points.shape
104
105 self.lifted_points = np.empty((nsim, ndim + 1))
106 self.lifted_points[:, :ndim] = points
107 # kind of datascience. feature space, quadratic kernel...
108 self.lifted_points[:, -1] = np.sum(np.square(points), axis=1)
109
110
111 def is_couple(self, couple_indices):
112 return is_line_convex(self.lifted_points, couple_indices)
113
114
115 #č Odbočka z odbočky
116 class ConvexSpline:
117 """
118 č Hlavní pointa CS tříd:
119 č pokud dva body zvednuté na povrch convexního paraboloidu
120 č v prostoru ndim+1 (feature space, quadratic kernel)
121 č lze lineárně separovat (hyperrovinou) od ostatních bodů,
122 č znamená to, že v původním prostoru
123 č jejich Voroného buňky budou mít společnou stěnu (kontakt),
124 č neboli, což je totež, u Delone triangulace by měly společné simplexy
125
126 č Hlavní pointa ConvexSpline třídy:
127 č Využit navíc geometrických informací, které už předem známé:
128 č 1. Známe souřadnice vzorků.
129 č 2. Víme, že přímka mezí těmi dvěma vzorky leží v hyperrovině
130 č 3. Vždyť to my zvedáme na povrch convexního paraboloidu!
131 č Můžeme tedy v každém její bodě najit tečnou hyperrovinu.
132
133
134 č nebudeme puntičkařit a pro jednoduchost předepíšeme,
135 č nechť dva body zájmu leží přímo v hyperrovině
136 č (bude to hlasít existence rozhraní i v degenerovaných případech
137 č jako např. tří teček na jedné přímce. Mně to ale nevadí)
138 """
139 def __init__(self, points):
140 nsim, ndim = points.shape
141
142 self.lifted_points = np.empty((nsim, ndim + 1))
143 self.lifted_points[:, :ndim] = points
144 # kind of datascience. feature space, quadratic kernel...
145 self.lifted_points[:, -1] = np.sum(np.square(points), axis=1)
146
147
148 def is_couple(self, couple_indices):
149 i, j = couple_indices
150
151 X = self.lifted_points
152 __nsim, ndim = X.shape
153
154
155
156
157 basis = np.random.random((ndim, ndim))
158 #č první vektor musí být zadán přímkou mezí vzorky
159 #č jinak se posype náš předpoklad, že leží v hyperrovině
160 #č a žádné výsledky "za", "před" hyperrovinou nebudou nic znamenat
161 basis[:, 0] = X[j] - X[i] #č QR rozklad jede po sloupcich
162
163 #č jako indice zkusme použit bod na usečce uprostřed mezí vzorky
164 half_point = np.sum(self.lifted_points[[i, j]], axis=0)
165 np.divide(half_point, 2, out=half_point)
166
167 #č všechy souřadnice jsou dány radius-vektorem od středu,
168 #č ale poslední souřadnice je to naše zvednutí,
169 #č kde bychom mohli zkusit dát korrektnější směr.
170 #č Mně humpolackými uvahami o tečně paraboly
171 #č na caru paríru vyšlo něco jako
172 #č že stačí dát poslední složku 0,5.
173 #č Jakože čím je roloměr je větší,
174 #č tím je "svislá" složka automaticky měnší.
175 #č Jakože netřeba ani normalizovat, ani nic "složitě" počítat
176 half_point[-1] = -0.5
177
178 #č ten náš radius-vektor není ortogonální
179 #č k přímce, na které leží ty naši dva vzorky
180 #č QR rozklad je ortogonalizuje
181 #č a vygeneruje další ortogonalní vektory
182 basis[:, 1] = half_point
183 basis, __ = np.linalg.qr(basis)
184
185
186 #č vytahneme náš ortogonalizovaný odhad
187 #č normálního vektoru
188 a = basis[:, 1]
189 ##č nejak tuším, že v poslední dimenzi
190 ##č znaménko normál musí být jednotné
191 a = a * (1 - 2 * (a[-1] > 0)) # a = a * -np.sign(a[-1])
192 b = X @ a
193
194 if np.max(b) - np.max(b[[i, j]]) < 1e-7:
195 #č bylo to myšleno jako jakési zoufalství
196 #č ale funguje překvapivě dobře
197 return True
198 else:
199 idx = np.argmax(b)
200 #č nahradíme v jedničce naš odhad normálního vektoru
201 #č nalezenou překažkou.
202 #č Zbytek bazí jíž byl ortogonální
203 #č k té naši pomyšlené normále
204 basis[:, 1] = X[idx] - X[i]
205
206 #č Ve zbytku pokračujeme jako vždycky.
207 #č Pořad ndim pokusu u False párečku
208 for __ in range(ndim):
209 basis, __ = np.linalg.qr(basis)
210
211 # get constrain
212 a = basis[:, -1]
213 #č nejak tuším, že v poslední dimenzi
214 #č znaménko normál musí být jednotné
215 a = a * (1 - 2 * (a[-1] > 0)) # a = a * -np.sign(a[-1])
216 b = X @ a
217 if np.max(b) - np.max(b[[i, j]]) < 1e-7:
218 return True
219 else:
220 idx = np.argmax(b)
221 basis[:, 2:] = basis[:, 1:-1]
222 basis[:, 1] = X[idx] - X[i]
223
224 basis, __ = np.linalg.qr(basis)
225 a = basis[:, -1]
226 #č nejak tuším, že v poslední dimenzi
227 #č znaménko normál musí být jednotné
228 a = a * (1 - 2 * (a[-1] > 0)) # a = a * -np.sign(a[-1])
229 b = X @ a
230 return np.max(b) - np.max(b[[i, j]]) < 1e-7
231
232
233
234
235 #class ContactSolver:
236 # """
237 # č Hlavní pointa třídy:
238 # č pokud dva body zvednuté na povrch convexního paraboloidu
239 # č v prostoru ndim+1 (feature space, quadratic kernel)
240 # č lze lineárně separovat (hyperrovinou) od ostatních bodů,
241 # č znamená to, že v původním prostoru
242 # č jejich Voroného buňky budou mít společnou stěnu (kontakt),
243 # č neboli, což je totež, u Delone triangulace by měly společné simplexy
244 #
245 # linprog:
246 # minimize c @ x
247 # such that:
248 # A_ub @ x <= b_ub
249 # A_eq @ x == b_eq
250 # lb <= x <= ub
251 #
252 # č rovnice hyperroviny
253 # H = ax + b = a1x1 + a2x2 + ... + b = 0
254 # č ačka a bčko jsou pro nás neznamé
255 # č takže máme ndim+1 iksů do tamtoho lineárního solveru
256 #
257 # č nebudeme puntičkařit a pro jednoduchost předepíšeme,
258 # č nechť dva body zájmu leží přímo v hyperrovině
259 # č (bude to hlasít existence rozhraní i v degenerovaných případech
260 # č jako např. tří teček na jedné přímce. Mně to ale nevadí)
261 # č Takže.
262 #
263 # č pro linprog zadáme constrains Ax=b
264 # A = [[ x_1i, x_2i, ..., x_ni, 1],
265 # [ x_1j, x_2j, ..., x_nj, 1]]
266 # b = [0, 0]
267 #
268 #
269 # č Zbytek musí splňovat nerovnost, tj.
270 # "Convex hull inequalities of the form Ax + b <= 0"
271 #
272 # č Neboli Ax <= b v termínech linprog
273 # č díky "menší nebo rovno"
274 # č nemusíme plnou matici ani maskovat
275 #
276 # č ačka hyperroviny zadavají jednotkový vektor normály,
277 # č takže leží v mezích -1 < a < 1
278 # č bčko lze omezit poloosou
279 # """
280 # def __init__(self, points):
281 # nsim, ndim = points.shape
282 #
283 # self.A = A = np.empty((nsim, ndim + 2))
284 # A[:, :ndim] = points
285 # # kind of datascience. feature space, quadratic kernel...
286 # #č dáme to trochu niž (ten "ndim"), abychom se vyhli triviálnímu řešení
287 # A[:, -2] = np.sum(np.square(points), axis=1)-1000
288 # A[:, -1] = 1
289 #
290 # self.lifted_points = A[:, :ndim+1]
291 #
292 # #č žšmaria, alokovat nuly..
293 # self.b_ub = np.atleast_1d(np.zeros(ndim-2))
294 # self.c = np.zeros(ndim + 2)
295 # self.b_eq = self.c[:2]
296 # self.bounds = [(-1, 1) for __ in range(ndim + 1)]
297 # #č skoro-nulové b-čko může být legální
298 # #č ale musíme vyhnout triviálnímu řešení
299 # #č nevím co s tím
300 # self.bounds.append((None, -0.2))
301 #
302 # def is_couple(self, couple_indices):
303 # i, j = couple_indices
304 #
305 # #č pro linprog zadáme constrains Ax=b
306 # # A = [[ x_1i, x_2i, ..., x_ni, 1],
307 # # [ x_1j, x_2j, ..., x_nj, 1]]
308 # A_eq = self.A[[i, j]]
309 #
310 # mask = np.ones(len(self.A), dtype=np.bool8)
311 # mask[[i, j]] = False
312 # A_ub = np.atleast_2d(self.A[mask])
313 #
314 # result = linprog(self.c, A_ub=A_ub, b_ub=self.b_ub, A_eq=A_eq,\
315 # b_eq=self.b_eq, bounds=self.bounds)
316 #
317 # return result.success
318 23
319 24
320 25
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