def _child_default( self ):
return SPIRRID()
def run():
# Quantities for the response function
# and randomization
#
E_mod = 70 * 1e+9 # Pa
sig_u = 1.25 * 1e+9 # Pa
D = 26 * 1.0e-6 # m
A = (D / 2.0)**2 * pi
xi_u = sig_u / E_mod
# construct a default response function for a single filament
rf = Filament(E_mod=70.e9, xi=0.02, A=A, theta=0, lambd=0)
# construct the integrator and provide it with the response function.
s = SPIRRID(rf=rf, min_eps=0.00, max_eps=0.05, n_eps=20)
# construct the random variables
n_int = 40
s.add_rv('xi',
distribution='weibull_min',
scale=0.02,
shape=10.,
n_int=n_int)
s.add_rv('E_mod',
distribution='uniform',
loc=70e+9,
scale=15e+9,
n_int=n_int)
s.add_rv('theta', distribution='uniform', loc=0.0, scale=0.01, n_int=n_int)
s.add_rv('lambd', distribution='uniform', loc=0.0, scale=.2, n_int=n_int)
s.add_rv('A',
distribution='uniform',
loc=A * 0.3,
scale=0.7 * A,
n_int=n_int)
# define a tables with the run configurations to start in a batch
run_list = [
({
'cached_dG': False,
'compiled_QdG_loop': True,
'compiled_eps_loop': True
}, 'bx-',
'$\mathrm{C}_{e,\\theta} ( q(e,\\theta) \cdot g[\\theta_1] g[\\theta_2] \dots g[\\theta_n] ) $ - %4.2f sec'
),
(
{
'cached_dG': False,
'compiled_QdG_loop': True,
'compiled_eps_loop': False
},
'r-2',
'$\mathrm{P}_{e} ( \mathrm{C}_{\\theta} ( q(e,\\theta) \cdot g[\\theta_1] g[\\theta_2] \dots g[\\theta_n] ) ) $ - %4.2f sec',
),
(
{
'cached_dG': True,
'compiled_QdG_loop': True,
'compiled_eps_loop': True
},
'go-',
'$\mathrm{C}_{e,\\theta} ( q(e,\\theta) \cdot G[\\theta] ) $ - %4.2f sec',
),
({
'cached_dG': True,
'compiled_QdG_loop': False,
'compiled_eps_loop': False
}, 'y--',
'$\mathrm{P}_{e} ( \mathrm{N}_{\\theta} ( q(e,\\theta) \cdot G[\\theta] ) ) $ - %4.2f sec'
),
]
legend = []
for idx, run in enumerate(run_list):
run_options, plot_options, legend_string = run
print 'run', idx,
s.set(**run_options)
print 'xdata', s.mean_curve.xdata
print 'ydata', s.mean_curve.ydata
s.mean_curve.plot(plt, plot_options)
print 'integral of the pdf theta', s.eval_i_dG_grid()
print 'execution time', s.exec_time
legend.append(legend_string % s.exec_time)
plt.xlabel('strain [-]')
plt.ylabel('stress')
plt.legend(legend)
plt.title(s.rf.title)
plt.show()
from rf_view import RFModelView
from rv_view import RVModelView
from result_view import ResultView
from spirrid_view import SPIRRIDModelView
from quaducom.resp_func.brittle_filament import Filament
# ---------------------------------------
# TREE STRUCTURE FOR SPIRRID VIEW
# ---------------------------------------
if __name__ == '__main__':
# CREATE INSTANCES #
default_rf = Filament()
spirrid = SPIRRID(rf=default_rf, implicit_var_eval=True)
spirrid_view = SPIRRIDModelView(model=spirrid)
result_view = ResultView(spirrid_view=spirrid_view)
# defining classes for tree nodes at first and second level
class SPIRRIDUI(HasTraits):
title = Str('simvisage SPIRRID')
image = Image('pics/spirrid.png')
comp_parts = List()
class Preprocessor(HasTraits):
title = Str('preprocessor')
traits_view = View( VSplit(
HGroup(
Item( 'rv_list', editor = rv_list_editor, show_label = False ),
id = 'rid.tview.randomization.rv',
label = 'Model variables',
),
HGroup(
Item( 'selected_var@', show_label = False, resizable = True ),
id = 'rid.tview.randomization.distr',
label = 'Distribution',
),
scrollable = True,
id = 'rid.tview.tabs',
dock = 'tab',
),
title = 'RANDOM VARIABLES',
id = 'rid.ridview',
dock = 'tab',
resizable = True,
height = 1.0, width = 1.0
)
if __name__ == '__main__':
s = SPIRRID( rf = Filament() )
r = RVModelView( model = s )
r.configure_traits()
def run():
# Quantities for the response function
# and randomization
# construct a default response function for a single filament
rf = ConstantFrictionFiniteFiber(fu=1200e15,
qf=1200,
L=0.02,
A=0.00000002,
E=210.e9,
z=0.004,
phi=0.5,
f=0.01)
# construct the integrator and provide it with the response function.
s = SPIRRID(rf=rf, min_eps=0.00, max_eps=0.0008, n_eps=380)
# construct the random variables
n_int = 25
s.add_rv('E_mod',
distribution='uniform',
loc=170.e9,
scale=250.e9,
n_int=n_int)
s.add_rv('L', distribution='uniform', loc=0.02, scale=0.03, n_int=n_int)
s.add_rv('phi', distribution='sin_distr', loc=0., scale=1., n_int=n_int)
s.add_rv('z', distribution='uniform', loc=0, scale=rf.L / 2., n_int=n_int)
# define a tables with the run configurations to start in a batch
run_list = [
({
'cached_dG': False,
'compiled_QdG_loop': True,
'compiled_eps_loop': True
}, 'bx-',
'$\mathrm{C}_{e,\\theta} ( q(e,\\theta) \cdot g[\\theta_1] g[\\theta_2] \dots g[\\theta_n] ) $ - %4.2f sec'
),
(
{
'cached_dG': False,
'compiled_QdG_loop': True,
'compiled_eps_loop': False
},
'r-2',
'$\mathrm{P}_{e} ( \mathrm{C}_{\\theta} ( q(e,\\theta) \cdot g[\\theta_1] g[\\theta_2] \dots g[\\theta_n] ) ) $ - %4.2f sec',
),
(
{
'cached_dG': True,
'compiled_QdG_loop': True,
'compiled_eps_loop': True
},
'go-',
'$\mathrm{C}_{e,\\theta} ( q(e,\\theta) \cdot G[\\theta] ) $ - %4.2f sec',
),
({
'cached_dG': True,
'compiled_QdG_loop': False,
'compiled_eps_loop': False
}, 'b--',
'$\mathrm{P}_{e} ( \mathrm{N}_{\\theta} ( q(e,\\theta) \cdot G[\\theta] ) ) $ - %4.2f sec'
),
]
for idx, run in enumerate(run_list):
run_options, plot_options, legend_string = run
print 'run', idx,
s.set(**run_options)
s.mean_curve.plot(plt,
plot_options,
linewidth=2,
label=legend_string % s.exec_time)
print 'execution time', s.exec_time
# def f():
# print 'exec_time', s.exec_time
#
# global f
#
# import cProfile
#
# cProfile.run('f()', 'spirrid.tprof')
# import pstats
# p = pstats.Stats('spirrid.tprof')
# p.strip_dirs()
# print 'cumulative'
# p.sort_stats('cumulative').print_stats(50)
# print 'time'
# p.sort_stats('time').print_stats(50)
plt.xlabel('strain [-]')
plt.ylabel('stress')
plt.legend(loc='lower right')
plt.title(s.rf.title)
plt.show()
n_params = len(rf.param_keys)
width = 0.08
time_plot = []
for idx in range(n_params):
offset = idx * width
n_rv = idx + 1
n_int = int(pow(memsize, 1 / float(n_rv)))
print 'n_int', n_int
s = SPIRRID(rf=rf,
min_eps=0.00,
max_eps=1.0,
n_eps=20,
compiler_verbose=0)
for rv in range(n_rv):
param_key = rf.param_keys[rv]
s.add_rv(param_key, n_int=n_int)
time_plot.append(run_study(s, run_dict, offset, width)[1])
plt.figure(0)
plt.plot(range(1,
len(rf.param_keys) + 1),
time_plot,
'-o',
color='black',
linewidth=1)
