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)
spring: new brand hustý modul pro vyrovnání odhadů 3fc5eb00de1eb65cff2db71640c340602687f52f I am 2021-06-25 00:52:06
convex_hull.Ghull.rvs: hloupá chyba 7494eef4e2621ac9651037cd4a99e9f570704dee I am 2021-06-21 01:37:49
convex_hull.Ghull.rvs: ensure at least one node outside 1c6d05935c83d11637ae566528cf65eb384215b5 I am 2021-06-19 19:04:40
convex_hull.Ghull: add nonGaussian hulls support, fix MC integration 3e10c2cefff5f3e204c1d4118b195e37023a5a57 I am 2021-06-19 17:44:09
mart: add qhull polygon c3da6bdd1b6412f178c828c1eb1a6368a02eb74c I am 2021-06-18 23:27:48
dicebox.Goal: implement csv export odhadů abdb28f509e664c039a6e5ca4bf1036d00957349 I am 2021-06-15 15:06:15
reader: add export_estimation function. Jednoduchý jako busy ef8fcada4b01be8db29836aa09459d8a7ef382b6 I am 2021-06-15 03:08:53
convex_hull: add meaningless method 96a86b7eabceb15e6c937932c2002409c2df0178 I am 2021-06-14 16:35:39
dicebox: new brand box named Goal is ready 725c2561b62769af6034c690005d1d22e6af41c7 I am 2021-06-05 13:40:15
convex_hull: last node fix in fire() function ca938c11398dfb2e16441b989902dab1558336b3 I am 2021-06-05 13:25:55
convex_hull: small fix for QHull under single simplex integration b0b236cd14ae614ecd1310b8c7cfcafe8d1b0851 I am 2021-05-30 05:57:45
convex_hull: ensure Ghull to always have some nodes for expansion 7110d521d9fece58639a359c83773df904b1177f I am 2021-05-29 07:03:49
dicebox: throw away plot dependency, simplify increment function 1cf0c481b8df1937ff7eda6e0373d5d6a72387db I am 2021-05-28 16:42:19
simplex: add JustCubatureTriangulation class separated from Shull ea291f9deee9f3b5b8615ae1f14a49aecd327461 I am 2021-05-28 16:39:58
mart: add convex_hull routines 90105552e7aecf3df8e84a1f5c4bdc1b04be249b I am 2021-04-25 20:11:34
convex_hull.Ghull: try to outthink OS's memory management 116444dc08cc0261e149de02f21f14f74dc8816b I am 2021-04-25 08:02:25
convex_hull.Ghull: in case of memory error divide ns by 3 0f629139f7926107b0b4eeb55452e745a2c23487 I am 2021-04-25 06:50:02
convex_hull: memory failsafe integration 7624e4b81526d3944f1a5ac74d298dee792c3085 I am 2021-04-24 08:06:27
simplex: delete ghull-related stuff (moved to convex_hull module already) f514adf959a9a2a9b7806b3cde81f78faf04539d I am 2021-04-19 17:04:54
convex_hull.QHull: change enough_points into property ae4f9b4d70bb43556874bc6d698cb1cc09ad9430 I am 2021-04-19 17:02:35
Commit 3fc5eb00de1eb65cff2db71640c340602687f52f - spring: new brand hustý modul pro vyrovnání odhadů
Author: I am
Author date (UTC): 2021-06-25 00:52
Committer name: I am
Committer date (UTC): 2021-06-25 00:52
Parent(s): 7494eef4e2621ac9651037cd4a99e9f570704dee
Signer:
Signing key:
Signing status: N
Tree: 8141c0d2c026cbb16d6a5a0b01d53b48cece464a
File Lines added Lines deleted
spring.py 348 0
File spring.py added (mode: 100644) (index 0000000..49a0736)
1 #!/usr/bin/env python
2 # coding: utf-8
3
4 import numpy as np
5
6
7 #č v statistice rozptyl jednotlyvých měření charakterizuje přesnost
8 # https://en.wikipedia.org/wiki/Inverse-variance_weighting
9 #č z teorii chyb měření
10 #č mame-li změřené dvě části l_1 a l_2, co musejí dohromady dat L,
11 #č můžeme spočítat odchylku delta = L - l_1 - l_2
12 #č Znamé-li přesnost jednotlivých měření 1/var_1 a 1/var_2,
13 #č můžeme tvrdit, že opravy jsou:
14 # v_1 = delta * var_1 / (var_1 + var_2)
15 # v_2 = delta * var_2 / (var_1 + var_2)
16 #č a tedy, že výrovnáné hodnoty jsou:
17 # l_1' = l_1 + v_1
18 # l_2' = l_2 + v_2
19 #č problemem je, že takovéto lineární vyrovnání může davat záporné hodnoty
20
21 #č zkusme hledat řešení v mechanice,
22 #č využijme pružinovou analogii.
23 #č Máme-li soustavu několika (třeba dvou) pružin, zapojených sériově,
24 #č kterou zatížíme sílou F, tak deformace soustavy bude:
25 #č delta_1 + delta_2 = delta = F/k_1 + F/k_2 = F*c_1 + F*c_2
26 # delat_1 = delta * c_1 / (c_1 + c_2)
27 # delat_2 = delta * c_2 / (c_1 + c_2)
28
29 #č takhle jsme přišli na ekvivalenci nějakého lineárního vyrovnavaní
30 #č a sériové soustavy pružin.
31 #č A teď ten trik - uvažovat deformace těch pružin nelineárně,
32 #č znemožnit stlačení do záporných délek
33
34 # d_epsilon = d_l / l
35 #č True strain = ln(l/L) = ln(l) - ln(L), kde
36 #č l je delka pružiny (prutu) po deformaci
37 #č L je původní délka
38
39 #č definujme sílu jako F = strain(epsilon) * tuhost(EA), tj.
40 # k = EA/l
41 # poddajnost(c) = původní_délka(l) / EA
42 # EA = l / c
43 #č EA vnímáme jako přirozenou charakteristiku, vlastnost
44 #č u těch charakteristik tuhostí-poddajností
45 #č lze všimnout jistou analogii s betama (nebo s CoV),
46 #č ale liší se jednotky, dělíme rozptílem, nikoliv směrodatnou odchylkou!
47 #č nebo epsilon = F * poddajnost(c) / původní_délka(l)
48 #č (výpočet za použití poddajností je hodně jednodušší a přehlednější)
49 #č řešíme soustavu rovnic
50 # l_1 + l_2 + l_100500 = L
51 # F_1 = F_2 = F_100500 = F
52 #č zde L je délka soustavy
53 #č F je síla, působicí na soustavu
54
55
56 def get_true_strain_spring_solution(lenghts, flexibilities, L=1):
57 """calculates corrected data for bounded statistically estimated values.
58 It uses nonlinear spring analogy, based on logarithmic strain ε,
59 also called, true strain or Hencky strain"""
60 #č tohle musí hlídat volající kód
61 assert np.all(np.isfinite(lenghts)) and np.all(lenghts > 0)
62 assert np.all(np.isfinite(flexibilities)) and np.all(flexibilities > 0)
63
64 Ls = lenghts #č původní
65 ls = lenghts #č vystupní
66 cs = flexibilities
67 #č EA vnímáme jako přirozenou charakteristiku, vlastnost
68 #č EA jsou z hlediska statistiky vahami
69 EAs = lenghts / flexibilities
70 #L = L
71
72 i = 0 #č počet iterací
73 sum_ls = np.sum(ls)
74
75
76
77 #č V tlaku - (záporný) přírůstek síly může (ale nemusí!) narůstat
78 #č v tahu Newtonová metoda může nejdřív soustavu
79 #č roztahnout do nekonečna a teprve pak stlačovat zpatky
80 #č Právě kvůli tomu v tahu můžou vylezt nekonečna
81 #č Jistě máme epsilon bound, definovaný jako delta_L / min(lenghts):
82 #
83 # linear_epsilon_max = delta_L / min(lenghts),
84 #
85 #č ale nemůžeme jej použit přímo pro výpočet síly,
86 #č F_max vždy vyjde větší jak samotné F-ko za normálního výpočtu:
87 #
88 # F = delta_L / np.sum(cs)
89 # F_max = max(delta_L / flexibilities)
90 # F_supermax = linear_epsilon_max * max(EAs)
91 # F_supermax = delta_L / min(lenghts) * max(lenghts / flexibilities)
92 # F <= F_max <= F_supermax
93 #
94
95
96 # let's try first approximation
97 #č Mám dojem, že se známenko může změnit pouze po první iteraci
98 #č Zde může být jak tlak, tak i tah, dále - pouze tlak
99 if sum_ls != L:
100 #č zaporná - zkracovat, kladná - prodlužovat
101 delta_L = L - sum_ls
102 # linear approximation
103 #č odhadneme sílu
104 F = delta_L / np.sum(cs)
105
106 #č aha. To je právě ta věc.
107 #č nemůžeme rovnou spočítat délky
108 #č musíme jít bočnou cestou přes true strain
109 # delta_i = F * c_i
110 #ls += F * c #ё нихрена подобного!
111
112 #č epsilon = F * poddajnost(c) / původní_délka(l)
113 epsilons = F / EAs
114 ls = np.exp(epsilons) * Ls
115
116 i += 1 #č počet iterací
117 sum_ls = np.sum(ls)
118 print("spring:", i, "delta", delta_L, "F", F)
119
120 #č nechcu explicitně výjadřovat přesnost
121 #č raději budu sledovat vyši přírůstků.
122 #č neplatí, že první iterace musí být větší jak ty další
123 #č V tlaku - (záporný) přírůstek síly může (ale nemusí!) narůstat
124 #č Doufám, že žádná nekonečna, nanky zde nevylezou
125 delta_F = -1 #č ať projdeme kontrolou
126 while (sum_ls != L) and (delta_F < 0): # while 1 + 1e-20 != 1
127 #č zaporná - zkracovat, kladná - prodlužovat
128 delta_L = L - sum_ls
129
130 cs = ls / EAs
131 # linear approximation
132 #č teď bacha, sílu musíme počítat v přirůstcích
133 delta_F = delta_L / np.sum(cs)
134 F += delta_F
135
136 #č epsilon = F * poddajnost(c) / původní_délka(l)
137 epsilons = F / EAs
138 ls = np.exp(epsilons) * Ls
139
140 i += 1 #č počet iterací
141 sum_ls = np.sum(ls)
142 print("spring:", i, "delta", delta_L, "F", F)
143
144 return ls
145
146
147
148 def get_semi_true_strain_spring_solution(lenghts, flexibilities, L=1):
149 """calculates corrected data for bounded statistically estimated values.
150 It uses nonlinear spring analogy, based on true strain in compression
151 and engineering (Cauchy) strain in tension"""
152
153 sum_ls = np.sum(lenghts)
154 if sum_ls == L:
155 print("spring: no action needed")
156 return lenghts
157
158 #č tohle musí hlídat volající kód
159 assert np.all(np.isfinite(lenghts)) and np.all(lenghts > 0)
160 assert np.all(np.isfinite(flexibilities)) and np.all(flexibilities > 0)
161
162 Ls = lenghts #č původní
163 ls = lenghts #č vystupní
164 cs = flexibilities
165
166
167 #č v tahu Newtonová metoda mohla by nejdřív soustavu
168 #č roztahnout do nekonečna a teprve pak stlačovat zpatky
169 #č Právě kvůli tomu v tahu mohly by vylezt nekonečna
170 #
171 #č Zde pointa je v tom, že nepotřebujeme precizní pružiny,
172 #č postačí nám, když tlak budeme omezovat,
173 #č aby nám délky neujely do záporných hodnot,
174 #č zatímco v tahu jednoduše použit lineárné řešení
175
176 #č zaporná - zkracovat, kladná - prodlužovat
177 delta_L = L - sum_ls
178 # linear approximation
179 #č odhadneme sílu
180 F = delta_L / np.sum(cs)
181
182 if F > 0: #č je třeba roztahovat
183 ls += F * cs
184 print("spring: tension; linear solution is used.", "Delta=", delta_L)
185 return ls
186
187 else: #compression, prepare for iteration
188 #č EA vnímáme jako přirozenou charakteristiku, vlastnost
189 #č EA jsou z hlediska statistiky vahami
190 EAs = lenghts / flexibilities
191
192 #č epsilon = F * poddajnost(c) / původní_délka(l)
193 epsilons = F / EAs
194 ls = np.exp(epsilons) * Ls
195
196 i = 1 #č počet iterací
197 sum_ls = np.sum(ls)
198 print("spring: compression #", i, "delta=", delta_L, "F=", F)
199
200 #č nechcu explicitně výjadřovat přesnost
201 #č raději budu sledovat vyši přírůstků.
202 #č neplatí, že první iterace musí být větší jak ty další
203 #č V tlaku - (záporný) přírůstek síly může (ale nemusí!) narůstat
204 #č Mám dojem, že se známenko může změnit pouze po první iteraci
205 #č Doufám, že žádná nekonečna, nanky zde nevylezou
206 delta_F = -1 #č ať projdeme kontrolou
207 while (sum_ls != L) and (delta_F < 0): # while 1 + 1e-20 != 1
208 #č zaporná - zkracovat, kladná - prodlužovat
209 delta_L = L - sum_ls
210
211 cs = ls / EAs
212 # linear approximation
213 #č teď bacha, sílu musíme počítat v přirůstcích
214 delta_F = delta_L / np.sum(cs)
215 F += delta_F
216
217 #č epsilon = F * poddajnost(c) / původní_délka(l)
218 epsilons = F / EAs
219 ls = np.exp(epsilons) * Ls
220
221 i += 1 #č počet iterací
222 sum_ls = np.sum(ls)
223 print("spring: compression #", i, "delta=", delta_L, "F=", F)
224
225 return ls
226
227
228 #č je to implicitní volba
229 get_spring_solution = get_semi_true_strain_spring_solution
230
231
232 #č Mohli bychom počítat v tlaku Eulerem, v tahu - Greenem.
233 #оӵ Кинлы со меда кулэ?
234 #
235 #def get_euler_almansi_strain_spring_solution(lenghts, flexibilities, L=1):
236 # """calculates corrected data for bounded statistically estimated values.
237 # It uses nonlinear spring analogy, based on Euler-Almansi strain"""
238 # #č tohle musí hlídat volající kód
239 # assert np.all(np.isfinite(lenghts)) and np.all(lenghts > 0)
240 # assert np.all(np.isfinite(flexibilities)) and np.all(flexibilities > 0)
241 #
242 # Ls = lenghts #č původní
243 # ls = lenghts #č vystupní
244 # cs = flexibilities
245 # #č EA vnímáme jako přirozenou charakteristiku, vlastnost
246 # #č EA jsou z hlediska statistiky vahami
247 # EAs = lenghts / flexibilities
248 # #L = L
249 #
250 # i = 0 #č počet iterací
251 # sum_ls = np.sum(ls)
252 #
253 #
254 # # Euler-Almansi strain
255 # # epsilon_EA = (l**2 - L**2) / 2 / l**2
256 #
257 #
258 # #č V tlaku - (záporný) přírůstek síly může (ale nemusí!) narůstat
259 # #č v tahu Newtonová metoda může nejdřív soustavu
260 # #č roztahnout do nekonečna a teprve pak stlačovat zpatky
261 # #č Právě kvůli tomu v tahu můžou vylezt nekonečna
262 # #č Jistě máme epsilon bound, definovaný jako delta_L / min(lenghts):
263 # #
264 # # linear_epsilon_max = delta_L / min(lenghts),
265 # #
266 # #č ale nemůžeme jej použit přímo pro výpočet síly,
267 # #č F_max vždy vyjde větší jak samotné F-ko za normálního výpočtu:
268 # #
269 # # F = delta_L / np.sum(cs)
270 # # F_max = max(delta_L / flexibilities)
271 # # F_supermax = linear_epsilon_max * max(EAs)
272 # # F_supermax = delta_L / min(lenghts) * max(lenghts / flexibilities)
273 # # F <= F_max <= F_supermax
274 # #
275 # #č
276 #
277 # while (sum_ls < L) and (delta_F < 0): #č je třeba roztahovat
278 # #č zaporná - zkracovat, kladná - prodlužovat
279 # #č takže delta_L musí být kladná
280 # delta_L = L - sum_ls
281 #
282 # cs = ls / EAs
283 # # linear approximation
284 # #č teď bacha, sílu musíme počítat v přirůstcích
285 # delta_F = delta_L / np.sum(cs)
286 # F += delta_F
287 #
288 # #č epsilon = F * poddajnost(c) / původní_délka(l)
289 # epsilons = F / EAs
290 # ls = np.exp(epsilons) * Ls
291 #
292 # i += 1 #č počet iterací
293 # sum_ls = np.sum(ls)
294 # print("spring:", i, "delta", delta_L, "F", F)
295 #
296 #
297 # # let's try first approximation
298 # if sum_ls != L:
299 # #č zaporná - zkracovat, kladná - prodlužovat
300 # delta_L = L - sum_ls
301 # # linear approximation
302 # #č odhadneme sílu
303 # F = delta_L / np.sum(cs)
304 #
305 # #č aha. To je právě ta věc.
306 # #č nemůžeme rovnou spočítat délky
307 # #č musíme jít bočnou cestou přes true strain
308 # # delta_i = F * c_i
309 # #ls += F * c #ё нихрена подобного!
310 #
311 # #č epsilon = F * poddajnost(c) / původní_délka(l)
312 # epsilons = F / EAs
313 # ls = np.exp(epsilons) * Ls
314 #
315 # i += 1 #č počet iterací
316 # sum_ls = np.sum(ls)
317 # print("spring:", i, "delta", delta_L, "F", F)
318 #
319 # #č nechcu explicitně výjadřovat přesnost
320 # #č raději budu sledovat vyši přírůstků.
321 # #č neplatí, že první iterace musí být větší jak ty další
322 # #č V tlaku - (záporný) přírůstek síly může (ale nemusí!) narůstat
323 # #č v tahu, tuším, tahle Newtonová metoda může nejdřív soustavu
324 # #č roztahnout do nekonečna a teprve pak stlačovat zpatky
325 # #č Mám dojem, že se známenko může změnit pouze po první iteraci
326 # #č Doufám, že žádná nekonečna, nanky zde nevylezou
327 # delta_F = -1 #č ať projdeme kontrolou
328 # while (sum_ls != L) and (delta_F < 0): # while 1 + 1e-20 != 1
329 # #č zaporná - zkracovat, kladná - prodlužovat
330 # delta_L = L - sum_ls
331 #
332 # cs = ls / EAs
333 # # linear approximation
334 # #č teď bacha, sílu musíme počítat v přirůstcích
335 # delta_F = delta_L / np.sum(cs)
336 # F += delta_F
337 #
338 # #č epsilon = F * poddajnost(c) / původní_délka(l)
339 # epsilons = F / EAs
340 # ls = np.exp(epsilons) * Ls
341 #
342 # i += 1 #č počet iterací
343 # sum_ls = np.sum(ls)
344 # print("spring:", i, "delta", delta_L, "F", F)
345 #
346 # return ls
347
348
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