def strains(self): mfn = MFnLineArray() mfn.xdata, mfn.ydata = self.values strains_fn = frompyfunc(mfn.get_diff, 1, 1) strains = strains_fn(mfn.xdata) strains[0] = strains[1] strains[-2] = strains[-1] return strains
def ppf( self, x ): self.check() if len( self.cdf_values ) != 0: xx, cdf = self.x_values, self.cdf_values else: xx, cdf = self.x_values, self.cdf( self.x_values ) ppf_mfn_line = MFnLineArray( xdata = cdf, ydata = xx ) return ppf_mfn_line.get_values( x )
def _get_cached_pdf( self ): if len( self.pdf_values ) == 0: cdf_line = MFnLineArray( xdata = self.x_values, ydata = self.cdf_values ) pdf = [] for x in self.x_values: pdf.append( cdf_line.get_diff( x ) ) return MFnLineArray( xdata = self.x_values, ydata = pdf ) else: return MFnLineArray( xdata = self.x_values, ydata = self.pdf_values )
def _get_pdf_array( self ): # get the normed histogram implemented in the base class YMBHist h, b = self.normed_hist b_cen = ( b[1:] + b[:-1] ) / 2. mask = ( h != 0. ) h = h[mask] b_cen = b_cen[mask] b = hstack( [min( b ), b_cen, max( b )] ) h = hstack( [0, h, 0] ) h = h / trapz( h, b ) p = MFnLineArray( xdata=b, ydata=h ) return p.get_values( self.x_array )
n = 200 # number of increments s_levels = np.linspace(0, 0.00125, 2) s_levels.reshape(-1, 2)[:, 0] = 0.0 #s_levels.reshape(-1, 2)[:, 1] = -0.005 s_levels[0] = 0 s_history_1 = s_levels.flatten() d_array = np.hstack([ np.linspace(s_history_1[i], s_history_1[i + 1], n) for i in range(len(s_levels) - 1) ]) t_max = 1.0 t_arr = np.linspace(0, t_max, len(d_array)) print 't_arr ', t_arr time_func = MFnLineArray(xdata=t_arr, ydata=d_array) time_func.extrapolate = 'constant' print 'time_func', time_func time_func_2 = interp1d(t_arr, d_array) print 'time_func_2', time_func_2 # ts.bc_list = [BCDof(var='u', dof=0, value=0.0), BCDof(var='f', dof=n_dofs - 1, time_function=loading_scenario.time_func)] if False: tloop.bc_list = [ BCSlice(slice=dots.mesh[0, :, 0, :], var='u', dims=[0, 1], value=0), BCSlice(slice=dots.mesh[25, -1, :, -1], var='u', dims=[1], value=-50),
def _mfn_default(self): return MFnLineArray()
def example_with_new_domain(): from ibvpy.api import \ TStepper as TS, RTraceDomainListField, TLoop, TLine from ibvpy.mats.mats2D5.mats2D5_bond.mats2D_bond import MATS2D5Bond from ibvpy.api import BCDofGroup from ibvpy.fets.fets2D.fets2D4q import FETS2D4Q fets_eval = FETS2DTF(parent_fets=FETS2D4Q(), mats_eval=MATS2D5Bond(E_m=30, nu_m=0.2, E_f=10, nu_f=0.1, G=10.)) from ibvpy.mesh.fe_grid import FEGrid from mathkit.mfn import MFnLineArray # Discretization fe_grid = FEGrid(coord_max=(10., 4., 0.), n_elems=(10, 3), fets_eval=fets_eval) mf = MFnLineArray( # xdata = arange(10), ydata=array([0, 1, 2, 3])) tstepper = TS( sdomain=fe_grid, bcond_list=[ BCDofGroup(var='u', value=0., dims=[0, 1], get_dof_method=fe_grid.get_left_dofs), # BCDofGroup( var='u', value = 0., dims = [1], # get_dof_method = fe_grid.get_bottom_dofs ), BCDofGroup(var='u', value=.005, dims=[0], time_function=mf.get_value, get_dof_method=fe_grid.get_right_dofs) ], rtrace_list=[ # RTDofGraph(name = 'Fi,right over u_right (iteration)' , # var_y = 'F_int', idx_y = right_dof, # var_x = 'U_k', idx_x = right_dof, # record_on = 'update'), # RTraceDomainListField(name = 'Stress' , # var = 'sig_app', idx = 0, # #position = 'int_pnts', # record_on = 'update'), # RTraceDomainListField(name = 'Damage' , # var = 'omega', idx = 0, # record_on = 'update', # warp = True), RTraceDomainListField(name='Displ matrix', var='u_m', idx=0, record_on='update', warp=True), RTraceDomainListField(name='Displ reinf', var='u_f', idx=0, record_on='update', warp=True), # RTraceDomainListField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ]) # Add the time-loop control #global tloop tloop = TLoop(tstepper=tstepper, KMAX=300, tolerance=1e-4, tline=TLine(min=0.0, step=1.0, max=1.0)) #import cProfile #cProfile.run('tloop.eval()', 'tloop_prof' ) print(tloop.eval()) #import pstats #p = pstats.Stats('tloop_prof') # p.strip_dirs() # print 'cumulative' # p.sort_stats('cumulative').print_stats(20) # print 'time' # p.sort_stats('time').print_stats(20) # Put the whole thing into the simulation-framework to map the # individual pieces of definition into the user interface. # from ibvpy.plugins.ibvpy_app import IBVPyApp app = IBVPyApp(ibv_resource=tloop) app.main()
def _get_PDFx(self): pdfx_line = MFnLineArray(xdata=self.x_values, ydata=self.pdf_x) return pdfx_line
def _get_transf_line(self): x = np.linspace(self.x_values[0], self.x_values[-1], 500) y = self.transf_eqn(x) return MFnLineArray(xdata=x, ydata=y, extrapolate='diff')
def _bond_fn_default(self): return MFnLineArray(xdata=[0., 1.], ydata=[0., 1.])
def app(): avg_radius = 0.03 md = MATS2DScalarDamage( E=20.0e3, nu=0.2, epsilon_0=1.0e-4, epsilon_f=8.0e-4, #epsilon_f = 12.0e-4, #test doubling the e_f stress_state="plane_strain", stiffness="secant", #stiffness = "algorithmic", strain_norm=Rankine()) mdm = MATS2DMicroplaneDamage( E=20.0e3, nu=0.2, #epsilon_f = 12.0e-4, #test doubling the e_f stress_state="plane_strain", model_version='compliance', phi_fn=PhiFnStrainSoftening(G_f=0.0014, f_t=2.0, md=0.0, h=2. * avg_radius)) # mp = MATSProxy( mats_eval = mdm ) # mp.varpars['epsilon_0'].switch = 'varied' # mp.varpars['epsilon_0'].spatial_fn = MFnNDGrid( shape = ( 8, 5, 1 ), # active_dims = ['x', 'y'], # x_mins = GridPoint( x = 0., y = 0. ), # x_maxs = GridPoint( x = length, y = heigth ) ) # mp.varpars['epsilon_0'].spatial_fn.set_values_in_box( 500., [0, 0, 0], [0.2, 0.2, 0.] ) # mp.varpars['epsilon_0'].spatial_fn.set_values_in_box( 500., [0.8, 0, 0], [1., 0.2, 0.] ) # mp.varpars['epsilon_0'].spatial_fn.set_values_in_box( 50., [0., 0.46, 0], [1., 0.5, 0.] ) # me = MATS2DElastic( E = 20.0e3, # nu = 0.2, # stress_state = "plane_strain" ) fets_eval = FETS2D4Q(mats_eval=mdm) #, ngp_r = 3, ngp_s = 3) n_el_x = 20 # 60 # Discretization fe_grid = FEGrid(coord_max=(.6, .15, 0.), shape=(n_el_x, n_el_x / 4), fets_eval=fets_eval) mf = MFnLineArray(xdata=array([0, 1, 2]), ydata=array([0, 3., 3.2])) #averaging function avg_processor = RTNonlocalAvg( avg_fn=QuarticAF(radius=avg_radius, correction=True)) loading_dof = fe_grid[n_el_x / 2, -1, 0, -1].dofs.flatten()[1] print('loading_dof', loading_dof) ts = TS( sdomain=fe_grid, u_processor=avg_processor, bcond_list=[ # constraint for all left dofs in y-direction: BCSlice(var='u', slice=fe_grid[0, 0, 0, 0], dims=[0, 1], value=0.), BCSlice(var='u', slice=fe_grid[-1, 0, -1, 0], dims=[1], value=0.), BCSlice(var='u', slice=fe_grid[n_el_x / 2, -1, 0, -1], dims=[1], time_function=mf.get_value, value=-2.0e-4), ], rtrace_list=[ RTDofGraph(name='Fi,right over u_right (iteration)', var_y='F_int', idx_y=loading_dof, var_x='U_k', idx_x=loading_dof, record_on='update'), RTraceDomainListField(name='Deformation', var='eps_app', idx=0, record_on='update'), RTraceDomainListField(name='Deformation', var='sig_app', idx=0, record_on='update'), RTraceDomainListField(name='Displacement', var='u', idx=1, record_on='update', warp=True), RTraceDomainListField(name='fracture_energy', var='fracture_energy', idx=0, record_on='update', warp=True), RTraceDomainListField(name='Damage', var='omega_mtx', idx=0, warp=True, record_on='update'), # RTraceDomainField(name = 'Stress' , # var = 'sig', idx = 0, # record_on = 'update'), # RTraceDomainField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ]) # Add the time-loop control # tl = TLoop(tstepper=ts, tolerance=5.0e-5, KMAX=200, tline=TLine(min=0.0, step=.1, max=1.0)) tl.eval() # Put the whole stuff into the simulation-framework to map the # individual pieces of definition into the user interface. # from ibvpy.plugins.ibvpy_app import IBVPyApp ibvpy_app = IBVPyApp(ibv_resource=ts) ibvpy_app.main()
class MATS1D5Bond(MATSEval): ''' Scalar Damage Model. ''' implements(IMATSEval) Ef = Float( 1., #34e+3, label="E", desc="Young's Modulus Fiber", auto_set=False, enter_set=True) Af = Float( 1., #34e+3, label="A", desc="Cross Section Fiber", auto_set=False, enter_set=True) Em = Float( 1., #34e+3, label="E", desc="Young's Modulus Matrix", auto_set=False, enter_set=True) Am = Float( 1., #34e+3, label="A", desc="Cross Section Matrix", auto_set=False, enter_set=True) G = Float( 1., #34e+3, label="G", desc="Shear Stiffness", auto_set=False, enter_set=True) bond_fn = Trait(MFnLineArray(ydata=[0, 1]), label="Bond", desc="Bond Function", auto_set=False) traits_view = View(Item('Ef'), Item('Af'), Item('Em'), Item('Am'), Item('G'), Item('bond_fn', editor=mpl_matplotlib_editor), resizable=True, scrollable=True, height=0.5, width=0.5, buttons=['OK', 'Cancel']) def _bond_fn_default(self): return MFnLineArray(xdata=[0., 1.], ydata=[0., 1.]) # This event can be used by the clients to trigger an action upon # the completed reconfiguration of the material model # changed = Event #--------------------------------------------------------------------------------------------- # View specification #--------------------------------------------------------------------------------------------- #----------------------------------------------------------------------------------------------- # Private initialization methods #----------------------------------------------------------------------------------------------- #----------------------------------------------------------------------------------------------- # Setup for computation within a supplied spatial context #----------------------------------------------------------------------------------------------- def setup(self, sctx): ''' Intialize state variables. ''' def new_cntl_var(self): return zeros(4, float_) #TODO: adapt for 4-5.. def new_resp_var(self): return zeros(4, float_) #TODO: adapt for 4-5.. #----------------------------------------------------------------------------------------------- # Evaluation - get the corrector and predictor #----------------------------------------------------------------------------------------------- def get_corr_pred(self, sctx, eps_app_eng, d_eps, tn, tn1): ''' Corrector predictor computation. @param eps_app_eng input variable - engineering strain ''' if eps_app_eng.shape[0] == 4: D_mtx = zeros((4, 4)) sigma = zeros(4) elif eps_app_eng.shape[0] == 5: D_mtx = zeros((5, 5)) sigma = zeros(5) D_mtx[2, 2] = self.bond_fn.get_diff(eps_app_eng[2]) sigma[2] = self.bond_fn.get_value(eps_app_eng[2]) #tau_m else: print "MATS1D5Bond: Unsupported number of strain components" D_mtx[0, 0] = self.bond_fn.get_diff(eps_app_eng[0]) D_mtx[1, 1] = self.bond_fn.get_diff(eps_app_eng[1]) D_mtx[-2, -2] = self.Ef * self.Af D_mtx[-1, -1] = self.Em * self.Am sigma[0] = self.bond_fn.get_value(eps_app_eng[0]) #tau_l sigma[1] = self.bond_fn.get_value(eps_app_eng[1]) #tau_r sigma[-2] = self.Ef * self.Af * eps_app_eng[-2] #sig_f sigma[-1] = self.Em * self.Am * eps_app_eng[-1] #sig_m # You print the stress you just computed and the value of the apparent E return sigma, D_mtx #--------------------------------------------------------------------------------------------- # Subsidiary methods realizing configurable features #--------------------------------------------------------------------------------------------- def get_sig_app(self, sctx, eps_app_eng, *args, **kw): # @TODO # the stress calculation is performed twice - it might be # cached. sig_eng, D_mtx = self.get_corr_pred(sctx, eps_app_eng, 0, 0, 0) r_pnt = sctx.loc s_tensor = zeros((3, 3)) if r_pnt[1] >= 0.: s_tensor[0, 0] = sig_eng[-1] else: s_tensor[0, 0] = sig_eng[-2] return s_tensor def get_shear(self, sctx, eps_app_eng): # @TODO # the stress calculation is performed twice - it might be # cached. sig_eng, D_mtx = self.get_corr_pred(sctx, eps_app_eng, 0, 0, 0) r_pnt = sctx.loc if eps_app_eng.shape[0] == 4: if r_pnt[0] >= 0.: sig_pos = [sig_eng[1]] else: sig_pos = [sig_eng[0]] elif eps_app_eng.shape[0] == 5: if r_pnt[0] >= 0.5: sig_pos = [sig_eng[1]] elif r_pnt[0] <= -0.5: sig_pos = [sig_eng[0]] else: sig_pos = [sig_eng[2]] return sig_pos def get_eps_app(self, sctx, eps_app_eng): r_pnt = sctx.loc if r_pnt[1] >= 0.: eps_pos = [eps_app_eng[-1]] else: eps_pos = [eps_app_eng[-2]] return eps_pos def get_slip(self, sctx, eps_app_eng): r_pnt = sctx.loc if eps_app_eng.shape[0] == 4: if r_pnt[0] >= 0.: eps_pos = [eps_app_eng[1]] else: eps_pos = [eps_app_eng[0]] if eps_app_eng.shape[0] == 5: if r_pnt[0] >= 0.5: eps_pos = [eps_app_eng[1]] elif r_pnt[0] <= -0.5: eps_pos = [eps_app_eng[0]] else: eps_pos = [eps_app_eng[2]] return eps_pos #--------------------------------------------------------------------------------------------- # Response trace evaluators #--------------------------------------------------------------------------------------------- # Declare and fill-in the rte_dict - it is used by the clients to # assemble all the available time-steppers. # rte_dict = Trait(Dict) def _rte_dict_default(self): return { 'sig_app_t1d': self.get_sig_app, 'eps_app_t1d': self.get_eps_app, 'shear_s': self.get_shear, 'slip_s': self.get_slip, 'msig_pos': self.get_msig_pos, 'msig_pm': self.get_msig_pm }
def example_with_new_domain(): from ibvpy.api import \ TStepper as TS, RTDofGraph, RTraceDomainListField, \ RTraceDomainListInteg, TLoop, \ TLine, BCDof, DOTSEval from ibvpy.mats.mats2D.mats2D_elastic.mats2D_elastic import MATS2DElastic from ibvpy.mats.mats2D.mats2D_sdamage.mats2D_sdamage import MATS2DScalarDamage from ibvpy.api import BCDofGroup mats_eval = MATS2DElastic() fets_eval = FETS2D4Q(mats_eval=mats_eval) #fets_eval = FETS2D4Q(mats_eval = MATS2DScalarDamage()) print(fets_eval.vtk_node_cell_data) from ibvpy.mesh.fe_grid import FEGrid from ibvpy.mesh.fe_refinement_grid import FERefinementGrid from ibvpy.mesh.fe_domain import FEDomain from mathkit.mfn import MFnLineArray # Discretization fe_grid = FEGrid(coord_max=(10., 4., 0.), shape=(10, 3), fets_eval=fets_eval) bcg = BCDofGroup(var='u', value=0., dims=[0], get_dof_method=fe_grid.get_left_dofs) bcg.setup(None) print('labels', bcg._get_labels()) print('points', bcg._get_mvpoints()) mf = MFnLineArray( # xdata = arange(10), ydata=np.array([0, 1, 2, 3])) right_dof = 2 tstepper = TS( sdomain=fe_grid, bcond_list=[ BCDofGroup(var='u', value=0., dims=[0, 1], get_dof_method=fe_grid.get_left_dofs), # BCDofGroup( var='u', value = 0., dims = [1], # get_dof_method = fe_grid.get_bottom_dofs ), BCDofGroup(var='u', value=.005, dims=[1], time_function=mf.get_value, get_dof_method=fe_grid.get_right_dofs) ], rtrace_list=[ RTDofGraph(name='Fi,right over u_right (iteration)', var_y='F_int', idx_y=right_dof, var_x='U_k', idx_x=right_dof, record_on='update'), RTraceDomainListField(name='Stress', var='sig_app', idx=0, position='int_pnts', record_on='update'), # RTraceDomainListField(name = 'Damage' , # var = 'omega', idx = 0, # # record_on = 'update', # warp = True), RTraceDomainListField(name='Displacement', var='u', idx=0, record_on='update', warp=True), RTraceDomainListField(name='Strain energy', var='strain_energy', idx=0, record_on='update', warp=False), RTraceDomainListInteg(name='Integ strain energy', var='strain_energy', idx=0, record_on='update', warp=False), # RTraceDomainListField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ]) # Add the time-loop control #global tloop tloop = TLoop(tstepper=tstepper, KMAX=300, tolerance=1e-4, tline=TLine(min=0.0, step=1.0, max=1.0)) #import cProfile #cProfile.run('tloop.eval()', 'tloop_prof' ) # print tloop.eval() #import pstats #p = pstats.Stats('tloop_prof') # p.strip_dirs() # print 'cumulative' # p.sort_stats('cumulative').print_stats(20) # print 'time' # p.sort_stats('time').print_stats(20) tloop.eval() # Put the whole thing into the simulation-framework to map the # individual pieces of definition into the user interface. # from ibvpy.plugins.ibvpy_app import IBVPyApp app = IBVPyApp(ibv_resource=tloop) app.main()
def reset_stress_strain_curve(self): self._stress_strain_curve = MFnLineArray(ydata=[0., self.E], xdata=[0., 1.])
from mathkit.mfn import MFnLineArray from matresdev.db.exdb.ex_run_view import ExRunView from matresdev.db.exdb.ex_run import ExRun ex_path = os.path.join(simdb.exdata_dir, 'bending_tests', 'three_point', '2012-10-11_BT-3PT-6c-2cm-0-TU_bs', 'BT-6c-2cm-0-TU-V1.csv') exrun = ExRun(ex_path) print 'F_max', np.max(exrun.ex_type.F) eps_c = exrun.ex_type.eps_c_smoothed M = exrun.ex_type.M_smoothed eps_c_M_fn = MFnLineArray(xdata=M, ydata=eps_c) eps_c_M_vct_fn = np.vectorize(eps_c_M_fn.get_value) M_max = M[-1] eps_c_max = np.min(eps_c) n_states = 4 #M_arr = np.linspace(0, M_max, n_states + 1)[1:] cf = np.linspace(0.8, 1.0, n_states) print 'cf', cf M_arr = cf * M_max eps_c_arr = eps_c_M_vct_fn(M_arr) print 'eps_c_max', eps_c_max print 'M_arr', M_arr print 'eps_c_arr', eps_c_arr
def __stress_strain_curve_default(self): return MFnLineArray(ydata=[0., self.E], xdata=[0., 1.])
eps1_sig1 = tl.rtrace_mngr.rtrace_bound_list[1] # eps0_sig0 = tl.rv_mngr.rv_list[0] # eps1_sig1 = tl.rv_mngr.rv_list[1] sig0_midx = argmax(np.fabs(eps0_sig0.trace.ydata)) sig1_midx = argmax(np.fabs(eps1_sig1.trace.ydata)) sig0_m = eps0_sig0.trace.ydata[sig0_midx] sig1_m = eps1_sig1.trace.ydata[sig1_midx] eps0_m = eps0_sig0.trace.xdata[sig0_midx] eps1_m = eps1_sig1.trace.xdata[sig1_midx] sig0_m_list.append(sig0_m) sig1_m_list.append(sig1_m) eps0_m_list.append(eps0_m) eps1_m_list.append(eps1_m) sig_plot = MFnLineArray(xdata=sig0_m_list, ydata=sig1_m_list) eps_plot = MFnLineArray(xdata=eps0_m_list, ydata=eps1_m_list) # sig_plot.configure_traits() print('sig_plot.xdata', sig_plot.ydata) p.plot(sig_plot.xdata, sig_plot.ydata) p.show() # Put the time-loop into the simulation-framework and map the # object to the user interface. #
TStepper as TS, RTraceGraph, RTraceDomainListField, TLoop, \ TLine, BCDofGroup, IBVPSolve as IS, DOTSEval from ibvpy.fets.fets3D import FETS3D8H16U from mathkit.mfn import MFnLineArray #from lib.mats.mats2D.mats_cmdm2D.mats_mdm2d import MACMDM from ibvpy.mats.mats2D.mats2D_sdamage.mats2D_sdamage import MATS2DScalarDamage from ibvpy.mats.mats2D.mats2D_sdamage.strain_norm2d import * from ibvpy.mats.mats3D.mats3D_elastic.mats3D_elastic import MATS3DElastic, MATS3DElasticNL E = 28e+3 fets_eval = FETS3D8H16U( mats_eval=MATS3DElasticNL(stress_strain_curve=MFnLineArray( ydata=[E, 0., 0.1], xdata=[-1, 0., 1.])), ) from ibvpy.mesh.fe_grid import FEGrid # Discretization domain = FEGrid(coord_max=(3., 3., 3.), shape=(3, 3, 3), fets_eval=fets_eval) # Put the tseval (time-stepper) into the spatial context of the # discretization and specify the response tracers to evaluate there. right_dof = 2 ts = TS( sdomain=domain, # conversion to list (square brackets) is only necessary for slicing of # single dofs, e.g "get_left_dofs()[0,1]" which elsewise retuns an integer only
def _mfn_default(self): return MFnLineArray(xdata=[0, 1], ydata=[1, 1])
def _get_mfn_line_array_target(self): xdata, ydata = self.get_target_data_exdb_tensile_test() print 'xdata[-1]', xdata[-1] return MFnLineArray(xdata=xdata, ydata=ydata)
def app(): avg_radius = 0.03 md = MATS2DScalarDamage(E=20.0e3, nu=0.2, epsilon_0=1.0e-4, epsilon_f=8.0e-4, #epsilon_f = 12.0e-4, #test doubling the e_f stress_state="plane_strain", stiffness="secant", #stiffness = "algorithmic", strain_norm=Rankine()) me = MATS2DElastic(E=20.0e3, nu=0.2, stress_state="plane_strain") fets_eval = FETS2D4Q(mats_eval=md)#, ngp_r = 3, ngp_s = 3) n_el_x = 40 # Discretization fe_grid = FEGrid(coord_max=(.6, .2, 0.), shape=(n_el_x, n_el_x / 3), fets_eval=fets_eval) mf = MFnLineArray(xdata=array([0, 1, 2, 3, 4 ]), ydata=array([0, 2., 2.5, 3., 3.2 ])) #averaging function avg_processor = RTNonlocalAvg(avg_fn=QuarticAF(radius=avg_radius, correction=True)) ts = TS(sdomain=fe_grid, u_processor=avg_processor, bcond_list=[ # constraint for all left dofs in y-direction: BCSlice(var='u', slice=fe_grid[0, 0, 0, 0], dims=[0, 1], value=0.), BCSlice(var='u', slice=fe_grid[-1, 0, -1, 0], dims=[1], value=0.), BCSlice(var='u', slice=fe_grid[n_el_x / 2, -1, 0, -1], dims=[1], time_function=mf.get_value, value= -2.0e-5), ], rtrace_list=[ RTraceGraph(name='Fi,right over u_right (iteration)' , var_y='F_int', idx_y=right_dof, var_x='U_k', idx_x=right_dof, record_on='update'), RTraceDomainListField(name='Strain' , var='eps_app', idx=0, record_on='update'), RTraceDomainListField(name='Displacement' , var='u', idx=1, record_on='update', warp=True), RTraceDomainListField(name='Damage' , var='omega', idx=0, record_on='update', warp=True), # RTraceDomainField(name = 'Stress' , # var = 'sig', idx = 0, # record_on = 'update'), # RTraceDomainField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ] ) # Add the time-loop control # tl = TLoop(tstepper=ts, tolerance=5.0e-5, KMAX=50, tline=TLine(min=0.0, step=1., max=10.0)) tl.eval() # Put the whole stuff into the simulation-framework to map the # individual pieces of definition into the user interface. # from ibvpy.plugins.ibvpy_app import IBVPyApp ibvpy_app = IBVPyApp(ibv_resource=ts) ibvpy_app.main()
def _get_mfn(self): return MFnLineArray(xdata=self.eps_arr, ydata=self.sig_arr)