def _get_rt_list(self): '''Prepare the list of tracers ''' right_dof = self.fe_grid[-1, -1].dofs[0, 0, 0] eps_app = RTraceDomainListField(name='Strain', position='int_pnts', var='eps_app', warp=False) damage = RTraceDomainListField(name='Damage', position='int_pnts', var='omega', warp=False) disp = RTraceDomainListField(name='Displacement', position='int_pnts', var='u', warp=False) sig_app = RTraceDomainListField(name='Stress', position='int_pnts', var='sig_app') rt_fu = RTraceGraph(name='Fi,right over u_right (iteration)', var_y='F_int', idx_y=right_dof, var_x='U_k', idx_x=right_dof) return [rt_fu, eps_app, damage, sig_app, disp]
def example_with_new_domain(): from ibvpy.api import \ TStepper as TS, RTDofGraph, RTraceDomainListField, TLoop, \ TLine, BCDof, IBVPSolve as IS, DOTSEval from ibvpy.mats.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic fets_eval = FETS1D2L3U(mats_eval=MATS1DElastic(E=10.)) from ibvpy.mesh.fe_grid import FEGrid # Discretization domain = FEGrid(coord_max=(3., ), shape=(3, ), fets_eval=fets_eval) ts = TS(dof_resultants=True, sdomain=domain, # conversion to list (square brackets) is only necessary for slicing of # single dofs, e.g "get_left_dofs()[0,1]" # bcond_list = [ BCDof(var='u', dof = 0, value = 0.) ] + # [ BCDof(var='u', dof = 2, value = 0.001 ) ]+ # [ ) ], bcond_list=[BCDof(var='u', dof=0, value=0.), # BCDof(var='u', dof = 1, link_dofs = [2], link_coeffs = [0.5], # value = 0. ), # BCDof(var='u', dof = 2, link_dofs = [3], link_coeffs = [1.], # value = 0. ), BCDof(var='f', dof=6, value=1, # link_dofs = [2], link_coeffs = [2] )], rtrace_list=[RTDofGraph(name='Fi,right over u_right (iteration)', var_y='F_int', idx_y=0, var_x='U_k', idx_x=1), RTraceDomainListField(name='Stress', var='sig_app', idx=0), RTraceDomainListField(name='Displacement', var='u', idx=0), RTraceDomainListField(name='N0', var='N_mtx', idx=0, record_on='update') ] ) # Add the time-loop control tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=1, max=1.0)) print('---- result ----') print(tloop.eval()) print(ts.F_int) print(ts.rtrace_list[0].trace.ydata) # 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 app = IBVPyApp(ibv_resource=tloop) app.main()
def __demo__(): from ibvpy.api import \ TStepper as TS, RTDofGraph, RTraceDomainListField, TLoop, \ TLine, BCDof from ibvpy.tmodel.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic fets_eval = FETS1D2L(mats_eval=MATS1DElastic(E=10.)) from ibvpy.mesh.fe_grid import FEGrid # Discretization domain = FEGrid(coord_max=(3., ), shape=(3, ), fets_eval=fets_eval) ts = TS(dof_resultants=True, sdomain=domain, bcond_list=[ BCDof(var='u', dof=0, value=0.), BCDof( var='f', dof=3, value=1, ) ], rtrace_list=[ RTDofGraph(name='Fi,right over u_right (iteration)', var_y='F_int', idx_y=0, var_x='U_k', idx_x=1), RTraceDomainListField(name='Stress', var='sig_app', idx=0), RTraceDomainListField(name='Displacement', var='u', idx=0, warp=True), RTraceDomainListField(name='N0', var='N_mtx', idx=0, record_on='update') ]) # Add the time-loop control tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=0.5, max=1.0)) print('---- result ----') print(tloop.eval()) print(ts.F_int) print(ts.rtrace_list[0].trace.ydata) # Put the whole stuff into the simulation-framework to map the # individual pieces of definition into the user interface. # app = IBVPyApp(ibv_resource=tloop) app.main()
def _get_fracture_energy(self): return RTraceDomainListField( name='Fracture energy', # position = 'int_pnts', var='fracture_energy', record_on='update', )
def _get_u(self): return RTraceDomainListField( name='displacement', var='u', warp=True, record_on='update', )
def _get_phi_pdc(self): return RTraceDomainListField( name='principal damage', # position = 'int_pnts', var='phi_pdc', record_on='update', )
def _get_max_omega_i(self): return RTraceDomainListField( name='max_omega_i', # position = 'int_pnts', var='max_omega_i', record_on='update', )
def _get_sig_app(self): return RTraceDomainListField( name='sig_app', position='int_pnts', var='sig_app', record_on='update', )
def _get_max_princ_stress(self): return RTraceDomainListField( name='max principle stress', idx=0, # position = 'int_pnts', var='max_principle_sig', record_on='update', )
def _max_princ_stress_default(self): return RTraceDomainListField( name='max principle stress', idx=0, var='max_principle_sig', warp=True, # position = 'int_pnts', record_on='update', )
slice=interior_bc, link_slice=fe_grid[0, 0], link_coeffs=[0], value=0.0), BCSlice(var='u', dims=[0], slice=fe_grid[-1, -1], value=1.0) ] fe_grid.inactive_elems = list(interior_elems) print('elems', interior_bc.elems) print('dofs', interior_bc.dofs) print('nodes', interior_bc.dof_nodes) rtrace_list = [ RTraceDomainListField( name='sig_app', var='sig_app', record_on='update', ) ] ts = TS( sdomain=fe_grid, bcond_list=bcond_list, rtrace_list=rtrace_list, ) tloop = TLoop(tstepper=ts, ) u = tloop.eval() # from ibvpy.plugins.ibvpy_app import IBVPyApp # ibvpy_app = IBVPyApp( ibv_resource = tloop )
def __demo__(): from ibvpy.api import \ TStepper as TS, RTraceGraph, RTraceDomainListField, TLoop, \ TLine, BCSlice, FEDomain, FERefinementGrid from ibvpy.mats.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic fets_eval = FETS1D2L(mats_eval = MATS1DElastic(E = 10.)) from ibvpy.mesh.fe_grid import FEGrid fe_domain = FEDomain() r1 = FERefinementGrid(fets_eval = fets_eval, domain = fe_domain) r2 = FERefinementGrid(fets_eval = fets_eval, domain = fe_domain) # Discretization domain1 = FEGrid(coord_max = (3.,), shape = (3,), fets_eval = fets_eval, level = r1) domain2 = FEGrid(coord_min = (3.,), coord_max = (6.,), shape = (3,), fets_eval = fets_eval, level = r2) ts = TS(dof_resultants = True, sdomain = fe_domain, bcond_list = [BCSlice(var = 'u', dims = [0], value = 0, slice = domain1[0, 0]), BCSlice(var = 'u', dims = [0], value = 0, slice = domain1[-1, -1], link_slice = domain2[0, 0], link_coeffs = [1.]), BCSlice(var = 'f', dims = [0], value = 1, slice = domain2[-1, -1]) ], rtrace_list = [RTraceGraph(name = 'Fi,right over u_right (iteration)' , var_y = 'F_int', idx_y = 0, var_x = 'U_k', idx_x = 1), RTraceDomainListField(name = 'Stress' , var = 'sig_app', idx = 0), RTraceDomainListField(name = 'Displacement' , var = 'u', idx = 0, warp = True), RTraceDomainListField(name = 'N0' , var = 'N_mtx', idx = 0, record_on = 'update') ] ) # Add the time-loop control tloop = TLoop(tstepper = ts, tline = TLine(min = 0.0, step = 0.5, max = 1.0)) print '---- result ----' print tloop.eval() print ts.F_int print ts.rtrace_list[0].trace.ydata # 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 app = IBVPyApp(ibv_resource = tloop) app.main()
def example_2d(): from ibvpy.api import FEDomain, FERefinementGrid, FEGrid, TStepper as TS, \ BCDofGroup, RTraceDomainListField from ibvpy.core.tloop import TLoop, TLine from ibvpy.mesh.xfe_subdomain import XFESubDomain from ibvpy.mats.mats2D.mats2D_elastic.mats2D_elastic import MATS2DElastic from ibvpy.mats.mats2D import MATS2DPlastic from ibvpy.fets.fets2D.fets2D4q import FETS2D4Q from ibvpy.fets.fets2D import FETS2D9Q from ibvpy.fets.fets2D.fets2D4q8u import FETS2D4Q8U from ibvpy.fets.fets_ls.fets_crack import FETSCrack #fets_eval = FETS2D4Q( mats_eval = MATS2DPlastic( E = 1., nu = 0. ) ) fets_eval = FETS2D4Q8U(mats_eval=MATS2DPlastic(E=1., nu=0.)) xfets_eval = FETSCrack(parent_fets=fets_eval, int_order=5, tri_subdivision=1) # Discretization fe_domain = FEDomain() fe_level1 = FERefinementGrid(domain=fe_domain, fets_eval=fets_eval) fe_grid1 = FEGrid(coord_max=(1., 1.), shape=(8, 8), fets_eval=fets_eval, level=fe_level1) #ls_function = lambda X, Y: X - Y - 0.13 ls_function = lambda X, Y: (X - 0.52)**2 + (Y - 0.72)**2 - 0.51**2 bls_function = lambda X, Y: -((X - 0.5)**2 + (Y - 0.21)**2 - 0.28**2) bls_function2 = lambda X, Y: -((X - 0.5)**2 + (Y - 0.21)**2 - 0.38**2) # design deficits: # - How to define a level set spanned over several fe_grids # (i.e. it is defined over the hierarchy of FESubDomains) # - Patching of subdomains within the FEPatchedGrid (FERefinementGrid) # - What are the compatibility conditions? # - What is the difference between FEGridLeveSetSlice # and FELSDomain? # FELSDomain is associated with a DOTS - Slice is not. # FEGrid has a multidimensional array - elem_grid # it can be accessed through this index. # it is masked by the activity map. The activity map can # be defined using slices and level sets. # the elems array enumerates the elements using the activity map. # in this way, the specialization of grids is available implicitly. # fe_xdomain = FELSDomain( domain=fe_domain, fets_eval=xfets_eval, fe_grid=fe_grid1, ls_function=ls_function, bls_function=bls_function, ) fe_tip_xdomain = FELSDomain( domain=fe_domain, fets_eval=xfets_eval, fe_grid=fe_xdomain, ls_function=bls_function, ) # deactivation must be done only after the dof enumeration has been completed fe_xdomain.deactivate_intg_elems_in_parent() fe_tip_xdomain.deactivate_intg_elems_in_parent() fe_xdomain.bls_function = bls_function2 fe_tip_xdomain.ls_function = bls_function2 # deactivation must be done only after the dof enumeration has been completed fe_xdomain.deactivate_intg_elems_in_parent() fe_tip_xdomain.deactivate_intg_elems_in_parent() # # General procedure: # 1) define the level sets with the boundaries # 2) use the bls to identify the tips of the level set # 3) use independent level sets to introduce indpendently junctions. # # get the extended dofs of the bls_elems and constrain it # cdofs = fe_tip_xdomain.elem_xdof_map.flatten() bc_list = [BCDof(var='u', dof=dof, value=0.0) for dof in cdofs] # construct the time stepper ts = TS( dof_resultants=True, sdomain=fe_domain, bcond_list=[ BCSlice( var='u', value=-0.1, dims=[1], slice=fe_grid1[:, 0, :, 0]), BCSlice( var='u', value=0., dims=[0], slice=fe_grid1[:, 0, :, 0]), BCSlice(var='u', value=0., dims=[0, 1], slice=fe_grid1[:, -1, :, -1]) ] + bc_list, rtrace_list=[ # RTDofGraph(name = 'Fi,right over u_right (iteration)' , # var_y = 'F_int', idx_y = 0, # var_x = 'U_k', idx_x = 1), RTraceDomainListField(name='Stress', var='sig_app', idx=0, warp=True), RTraceDomainListField(name='Displacement', var='u', idx=0, warp=True), # RTraceDomainField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ]) # do = 'print' if do == 'print': p = 'state' if p == 'grids': print('fe_xdomain.ls mask') print(fe_xdomain.ls_mask) print('fe_xdomain.idx mask') print(fe_xdomain.idx_mask) print('fe_xdomain.intg mask') print(fe_xdomain.intg_mask) print('fe_xdomain.xelems_mask') print(fe_xdomain.xelems_mask) print('fe_xdomain.xelems_grid_ix') print(fe_xdomain.xelems_grid_ix) print('fe_xdomain.ls_elem_grid') print(fe_xdomain.ls_elem_grid) print('fe_xdomain.ls_ielem_grid') print(fe_xdomain.ls_ielem_grid) print('fe_xdomain.intg_elem_grid') print(fe_xdomain.intg_elem_grid) print('fe_tip_xdomain.ls_mask`') print(fe_tip_xdomain.ls_mask) print('fe_tip_xdomain.intg_mask`') print(fe_tip_xdomain.intg_mask) print('fe_tip_xdomain.idx_mask`') print(fe_tip_xdomain.idx_mask) print('fe_tip_xdomain.xelems_mask') print(fe_tip_xdomain.xelems_mask) print('fe_tip_xdomain.xelems_grid_ix') print(fe_tip_xdomain.xelems_grid_ix) print('fe_tip_xdomain.ls_elem_grid') print(fe_tip_xdomain.ls_elem_grid) print('fe_tip_xdomain.ls_ielems_grid') print(fe_tip_xdomain.ls_ielem_grid) print('fe_tip_xdomain.intg_elem_grid') print(fe_tip_xdomain.intg_elem_grid) if p == 'maps': print('fe_xdomain.elem_dof_map') print(fe_xdomain.elem_dof_map) print('fe_tip_xdomain.elem_dof_map') print(fe_tip_xdomain.elem_dof_map) print('fe_xdomain.elems') print(fe_xdomain.elems) print('fe_tip_xdomain.elems') print(fe_tip_xdomain.elems) print('fe_xdomain.elem_X_map') print(fe_xdomain.elem_X_map) print('fe_tip_xdomain.elem_X_map') print(fe_tip_xdomain.elem_X_map) if p == 'fields': print("ls_values ", fe_xdomain.dots.dof_node_ls_values) print("tip ls_values ", fe_tip_xdomain.dots.dof_node_ls_values) print('intersection points ', fe_xdomain.ls_intersection_r) print('tip intersection points ', fe_tip_xdomain.ls_intersection_r) print("triangles ", fe_xdomain.dots.rt_triangles) print("vtk points ", fe_xdomain.dots.vtk_X) print("vtk data ", fe_xdomain.dots.get_vtk_cell_data('blabla', 0, 0)) print('ip_triangles', fe_xdomain.dots.int_division) print('ip_coords', fe_xdomain.dots.ip_coords) print('ip_weigths', fe_xdomain.dots.ip_weights) print('ip_offset', fe_xdomain.dots.ip_offset) print('ip_X_coords', fe_xdomain.dots.ip_X) print('ip_ls', fe_xdomain.dots.ip_ls_values) print('vtk_ls', fe_xdomain.dots.vtk_ls_values) print('J_det ', fe_xdomain.dots.J_det_grid) if p == 'state': # Add the time-loop control print('STATE: initial') print('fe_xdomain.dots.state_elem grid') print(fe_xdomain.dots.state_start_elem_grid) print('fe_tip_xdomain.dots.state_elem grid') print(fe_tip_xdomain.dots.state_start_elem_grid) print('fe_xdomain.dots.state_end_elem grid') print(fe_xdomain.dots.state_end_elem_grid) print('fe_tip_xdomain.dots.state_end_elem grid') print(fe_tip_xdomain.dots.state_end_elem_grid) fe_xdomain.dots.state_array[:] = 25.5 print('state_array 25', fe_xdomain.dots.state_array) fe_tip_xdomain.dots.state_array[:] = 58 bls_function3 = lambda X, Y: -((X - 0.5)**2 + (Y - 0.21)**2 - 0.58**2) fe_xdomain.bls_function = bls_function3 fe_tip_xdomain.ls_function = bls_function3 print('STATE: changed') print('fe_xdomain.dots.state_elem grid') print(fe_xdomain.dots.state_start_elem_grid) print('fe_tip_xdomain.dots.state_elem grid') print(fe_tip_xdomain.dots.state_start_elem_grid) print('fe_xdomain.dots.state_end_elem grid') print(fe_xdomain.dots.state_end_elem_grid) print('fe_tip_xdomain.dots.state_end_elem grid') print(fe_tip_xdomain.dots.state_end_elem_grid) print('state_array 25', fe_xdomain.dots.state_array.shape) print('state_array 25', fe_xdomain.dots.state_array[570:]) print('state_array 58', fe_tip_xdomain.dots.state_array.shape) elif do == 'ui': tloop = TLoop(tstepper=ts, debug=False, tolerance=1e-4, KMAX=3, RESETMAX=0, tline=TLine(min=0.0, step=1, max=1.0)) tloop.eval() from ibvpy.plugins.ibvpy_app import IBVPyApp ibvpy_app = IBVPyApp(ibv_resource=ts) ibvpy_app.main()
def _get_tloop(self): #-------------------------------------------------------------- # ts #-------------------------------------------------------------- mid_zone_spec = self.mid_zone_specmn_fe_grid load_zone_spec = self.load_zone_specmn_fe_grid outer_zone_spec = self.outer_zone_specmn_fe_grid if self.elstmr_flag: # ELSTRMR TOP SURFACE # dofs at elastomer top surface (used to integrate the force) # elastomer = self.elstmr_fe_grid elstmr_top_dofs_z = elastomer[:, :, -1, :, :, -1].dofs[:, :, 2].flatten() load_dofs_z = np.unique(elstmr_top_dofs_z) print 'load_dofs_z', load_dofs_z else: # LINE LOAD TOP OF LOAD ZONE # dofs at center line of the specmn load zone (used to integrate the force) # note slice index in x-direction is only valid for load_zone_shape_x = 2 ! # load_zone_spec_topline_dofs_z = load_zone_spec[ 0, :, -1, -1, :, -1].dofs[:, :, 2].flatten() load_dofs_z = np.unique(load_zone_spec_topline_dofs_z) print 'load_dofs_z', load_dofs_z # SUPPRT LINE # dofs at support line of the specmn (used to integrate the force) # outer_zone_spec_supprtline_dofs_z = outer_zone_spec[ -1, :, 0, -1, :, 0].dofs[:, :, 2].flatten() supprt_dofs_z = np.unique(outer_zone_spec_supprtline_dofs_z) print 'supprt_dofs_z', supprt_dofs_z # CENTER DOF (used for tracing of the displacement) # center_bottom_dof = mid_zone_spec[0, 0, 0, 0, 0, 0].dofs[0, 0, 2] print 'center_bottom_dof', center_bottom_dof # THIRDPOINT DOF (used for tracing of the displacement) # dofs at center middle of the laod zone at the bottom side # # NOTE: slice index in x-direction is only valid for load_zone_shape_x = 2 ! thirdpoint_bottom_dof = load_zone_spec[0, 0, 0, -1, 0, 0].dofs[0, 0, 2] print 'thirdpoint_bottom_dof', thirdpoint_bottom_dof # force-displacement-diagram (CENTER) # self.f_w_diagram_center = RTraceGraph( name='displacement_elasttop (center) - force', var_x='U_k', idx_x=center_bottom_dof, var_y='F_int', idx_y_arr=load_dofs_z, record_on='update', transform_x='-x * 1000', # %g * x' % ( fabs( w_max ),), # due to symmetry the total force sums up from four parts of the beam (2 symmetry axis): # transform_y='-4000. * y') # force-displacement-diagram_supprt (SUPPRT) # self.f_w_diagram_supprt = RTraceGraph( name='displacement_supprtline (center) - force', var_x='U_k', idx_x=center_bottom_dof, var_y='F_int', idx_y_arr=supprt_dofs_z, record_on='update', transform_x='-x * 1000', # %g * x' % ( fabs( w_max ),), # due to symmetry the total force sums up from four parts of the beam (2 symmetry axis): # transform_y='4000. * y') # force-displacement-diagram (THIRDPOINT) # self.f_w_diagram_thirdpoint = RTraceGraph( name='displacement_elasttop (thirdpoint) - force', var_x='U_k', idx_x=thirdpoint_bottom_dof, var_y='F_int', idx_y_arr=load_dofs_z, record_on='update', transform_x='-x * 1000', # %g * x' % ( fabs( w_max ),), # due to symmetry the total force sums up from four parts of the beam (2 symmetry axis): # transform_y='-4000. * y') ts = TS( sdomain=self.fe_domain, bcond_list=self.bc_list, rtrace_list=[ self.f_w_diagram_center, self.f_w_diagram_thirdpoint, self.f_w_diagram_supprt, RTraceDomainListField(name='Displacement', var='u', idx=0, warp=True), # RTraceDomainListField(name = 'Stress' , # var = 'sig_app', idx = 0, warp = True, # record_on = 'update'), # RTraceDomainListField(name = 'Strain' , # var = 'eps_app', idx = 0, warp = True, # record_on = 'update'), # RTraceDomainListField(name = 'Damage' , # var = 'omega_mtx', idx = 0, warp = True, # record_on = 'update'), RTraceDomainListField(name='max_omega_i', warp=True, var='max_omega_i', idx=0, record_on='update'), # RTraceDomainListField(name = 'IStress' , # position = 'int_pnts', # var = 'sig_app', idx = 0, # record_on = 'update'), # RTraceDomainListField(name = 'IStrain' , # position = 'int_pnts', # var = 'eps_app', idx = 0, # record_on = 'update'), ]) # Add the time-loop control tloop = TLoop(tstepper=ts, KMAX=50, tolerance=self.tolerance, RESETMAX=0, tline=TLine(min=0.0, step=self.tstep, max=self.tmax), ord=self.ord) return tloop
def example_with_new_domain(): from ibvpy.api import \ TStepper as TS, RTraceGraph, RTraceDomainListField, \ RTraceDomainListInteg, TLoop, \ TLine, BCDof, IBVPSolve as IS, 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=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=[ 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='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 example(): from ibvpy.api import \ TStepper as TS, RTDofGraph, RTraceDomainListField, TLoop, \ TLine, IBVPSolve as IS, DOTSEval, BCSlice from ibvpy.mesh.fe_grid import FEGrid from mathkit.mfn import MFnLineArray stiffness_concrete = 34000 * 0.03 * 0.03 A_fiber = 1. E_fiber = 1. stiffness_fiber = E_fiber * A_fiber d = 2 * sqrt(Pi) tau_max = 0.1 * d * Pi G = 100 u_max = 0.023 f_max = 0.2 mats_eval = MATS1D5Bond(mats_phase1=MATS1DElastic(E=stiffness_fiber), mats_phase2=MATS1DElastic(E=0), mats_ifslip=MATS1DPlastic(E=G, sigma_y=tau_max, K_bar=0., H_bar=0.), mats_ifopen=MATS1DElastic(E=0)) fets_eval = FETS1D52L4ULRH(mats_eval=mats_eval) domain = FEGrid(coord_max=(1., 0.2), shape=(16, 1), fets_eval=fets_eval) end_dof = domain[-1, 0, -1, 0].dofs[0, 0, 0] ts = TS(dof_resultants=True, sdomain=domain, # conversion to list (square brackets) is only necessary for slicing of # single dofs, e.g "get_left_dofs()[0,1]" bcond_list=[ BCSlice(var='u', value=0., dims=[0], slice=domain[:, :, :, -1]), BCSlice(var='u', value=0., dims=[1], slice=domain[:, :, :, :]), BCSlice(var='f', value=f_max, dims=[0], slice=domain[-1, 0, -1, 0]) ], rtrace_list=[RTDofGraph(name='Fi,right over u_right (iteration)', var_y='F_int', idx_y=end_dof, var_x='U_k', idx_x=end_dof), RTraceDomainListField(name='slip', var='slip', idx=0), RTraceDomainListField(name='eps1', var='eps1', idx=0), RTraceDomainListField(name='eps2', var='eps2', idx=0), RTraceDomainListField(name='shear_flow', var='shear_flow', idx=0), RTraceDomainListField(name='sig1', var='sig1', idx=0), RTraceDomainListField(name='sig2', var='sig2', idx=0), RTraceDomainListField(name='Displacement', var='u', idx=0) ]) # Add the time-loop control tloop = TLoop(tstepper=ts, KMAX=30, debug=False, tline=TLine(min=0.0, step=0.1, max=1.0)) print(tloop.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 app = IBVPyApp(ibv_resource=tloop) app.main()
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 = 60 # Discretization fe_grid = FEGrid(coord_max=(.6, .15, 0.), shape=(n_el_x, 15), fets_eval=fets_eval) mf = MFnLineArray(xdata=array([0, 1, 2, 7, 8 , 28]), ydata=array([0, 3., 3.2, 3.3, 3.32, 3.72 ])) #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=[ # 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='Deformation' , 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-4, KMAX=100, tline=TLine(min=0.0, step=.25, 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 eval(self): elem_length = self.length / float(self.shape) flaw_radius = self.flaw_radius mats = MATS1DElasticWithFlaw(E=10., flaw_position=self.flaw_position, flaw_radius=flaw_radius, reduction_factor=self.reduction_factor) #fets_eval = FETS1D2L( mats_eval = mats ) fets_eval = FETS1D2L3U(mats_eval=mats) domain = FEGrid(coord_max=(self.length, 0., 0.), shape=(self.shape, ), fets_eval=fets_eval) avg_processor = RTNonlocalAvg( avg_fn=QuarticAF(radius=self.avg_radius, correction=True)) eps_app = RTraceDomainListField(name='Strain', position='int_pnts', var='eps_app', warp=False) damage = RTraceDomainListField(name='Damage', position='int_pnts', var='omega', warp=False) disp = RTraceDomainListField(name='Displacement', position='int_pnts', var='u', warp=False) sig_app = RTraceDomainListField(name='Stress', position='int_pnts', var='sig_app') right_dof = domain[-1, -1].dofs[0, 0, 0] rt_fu = RTDofGraph(name='Fi,right over u_right (iteration)', var_y='F_int', idx_y=right_dof, var_x='U_k', idx_x=right_dof) ts = TS( u_processor=avg_processor, dof_resultants=True, sdomain=domain, # conversion to list (square brackets) is only necessary for slicing of # single dofs, e.g "get_left_dofs()[0,1]" # bcond_list = [ BCDof(var='u', dof = 0, value = 0.) ] + # [ BCDof(var='u', dof = 2, value = 0.001 ) ]+ # [ ) ], bcond_list=[ BCDof(var='u', dof=0, value=0.), # BCDof(var='u', dof = 1, link_dofs = [2], link_coeffs = [0.5], # value = 0. ), # BCDof(var='u', dof = 2, link_dofs = [3], link_coeffs = [1.], # value = 0. ), BCDof( var='u', dof=right_dof, value=0.01, ) ], rtrace_list=[ rt_fu, eps_app, # damage, sig_app, disp, ]) # Add the time-loop control tloop = TLoop(tstepper=ts, KMAX=100, tolerance=1e-5, verbose_iteration=False, tline=TLine(min=0.0, step=1.0, max=1.0)) U = tloop.eval() p.subplot(221) rt_fu.refresh() rt_fu.trace.plot(p) eps = eps_app.subfields[0] xdata = eps.vtk_X[:, 0] ydata = eps.field_arr[:, 0, 0] idata = argsort(xdata) p.subplot(222) p.plot(xdata[idata], ydata[idata], 'o-') disp = disp.subfields[0] xdata = disp.vtk_X[:, 0] ydata = disp.field_arr[:, 0] idata = argsort(xdata) p.subplot(223) p.plot(xdata[idata], ydata[idata], 'o-') sig = sig_app.subfields[0] xdata = sig.vtk_X[:, 0] ydata = sig.field_arr[:, 0, 0] idata = argsort(xdata) p.subplot(224) p.plot(xdata[idata], ydata[idata], 'o-')
def peval( self ): '''Evaluation procedure. ''' #mv = MATS1DDamageView( model = mats_eval ) #mv.configure_traits() self.mats_m.reset_state() # Discretization # length = self.length domain = FEGrid( coord_min = ( 0., length / 5. ), coord_max = ( length, 0. ), shape = ( self.shape, 1 ), fets_eval = self.fets ) right_dofs = domain[-1, -1, -1, :].dofs[0, :, 0] print 'concrete_dofs', id( domain ), domain[:, 0, :, 0].dofs # Response tracers self.stress_strain = RTraceGraph( name = 'Fi,right over u_right (iteration)' , var_y = 'F_int', idx_y = right_dofs[0], var_x = 'U_k', idx_x = right_dofs[0] ) self.eps_m_field = RTraceDomainListField( name = 'eps_m' , position = 'int_pnts', var = 'eps1', idx = 0, warp = True ) self.eps_f_field = RTraceDomainListField( name = 'eps_f' , position = 'int_pnts', var = 'eps2', idx = 0, warp = True ) # Response tracers self.sig_m_field = RTraceDomainListField( name = 'sig_m' , position = 'int_pnts', var = 'mats_phase1_sig_app', idx = 0 ) self.sig_f_field = RTraceDomainListField( name = 'sig_f' , position = 'int_pnts', var = 'mats_phase2_sig_app', idx = 0 ) self.omega_m_field = RTraceDomainListField( name = 'omega_m' , position = 'int_pnts', var = 'mats_phase1_omega', idx = 0, warp = True ) # damage_onset_displ = self.mats_m.epsilon_0 * self.length go_behind = 1.5 finish_displ = go_behind * damage_onset_displ n_steps = 20 step_size = ( finish_displ - damage_onset_displ ) / n_steps tmax = 1 + n_steps def ls( t ): if t <= 1: return t else: return 1.0 + ( t - 1.0 ) / n_steps * ( go_behind - 1 ) ts = TSCrackLoc( dof_resultants = True, on_update = self.plot, sdomain = domain, bcond_list = [# define the left clamping BCSlice( var = 'u', value = 0., dims = [0], slice = domain[ 0, 0, 0, :] ), # loading at the right edge BCSlice( var = 'f', value = 1, dims = [0], slice = domain[-1, -1, -1, 0], time_function = ls ), # BCSlice(var='u', value = finish_displ, dims = [0], slice = domain[-1,-1,-1, 0], # time_function = ls ), # fix horizontal displacement in the top layer BCSlice( var = 'u', value = 0., dims = [0], slice = domain[:, -1, :, -1] ), # fix the vertical displacement all over the domain BCSlice( var = 'u', value = 0., dims = [1], slice = domain[ :, :, :, :] ) ], rtrace_list = [ self.stress_strain, self.eps_m_field, self.eps_f_field, self.sig_m_field, self.sig_f_field, self.omega_m_field ] ) # Add the time-loop control tloop = TLoop( tstepper = ts, KMAX = 200, debug = True, tolerance = 1e-5, tline = TLine( min = 0.0, step = 1.0, max = 1.0 ) ) print ts.rte_dict.keys() U = tloop.eval() self.plot() return array( [ U[right_dofs[-1]] ], dtype = 'float_' )
def __demo__(): from ibvpy.api import \ TStepper as TS, RTraceDomainListField, TLoop, \ TLine, BCSlice, FEDomain, FERefinementGrid, FEGrid from ibvpy.mats.mats2D.mats2D_elastic.mats2D_elastic import MATS2DElastic fets_eval = FETS2D4Q8U(mats_eval=MATS2DElastic()) fe_domain = FEDomain() r1 = FERefinementGrid(fets_eval=fets_eval, domain=fe_domain) r2 = FERefinementGrid(fets_eval=fets_eval, domain=fe_domain) # Discretization domain1 = FEGrid(coord_max=(3., 3.), shape=(10, 4), fets_eval=fets_eval, level=r1) domain2 = FEGrid(coord_min=(3., 0.), coord_max=(6., 3), shape=(10, 4), fets_eval=fets_eval, level=r2) ts = TS( dof_resultants=True, sdomain=[domain1, domain2], # fe_domain, bcond_list=[ # Fix the left edge of domain1 BCSlice(var='u', dims=[0, 1], value=0, slice=domain1[0, :, 0, :]), # Link the right edge of domain1 with the left edge of domain2 # # note that following arrays must have the same lengths: # slice and link_slice # dims, link_dims and link_coeffs must have the same lengths # VAR-1: # linking along the complete line between 'domain1' and 'domain2' # all nodes along the y-axis # (used linking of more nodes at once in 'BCSlice') # BCSlice(var='u', dims=[0, 1], value=0.0, slice=domain1[-1, :, -1, :], link_slice=domain2[0, :, 0, :], link_dims=[0, 1], link_coeffs=[1., 1.]), # VAR-2: # linking along individual points between 'domain1' and 'domain2' # (used linking of single nodes in 'BCSlice') # # BCSlice(var='u', dims=[0, 1], value=0.0, # slice=domain1[-1, -1, -1, -1], # link_slice=domain2[0, -1, 0, -1], # link_dims=[0, 1], # link_coeffs=[1., 1.]), # BCSlice(var='u', dims=[0, 1], value=0.0, # slice=domain1[-1, 0, -1, 0], # link_slice=domain2[0, 0, 0, 0], # link_dims=[0, 1], # link_coeffs=[1., 1.]), # Load the right edge of domain2 BCSlice(var='f', dims=[0], value=1, slice=domain2[-1, :, -1, :]) ], rtrace_list=[ RTraceDomainListField(name='Stress', var='sig_app', idx=0), RTraceDomainListField(name='Displacement', var='u', idx=0, warp=True), ]) # Add the time-loop control tloop = TLoop(tstepper=ts, debug=False, tline=TLine(min=0.0, step=1.0, max=1.0)) print '---- result ----' print tloop.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 app = IBVPyApp(ibv_resource=tloop) app.main()
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()
def simgrid( fets_eval, cube_size, shape, support_slices, support_dirs, loading_slice, load_dir=0, load_max=0.01, n_load_steps=1, vars=[], ivars=[], var_type='u', ): '''Construct an idealization and run simulation with primary variable fixed on support slices and with unit load on loading slices applied in load dir. Return the solution vector and the fields specified in vars. ''' # Discretization domain = FEGrid(coord_max=cube_size, shape=shape, fets_eval=fets_eval) u_max = load_max support_bcond = [ BCSlice(var='u', value=0, dims=support_dir, slice=domain[support_slice]) for support_slice, support_dir in zip(support_slices, support_dirs) ] load_bcond = [ BCSlice(var=var_type, value=u_max, dims=[load_dir], slice=domain[loading_slice]) ] bcond = support_bcond + load_bcond loading_dofs = domain[loading_slice].dofs[:, :, load_dir].flatten() graphs = [ RTraceGraph(name='Force in one node / Displ.', var_y='F_int', idx_x=loading_dof, var_x='U_k', idx_y=loading_dof) for loading_dof in loading_dofs ] rtrace_list = [ RTraceDomainListField( name=var, var=var, warp=True, #position = 'int_pnts', record_on='update') for var in vars ] irtrace_list = [ RTraceDomainListInteg(name='Integ(' + var + ')', var=var, record_on='update') for var in ivars ] ts = TS(sdomain=domain, bcond_list=bcond, rtrace_list=graphs + rtrace_list + irtrace_list) load_step = 1. / float(n_load_steps) # Add the time-loop control tloop = TLoop(tstepper=ts, KMAX=15, RESETMAX=0, tolerance=1e-5, tline=TLine(min=0.0, step=load_step, max=1.0)) u = tloop.eval() fields = [rtrace.subfields[0].field_arr for rtrace in rtrace_list] integs = [rtrace.integ_val for rtrace in irtrace_list] for graph in graphs: graph.redraw() traces = [graph.trace for graph in graphs] xydata = (traces[0].xdata, column_stack([trace.ydata for trace in traces])) return tloop, u, fields, integs, xydata
def example_with_new_domain(): from ibvpy.api import \ TStepper as TS, RTraceDomainListField, TLoop, TLine from ibvpy.tmodel.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()
value=0.002, dims=[1], get_dof_method=domain.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), # RTraceDomainListField(name = 'Stress' , # var = 'sig_app', idx = 0, # record_on = 'update'), # RTraceDomainListField(name = 'Displacement' , # var = 'u', idx = 1), RTraceDomainListField( name='Stress', #position = 'int_pnts', var='sig_app', idx=1), # RTraceDomainListField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ]) # Add the time-loop control # tl = TLoop(tstepper=ts, 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. #
def example_2d(): from ibvpy.mats.mats2D.mats2D_elastic.mats2D_elastic import MATS2DElastic from ibvpy.fets.fets2D.fets2D4q import FETS2D4Q from ibvpy.fets.fets2D.fets2D4q8u import FETS2D4Q8U from ibvpy.fets.fets2D.fets2D4q9u import FETS2D4Q9U from ibvpy.fets.fets2D.fets2D9q import FETS2D9Q fets_eval = FETS2D4Q(mats_eval=MATS2DElastic(E=1., nu=0.)) xfets_eval = FETSBimaterial(parent_fets=fets_eval, int_order=3, mats_eval=MATS2DElastic(E=1., nu=0.), mats_eval2=MATS2DElastic(E=5., nu=0.)) # Discretization fe_domain = FEDomain() fe_level1 = FERefinementGrid(domain=fe_domain, fets_eval=fets_eval) fe_grid1 = FEGrid(coord_max=(3., 1., 0.), shape=(3, 1), fets_eval=fets_eval, level=fe_level1) fe_xdomain = XFESubDomain( domain=fe_domain, fets_eval=xfets_eval, #fe_grid_idx_slice = fe_grid1[1,0], fe_grid_slice=fe_grid1['X - 1.5']) ts = TS( dof_resultants=True, sdomain=fe_domain, bcond_list=[ BCDofGroup(var='u', value=1., dims=[0], get_dof_method=fe_grid1.get_right_dofs), BCDofGroup(var='u', value=0., dims=[1], get_dof_method=fe_grid1.get_right_dofs), BCDofGroup(var='u', value=0., dims=[0, 1], get_dof_method=fe_grid1.get_left_dofs), ], rtrace_list=[ # RTraceGraph(name = 'Fi,right over u_right (iteration)' , # var_y = 'F_int', idx_y = 0, # var_x = 'U_k', idx_x = 1), # RTraceDomainListField(name = 'Stress' , # var = 'sig_app', idx = 0, warp = True ), RTraceDomainListField(name='Displacement', var='u', idx=0, warp=True), RTraceDomainListField(name='Strain', var='eps', idx=0, warp=True), # RTraceDomainField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ]) # # # Add the time-loop control tloop = TLoop( tstepper=ts, # tolerance = 1e-4, KMAX = 4, # debug = True, RESETMAX = 2, tline=TLine(min=0.0, step=1., max=1.0)) #print "elements ",fe_xdomain.elements[0] fe_xdomain.deactivate_sliced_elems() print 'parent elems ', fe_xdomain.fe_grid_slice.elems print 'parent dofs ', fe_xdomain.fe_grid_slice.dofs print "dofmap ", fe_xdomain.elem_dof_map print "ls_values ", fe_xdomain.dots.dof_node_ls_values print 'intersection points ', fe_xdomain.fe_grid_slice.r_i print "triangles ", fe_xdomain.dots.rt_triangles print "vtk points ", fe_xdomain.dots.vtk_X print "vtk data ", fe_xdomain.dots.get_vtk_cell_data('blabla', 0, 0) print 'ip_triangles', fe_xdomain.dots.int_division print 'ip_coords', fe_xdomain.dots.ip_coords print 'ip_weigths', fe_xdomain.dots.ip_weights print 'ip_offset', fe_xdomain.dots.ip_offset print 'ip_X_coords', fe_xdomain.dots.ip_X print 'ip_ls', fe_xdomain.dots.ip_ls_values print 'vtk_ls', fe_xdomain.dots.vtk_ls_values print 'J_det ', fe_xdomain.dots.J_det_grid print tloop.eval() # #ts.setup() from ibvpy.plugins.ibvpy_app import IBVPyApp ibvpy_app = IBVPyApp(ibv_resource=ts) ibvpy_app.main()
def example_with_new_domain(): from ibvpy.api import \ TStepper as TS, RTraceDomainListField, TLoop, \ TLine, BCSlice from ibvpy.fets.fets2D.fets2D4q8u import FETS2D4Q8U from ibvpy.tmodel.mats3D.mats3D_cmdm import \ MATS3DMicroplaneDamage from ibvpy.tmodel.matsXD.matsXD_cmdm import PhiFnStrainSoftening # tmodel = MATS2DElastic(E=2,nu= .2, # stress_state= 'rotational_symetry') mats = MATS3DMicroplaneDamage(model_version='stiffness', E=34e3, nu=0.2, phi_fn=PhiFnStrainSoftening(G_f=0.001117, f_t=2.8968)) fets_eval = FETS2Drotsym(prototype_fets=FETS2D4Q8U(), mats_eval=mats) fets_eval.vtk_r *= 0.9 from ibvpy.mesh.fe_grid import FEGrid radius = sqrt(1. / pi) # f_i = (radius/2.)*2*pi # f_o = (radius)*2*pi # print 'f ',f_i,' ', f_o # Discretization fe_grid = FEGrid( # coord_min = (0.,radius/2.,0.), coord_max=(1., radius, 0.), shape=(20, 20), fets_eval=fets_eval) tstepper = TS(sdomain=fe_grid, bcond_list=[ BCSlice(var='u', value=0., dims=[0], slice=fe_grid[0, :, 0, :]), BCSlice(var='u', value=0., dims=[1], slice=fe_grid[0, 0, 0, 0]), BCSlice(var='u', value=1.e-3, dims=[0], slice=fe_grid[-1, :, -1, :]), ], rtrace_list=[ RTraceDomainListField(name='Stress', var='sig_app', idx=0, warp=True, record_on='update'), RTraceDomainListField(name='fracture_energy', var='fracture_energy', idx=0, warp=True, record_on='update'), RTraceDomainListField(name='Displacement', var='u', 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()
get_dof_method=domain.get_bottom_left_dofs), BCDofGroup(var='u', value=0.002, dims=[0], get_dof_method=domain.get_right_dofs) ], 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 = 'Deformation' , # var = 'eps', idx = 0, # record_on = 'update'), RTraceDomainListField(name='Displacement', var='u', idx=0, warp=True), # RTraceDomainListField(name = 'Stress' , # var = 'sig', idx = 0, # record_on = 'update'), # RTraceDomainListField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ]) # Add the time-loop control tloop = TLoop(tstepper=ts, KMAX=4, RESETMAX=0, tolerance=1e-3, tline=TLine(min=0.0, step=1.0, max=1.0))
BCDofGroup(var='u', value=0., dims=[1, 2], get_dof_method=domain.get_bottom_left_dofs), BCDofGroup(var='u', value=0.002, dims=[0], get_dof_method=domain.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='Deformation', var='eps_app', idx=0, record_on='update'), RTraceDomainListField(name='Displacement', var='u', idx=0), # RTraceDomainListField(name = 'Stress' , # var = 'sig', idx = 0, # record_on = 'update'), # RTraceDomainListField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ]) # Add the time-loop control tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=0.5, max=1.0)) tloop.eval()
value=0., dims=[1], get_dof_method=domain.get_bottom_left_dofs), BCDofGroup(var='u', value=0.002, dims=[0], get_dof_method=domain.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), # RTraceDomainField(name = 'Stress' , # var = 'sig_app', idx = 0, # record_on = 'update'), RTraceDomainListField(name='Displacement', var='u', idx=0), # RTraceDomainField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ]) # Add the time-loop control tl = TLoop(tstepper=ts, tline=TLine(min=0.0, step=0.5, 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 app = IBVPyApp(ibv_resource=tl) app.main()
def example_1d(): fets_eval = FETS1D2L3U(mats_eval=MATS1DElastic(E=20.)) xfets_eval = FETSCrack(parent_fets=fets_eval, int_order=2) # Discretization fe_domain = FEDomain() fe_level1 = FERefinementGrid(domain=fe_domain, fets_eval=fets_eval) fe_grid1 = FEGrid(coord_max=(2., 0., 0.), shape=(2, ), fets_eval=fets_eval, level=fe_level1) enr = True if enr: fe_xdomain = XFESubDomain( domain=fe_domain, fets_eval=xfets_eval, #fe_grid_idx_slice = fe_grid1[1,0], fe_grid_slice=fe_grid1['X - .75']) fe_xdomain.deactivate_sliced_elems() ts = TS( dof_resultants=True, sdomain=fe_domain, bcond_list=[ BCSlice(var='u', value=-1. / 2., dims=[0], slice=fe_grid1[0, 0]), BCSlice(var='u', value=0., dims=[0], slice=fe_grid1[-1, -1]), ], rtrace_list=[ # RTDofGraph(name = 'Fi,right over u_right (iteration)' , # var_y = 'F_int', idx_y = 0, # var_x = 'U_k', idx_x = 1), RTraceDomainListField(name='Stress', var='eps', idx=0, warp=True), RTraceDomainListField(name='Displacement', var='u', idx=0, warp=True), # RTraceDomainField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ]) # # # Add the time-loop control tloop = TLoop(tstepper=ts, debug=True, tolerance=1e-4, RESETMAX=0, tline=TLine(min=0.0, step=1, max=1.0)) #print "elements ",fe_xdomain.elements[0] if enr: print('parent elems ', fe_xdomain.fe_grid_slice.elems) print('parent dofs ', fe_xdomain.fe_grid_slice.dofs) print("dofmap ", fe_xdomain.elem_dof_map) print("ls_values ", fe_xdomain.dots.dof_node_ls_values) print('intersection points ', fe_xdomain.fe_grid_slice.r_i) # print("triangles ", fe_xdomain.dots.int_division) print('ip_coords', fe_xdomain.dots.ip_coords) print('ip_weigths', fe_xdomain.dots.ip_weights) print('ip_offset ', fe_xdomain.dots.ip_offset) print('ip_X_coords', fe_xdomain.dots.ip_X) print('ip_ls', fe_xdomain.dots.ip_ls_values) print('vtk_X ', fe_xdomain.dots.vtk_X) print('vtk triangles ', fe_xdomain.dots.rt_triangles) print("vtk data ", fe_xdomain.dots.get_vtk_cell_data('blabla', 0, 0)) print('vtk_ls', fe_xdomain.dots.vtk_ls_values) print('J_det ', fe_xdomain.dots.J_det_grid) tloop.eval() from ibvpy.plugins.ibvpy_app import IBVPyApp ibvpy_app = IBVPyApp(ibv_resource=ts) ibvpy_app.main()