def setUp(self): self.fets_eval = FETS1D2L(mats_eval = MATS1DElastic(E=10.)) # Discretization self.fe_domain1 = FEGrid( coord_max = (3.,0.,0.), shape = (3,), fets_eval = self.fets_eval ) self.fe_domain2 = FEGrid( coord_min = (3.,0.,0.), coord_max = (6.,0.,0.), shape = (3,), fets_eval = self.fets_eval ) self.fe_domain3 = FEGrid( coord_min = (3.,0.,0.), coord_max = (6.,0.,0.), shape = (3,), fets_eval = self.fets_eval ) self.ts = TS( dof_resultants = True, sdomain = [ self.fe_domain1, self.fe_domain2 , self.fe_domain3 ], bcond_list = [BCDof(var='u', dof = 0, value = 0.), BCDof(var='u', dof = 4, link_dofs = [3], link_coeffs = [1.], value = 0. ), BCDof(var='f', dof = 7, value = 1, link_dofs = [2], link_coeffs = [2] ) ], rtrace_list = [ RTraceGraph(name = 'Fi,right over u_right (iteration)' , var_y = 'F_int', idx_y = 0, var_x = 'U_k', idx_x = 1), ] ) # Add the time-loop control self.tloop = TLoop( tstepper = self.ts, tline = TLine( min = 0.0, step = 1, max = 1.0 ))
def _get_fe_domain_structure(self): '''Root of the domain hierarchy ''' elem_length = self.length / float(self.shape) fe_domain = FEDomain() fe_m_level = FERefinementGrid(name='matrix domain', domain=fe_domain, fets_eval=self.fets_m) fe_grid_m = FEGrid(name='matrix grid', coord_max=(self.length, ), shape=(self.shape, ), level=fe_m_level, fets_eval=self.fets_m, geo_transform=self.geo_transform) fe_fb_level = FERefinementGrid(name='fiber bond domain', domain=fe_domain, fets_eval=self.fets_fb) fe_grid_fb = FEGrid(coord_min=(0., length / 5.), coord_max=(length, 0.), shape=(self.shape, 1), level=fe_fb_level, fets_eval=self.fets_fb, geo_transform=self.geo_transform) return fe_domain, fe_grid_m, fe_grid_fb, fe_m_level, fe_fb_level
def test_bar2(): '''Clamped bar composed of two linked bars loaded at the right end [00]-[01]-[02]-[03]-[04]-[05]-[06]-[07]-[08]-[09]-[10] [11]-[12]-[13]-[14]-[15]-[16]-[17]-[18]-[19]-[20]-[21] u[0] = 0, u[5] = u[16], R[-1] = R[21] = 10 ''' fets_eval = FETS1D2L(mats_eval=MATS1DElastic(E=10., A=1.)) # Discretization fe_domain1 = FEGrid(coord_max=(10., 0., 0.), shape=(10, ), n_nodal_dofs=1, dof_r=fets_eval.dof_r, geo_r=fets_eval.geo_r) fe_domain2 = FEGrid(coord_min=(10., 0., 0.), coord_max=(20., 0., 0.), shape=(10, ), n_nodal_dofs=1, dof_r=fets_eval.dof_r, geo_r=fets_eval.geo_r) ts = TS(iterms=[(fets_eval, fe_domain1), (fets_eval, fe_domain2)], dof_resultants=True, bcond_list=[ BCDof(var='u', dof=0, value=0.), BCDof(var='u', dof=5, link_dofs=[16], link_coeffs=[1.], value=0.), BCDof(var='f', dof=21, value=10) ], rtrace_list=[ RTraceGraph(name='Fi,right over u_right (iteration)', var_y='F_int', idx_y=0, var_x='U_k', idx_x=1), ]) # Add the time-loop control tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=1, max=1.0)) u = tloop.eval() print 'u', u # # '---------------------------------------------------------------' # 'Clamped bar composed of two linked bars control displ at right' # 'u[0] = 0, u[5] = u[16], u[21] = 1' # Remove the load and put a unit displacement at the right end # Note, the load is irrelevant in this case and will be rewritten # ts.bcond_list = [ BCDof(var='u', dof=0, value=0.), BCDof(var='u', dof=5, link_dofs=[16], link_coeffs=[1.], value=0.), BCDof(var='u', dof=21, value=1.) ] # system solver u = tloop.eval() print 'u', u
def _get_fe_grid_column(self): return FEGrid(coord_min=(0.0, 0.0, 0.0), coord_max=(1.0, 1.0, 1.0), geo_transform=self.column, shape=(self.n_elems_col_xy, self.n_elems_col_xy, self.n_elems_col_z), fets_eval=self.fe_column)
def _get_fe_grid_roof(self): return FEGrid(coord_min=(0.0, 0.0, 0.0), coord_max=(1.0, 1.0, 1.0), geo_transform=self.hp_shell, shift_array=self.shift_array, shape=(self.n_elems_xy, self.n_elems_xy, self.n_elems_z), fets_eval=self.fe_roof)
def _get_fe_disk_grid(self): fe_grid = FEGrid(coord_min=(-1, -1), coord_max=(1, 1), geo_transform=self.geo_disk, shape=(self.n_elems, self.n_elems), fets_eval=self.fets_disk) return fe_grid
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 _get_fe_grid_columns(self): return [ FEGrid(coord_min=(0.0, 0.0, 0.0), coord_max=(1.0, 1.0, 1.0), geo_transform=column, shape=(1, 1, 1), fets_eval=self.fe_column) for column in self.columns ]
def _get_specmn_fe_grid(self): fe_grid = FEGrid(coord_max=(1, 1, 1), shape=(self.shape_x, self.shape_y, self.shape_z), level=self.specmn_fe_level, geo_transform=self.barel_shell_geo, fets_eval=self.specmn_fets) return fe_grid
def setUp(self): ''' Construct the FEDomain with two FERefinementGrids (2,2) ''' self.domain1 = FEDomain() self.fets_eval = FETS2D4Q(mats_eval=MATS2DElastic()) self.d1 = FERefinementGrid(name='d1', domain=self.domain1) g1 = FEGrid(coord_max=(1., 1., 0.), shape=(2, 2), fets_eval=self.fets_eval, level=self.d1) self.d2 = FERefinementGrid(name='d2', domain=self.domain1) g2 = FEGrid(coord_min=(1., 0., 0.), coord_max=(2., 1., 0.), shape=(2, 2), fets_eval=self.fets_eval, level=self.d2)
def _get_buttstrap_clamp_fe_grid(self): fe_grid = FEGrid(coord_min=(0, 0), coord_max=(1, 1), level=self.buttstrap_clamp_fe_level, geo_transform=self.buttstrap_clamp_geo, shape=(1, self.buttstrap_ne_y), fets_eval=self.buttstrap_fets) return fe_grid
def _get_friction_fe_grid(self): fe_grid = FEGrid(coord_min=(0, 0), coord_max=(1, 1), level=self.friction_fe_level, geo_transform=self.friction_geo, shape=(self.friction_ne_x, self.friction_ne_y), fets_eval=self.friction_fets) return fe_grid
def setUp(self): ''' Construct the FEDomain with one FERefinementGrids (2,2) ''' self.fets_eval = FETS3D8H() self.grid = FEGrid(coord_max=(1., 1., 1.), shape=(1, 1, 1), fets_eval=self.fets_eval)
def _get_domain(self): # Number of elements n_e_x = 20 # Element definition domain = FEGrid(coord_max=(self.L_x, ), shape=(n_e_x, ), fets_eval=self.fets_eval) return domain
def _get_specmn_fe_grid(self): # only a quarter of the beam is simulated due to symmetry: fe_grid = FEGrid(coord_min=(self.sym_elstmr_length, 0., 0.), coord_max=(self.sym_specmn_length, self.sym_width, self.thickness), shape=(self.shape_x, self.shape_y, self.shape_z), level=self.specmn_fe_level, fets_eval=self.specmn_fets) return fe_grid
def notched_bended_beam(): fets_eval_4u = FETS2D4Q(mats_eval=MATS2DScalarDamage()) fets_eval_cracked = FETSLSEval(parent_fets=fets_eval_4u) # Discretization fe_domain1 = FEGrid(coord_max=(5., 2., 0.), shape=(3, 2), fets_eval=fets_eval_4u) fe_child_domain = FERefinementGrid(parent_domain=fe_domain1, fets_eval=fets_eval_cracked, fine_cell_shape=(1, 1)) crack_level_set = lambda X: X[0] - 2.5 fe_child_domain.refine_elem((1, 0), crack_level_set) dots = fe_child_domain.new_dots() fe_domain = FEDomainList(subdomains=[fe_domain1]) fe_domain_tree = FEDomainTree(domain_list=fe_domain) ts = TS( dof_resultants=True, sdomain=[fe_domain1, fe_child_domain], bcond_list=[ BCDofGroup(var='u', value=0., dims=[0, 1], get_dof_method=fe_domain1.get_left_dofs), BCDofGroup(var='u', value=0., dims=[0, 1], get_dof_method=fe_domain1.get_right_dofs), BCDofGroup(var='f', value=-1., dims=[1], get_dof_method=fe_domain1.get_top_dofs), ], 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 ), # RTraceDomainField(name = 'Displacement' , # var = 'u', idx = 0), # RTraceDomainField(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(tloop.eval())
def _get_fe_grid(self): elem_length = self.length / float(self.shape) fe_grid = FEGrid(coord_max=(self.length, ), shape=(self.shape, ), level=self.fe_grid_level, fets_eval=self.fets) return fe_grid
def _get_fe_grid_roofs(self): return [ FEGrid(coord_min=(0.0, 0.0, 0.0), coord_max=(1.0, 1.0, 1.0), geo_transform=hp_shell, shape=(self.n_elems_xy_quarter, self.n_elems_xy_quarter, self.n_elems_z), fets_eval=self.fe_roof) for hp_shell in self.hp_shells ]
def run_example(): from ibvpy.api import \ TStepper as TS, RTraceGraph, RTraceDomainListField, \ RTraceDomainListInteg, TLoop, \ TLine, BCDof, IBVPSolve as IS, DOTSEval from ibvpy.mats.mats2D.mats2D_conduction.mats2D_conduction import MATS2DConduction from ibvpy.api import BCDofGroup fets_eval = FETS2D4Q4T(mats_eval=MATS2DConduction(k=1.)) 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=(1., 1., 0.), shape=(2, 2), fets_eval=fets_eval) tstepper = TS( sdomain=fe_grid, bcond_list=[ BCDofGroup(var='u', value=0., dims=[0], 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], get_dof_method=fe_grid.get_top_right_dofs) ], rtrace_list=[ # 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 = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ]) print tstepper.setup() return # Add the time-loop control tloop = TLoop(tstepper=tstepper, debug=False, tline=TLine(min=0.0, step=1.0, max=1.0)) tloop.eval()
def _get_elstmr_fe_grid(self): x_max = self.sym_elstmr_length y_max = self.width / 2. z_max = self.thickness + self.elstmr_thickness fe_grid = FEGrid(coord_min=(0, 0, self.thickness), coord_max=(x_max, y_max, z_max), level=self.elstmr_fe_level, shape=(self.mid_shape_x, self.shape_y, 1), fets_eval=self.elstmr_fets) return fe_grid
def _get_elstmr_fe_grid(self): fe_grid = FEGrid(coord_min=(self.sym_mid_zone_specmn_length - self.sym_elstmr_length, 0., self.thickness), coord_max=(self.sym_mid_zone_specmn_length + self.sym_elstmr_length, self.sym_width, self.thickness + self.elstmr_thickness), level=self.elstmr_fe_level, shape=(self.load_zone_shape_x, self.shape_y, 1), fets_eval=self.elstmr_fets) return fe_grid
def _get_supprt_fe_grid(self): return FEGrid( coord_min=(0, 0, 0), coord_max=(1, 1, 1), level=self.supprt_fe_level, # use shape (2,2) in order to place support in the center of the steel support # corresponding to 4 elements of the slab mesh # shape=(self.shape_supprt_x, self.shape_supprt_x, 1), geo_transform=self.geo_supprt, fets_eval=self.supprt_fets)
def demo3d(): # Geometry # length = 1.0 from ibvpy.fets.fets3D import FETS3D8H, FETS3D8H20U, FETS3D8H27U, FETS3D8H20U from ibvpy.mats.mats3D import MATS3DElastic # Material and FE Formulation # lin_x_temperature = TemperatureLinFn(length=length, n_dims=3, offset=0.5) fets_eval = FETS3D8H20U(mats_eval=MATS3DElastic( E=30e3, nu=0.2, initial_strain=lin_x_temperature)) fets_eval.vtk_r *= 0.99 # Discretization # domain = FEGrid(coord_max=(length, length, length), shape=(6, 3, 3), fets_eval=fets_eval) bcond_list = [ BCSlice(var='u', dims=[0, 1, 2], slice=domain[0, 0, 0, 0, 0, 0], value=0), BCSlice(var='u', dims=[0, 1], slice=domain[0, 0, -1, 0, 0, -1], value=0), BCSlice(var='u', dims=[0], slice=domain[0, -1, 0, 0, -1, 0], value=0), ] rtrace_list = [ sig_trace, eps_trace, eps0_trace, eps1t_trace, max_p_sig_trace, u_trace ] for rtrace in rtrace_list: rtrace.position = 'int_pnts' rtrace.warp = False corner_dof = domain[-1, -1, -1, -1, -1, -1].dofs[0, 0, 2] ts = TS(sdomain=domain, bcond_list=bcond_list, rtrace_list=rtrace_list) # Time integration # tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=3, max=1.0)) tloop.eval() # Postprocessing # app = IBVPyApp(ibv_resource=tloop) app.main()
def setUp(self): self.fets_eval = FETS1D2L(mats_eval=MATS1DElastic(E=10.)) # Discretization self.domain = FEGrid(coord_max=(10., 0., 0.), shape=(1, ), fets_eval=self.fets_eval) self.ts = TS(sdomain=self.domain, dof_resultants=True) self.tloop = TLoop(tstepper=self.ts, tline=TLine(min=0.0, step=1, max=1.0))
def example_2d(): from ibvpy.mats.mats2D.mats2D_elastic.mats2D_elastic import MATS2DElastic from ibvpy.fets.fets2D.fets2D4q import FETS2D4Q fets_eval = FETS2D4Q(mats_eval=MATS2DElastic(E=2.1e5)) # Discretization fe_domain1 = FEGrid(coord_max=(2., 5., 0.), shape=(10, 10), fets_eval=fets_eval) fe_subgrid1 = FERefinementLevel(parent=fe_domain1, fine_cell_shape=(1, 1)) print 'children' print fe_domain1.children fe_subgrid1.refine_elem((5, 5)) fe_subgrid1.refine_elem((6, 5)) fe_subgrid1.refine_elem((7, 5)) fe_subgrid1.refine_elem((8, 5)) fe_subgrid1.refine_elem((9, 5)) fe_domain = FEDomain(subdomains=[fe_domain1]) ts = TS(dof_resultants=True, sdomain=fe_domain, bcond_list=[BCDofGroup(var='f', value=0.1, dims=[0], get_dof_method=fe_domain1.get_top_dofs), BCDofGroup(var='u', value=0., dims=[0, 1], get_dof_method=fe_domain1.get_bottom_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), # RTraceDomainField(name = 'Displacement' , # var = 'u', idx = 0), # RTraceDomainField(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 tloop.eval() from ibvpy.plugins.ibvpy_app import IBVPyApp ibvpy_app = IBVPyApp(ibv_resource=tloop) ibvpy_app.main()
def _get_fe_grid_roof(self): hp_shell = GeoHPShell(thickness = 0.6) square_to_circle = GeoSquare2Circle(post_transform = hp_shell, circle_radius = 0.15, #Scircle_center = [4.0, 4.0, 0.0], square_edge = 0.6) fe_grid = FEGrid(coord_min = (-1.0, -1.0, 0.0), coord_max = (1.0, 1.0, 1.0), geo_transform = square_to_circle, shape = (self.n_elems_xy, self.n_elems_xy, self.n_elems_z), fets_eval = self.fe_roof) mid_idx = self.mid_idx idx_min, idx_max = self.idx_min, self.idx_max print 'idx_min', idx_min print 'idx_max', idx_max interior_elems = fe_grid[ idx_min:idx_max, idx_min:idx_max, :, :, :, : ].elems fe_grid.inactive_elems = list(interior_elems) print 'elems', interior_elems return fe_grid
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 demo1d(): # Geometry # length = 1.0 # Material and FE Formulation # from ibvpy.fets.fets1D import FETS1D2L, FETS1D2L3U from ibvpy.mats.mats1D import MATS1DElastic mats_eval = MATS1DElastic(E=100., initial_strain=TemperatureLinFn(length=length, n_dims=1, offset=0.5)) fets_eval = FETS1D2L3U(mats_eval=mats_eval) fets_eval.vtk_r *= 0.99 # Discretization # domain = FEGrid(coord_max=(length, 0., 0.), n_elems=(10, ), fets_eval=fets_eval) bcond_list = [ BCSlice(var='u', dims=[0], slice=domain[0, 0], value=0), #BCSlice( var = 'u', dims = [0], slice = domain[-1, -1], value = 0 ) ] ts = TS(sdomain=domain, bcond_list=bcond_list, rtrace_list=[sig_trace, eps_trace, eps0_trace, eps1t_trace]) # Time integration # tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=1, max=1.0)) tloop.eval() # Postprocessing # legend = [] plot_sig(eps_trace, 'eps', legend) plot_sig(eps0_trace, 'eps0', legend) plot_sig(eps1t_trace, 'eps1t', legend) p.legend(legend) p.show()
def demo2d(): # Geometry # length = 1.0 from ibvpy.fets.fets2D import FETS2D4Q, FETS2D4Q8U, FETS2D4Q12U from ibvpy.mats.mats2D import MATS2DElastic # Material and FE Formulation # lin_x_temperature = TemperatureLinFn(length=length, n_dims=2) fets_eval = FETS2D4Q12U(mats_eval=MATS2DElastic( E=30e5, nu=0.2, initial_strain=lin_x_temperature)) fets_eval.vtk_r *= 0.99 # Discretization # domain = FEGrid(coord_max=(length, length, 0.), shape=(10, 10), fets_eval=fets_eval) bcond_list = [ BCSlice(var='u', dims=[0, 1], slice=domain[0, 0, 0, 0], value=0), BCSlice(var='u', dims=[1], slice=domain[0, -1, 0, -1], value=0), ] rtrace_list = [sig_trace, eps_trace, eps0_trace, eps1t_trace, u_trace] ts = TS( sdomain=domain, bcond_list=bcond_list, rtrace_list=rtrace_list, ) # Time integration # tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=1, max=1.0)) tloop.eval() # Postprocessing # app = IBVPyApp(ibv_resource=tloop) app.main()
def test_rg_addition(self): '''Check numbering after addition of FERefinementGrid Add another FERefinementGrid (2,2) as a child of grid 1 Check the n_dofs of FEDomain to verify the re-enumeration Check the elem_dof_map of the grid 3. ''' d3 = FERefinementGrid(name='d3', parent=self.d1) g3 = FEGrid(coord_max=(1., 1., 0.), shape=(2, 2), fets_eval=self.fets_eval, level=d3) n_dofs = self.domain1.n_dofs #check the n_dofs of the domain after addition self.assertEqual(n_dofs, 54) #check elem_dof_map of added subdomain elem_dof_map = d3.elem_dof_map edm = [ 36, 37, 42, 43, 44, 45, 38, 39, 38, 39, 44, 45, 46, 47, 40, 41, 42, 43, 48, 49, 50, 51, 44, 45, 44, 45, 50, 51, 52, 53, 46, 47 ] for e_, e_ex_ in zip(elem_dof_map.flatten(), edm): self.assertEqual(e_, e_ex_)
def setUp(self): self.fets_eval = FETS1D2L(mats_eval=MATS1DElastic(E=10.)) # Discretization self.fe_domain1 = FEGrid(coord_max=(3., 0., 0.), shape=(3, ), fets_eval=self.fets_eval) self.fe_domain2 = FEGrid(coord_min=(3., 0., 0.), coord_max=(6., 0., 0.), shape=(3, ), fets_eval=self.fets_eval) self.fe_domain3 = FEGrid(coord_min=(3., 0., 0.), coord_max=(6., 0., 0.), shape=(3, ), fets_eval=self.fets_eval) self.ts = TS( dof_resultants=True, sdomain=[self.fe_domain1, self.fe_domain2, self.fe_domain3], bcond_list=[ BCDof(var='u', dof=0, value=0.), BCDof(var='u', dof=4, link_dofs=[3], link_coeffs=[1.], value=0.), BCDof(var='f', dof=7, value=1, link_dofs=[2], link_coeffs=[2]) ], rtrace_list=[ RTraceGraph(name='Fi,right over u_right (iteration)', var_y='F_int', idx_y=0, var_x='U_k', idx_x=1), ]) # Add the time-loop control self.tloop = TLoop(tstepper=self.ts, tline=TLine(min=0.0, step=1, max=1.0))
from mathkit.matrix_la.coo_mtx import COOSparseMtx from mathkit.matrix_la.dense_mtx import DenseMtx import unittest from ibvpy.api import TStepper as TS, RTraceGraph, RTraceDomainField, TLoop, TLine, BCDof, IBVPSolve as IS, DOTSEval from ibvpy.mats.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic from ibvpy.mesh.fe_grid import FEGrid from ibvpy.fets.fets1D.fets1D2l import FETS1D2L if __name__ == "__main__": fets_eval = FETS1D2L(mats_eval=MATS1DElastic(E=10.0)) # Discretization domain = FEGrid(coord_max=(10.0, 0.0, 0.0), shape=(1,), fets_eval=fets_eval) ts = TS(sdomain=domain, dof_resultants=True) tloop = TLoop(tstepper=ts, debug=False, tline=TLine(min=0.0, step=1, max=1.0)) """Clamped bar loaded at the right end with unit displacement [00]-[01]-[02]-[03]-[04]-[05]-[06]-[07]-[08]-[09]-[10] 'u[0] = 0, u[10] = 1""" domain.coord_max = (1, 0, 0) domain.shape = (3,) ts.bcond_list = [ BCDof(var="u", dof=0, value=0.0), BCDof(var="u", dof=1, link_dofs=[2], link_coeffs=[0.5]), BCDof(var="u", dof=3, value=1.0), ]
#------------------------- # element type: #------------------------- if element_type == 'linear': fets_eval = FETS2D4Q( mats_eval = cmdm ) elif element_type == 'quadratic': fets_eval = FETS2D9Q( mats_eval = cmdm) #------------------------- # Discretization #------------------------- domain = FEGrid( coord_max = (length,height,0.), shape = shape, fets_eval = fets_eval ) #------------------------- # ts: #------------------------- # alternative way to get the top/bottom middle dof using slicing of FEGrid: # i.e. get the element which is placed right for the center and then get the lower left node #bottom_middle_dof = domain[shape[0]/2, 0, 0, 0].dofs[0,0,1] #top_middle_dof = domain[shape[0]/2,-1, 0,-1].dofs[0,0,1] top_middle_dofs, top_middle_dof_points = domain.get_top_middle_dofs() top_middle_dof = top_middle_dofs[0,1]
class TestMultiDomain( unittest.TestCase): ''' Test functionality connected with kinematic constraints on multiple domains. ''' def setUp(self): self.fets_eval = FETS1D2L(mats_eval = MATS1DElastic(E=10.)) # Discretization self.fe_domain1 = FEGrid( coord_max = (3.,0.,0.), shape = (3,), fets_eval = self.fets_eval ) self.fe_domain2 = FEGrid( coord_min = (3.,0.,0.), coord_max = (6.,0.,0.), shape = (3,), fets_eval = self.fets_eval ) self.fe_domain3 = FEGrid( coord_min = (3.,0.,0.), coord_max = (6.,0.,0.), shape = (3,), fets_eval = self.fets_eval ) self.ts = TS( dof_resultants = True, sdomain = [ self.fe_domain1, self.fe_domain2 , self.fe_domain3 ], bcond_list = [BCDof(var='u', dof = 0, value = 0.), BCDof(var='u', dof = 4, link_dofs = [3], link_coeffs = [1.], value = 0. ), BCDof(var='f', dof = 7, value = 1, link_dofs = [2], link_coeffs = [2] ) ], rtrace_list = [ RTraceGraph(name = 'Fi,right over u_right (iteration)' , var_y = 'F_int', idx_y = 0, var_x = 'U_k', idx_x = 1), ] ) # Add the time-loop control self.tloop = TLoop( tstepper = self.ts, tline = TLine( min = 0.0, step = 1, max = 1.0 )) def test_bar2( self ): '''Clamped bar composed of two linked bars loaded at the right end [00]-[01]-[02]-[03]-[04]-[05]-[06]-[07]-[08]-[09]-[10] [11]-[12]-[13]-[14]-[15]-[16]-[17]-[18]-[19]-[20]-[21] u[0] = 0, u[5] = u[16], R[-1] = R[21] = 10 ''' self.fe_domain1.set( coord_min = (0,0,0), coord_max = (10,0,0), shape = (10,) ) self.fe_domain2.set( coord_min = (10,0,0), coord_max = (20,0,0), shape = (10,) ) self.ts.set( sdomain = [ self.fe_domain1, self.fe_domain2 ], bcond_list = [ BCDof(var='u', dof = 0, value = 0.), BCDof(var='u', dof = 5, link_dofs = [16], link_coeffs = [1.], value = 0. ), BCDof(var='f', dof = 21, value = 10 ) ] ) u = self.tloop.eval() # expected solution u_ex = array([0., 1., 2., 3., 4., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 6., 7., 8., 9.,10.], dtype = float ) for u_, u_ex_ in zip( u, u_ex ): self.assertAlmostEqual( u_, u_ex_ ) return # @todo - reactivate this test. # # '---------------------------------------------------------------' # 'Clamped bar composed of two linked bars control displ at right' # 'u[0] = 0, u[5] = u[16], u[21] = 1' # Remove the load and put a unit displacement at the right end # Note, the load is irrelevant in this case and will be rewritten # self.ts.bcond_list = [BCDof(var='u', dof = 0, value = 0.), BCDof(var='u', dof = 5, link_dofs = [16], link_coeffs = [1.], value = 0. ), BCDof(var='u', dof = 21, value = 1. ) ] # system solver u = self.tloop.eval() # expected solution u_ex = array([0., 1/10., 2/10. , 3/10. , 4/10. , 5/10., 5/10. , 5/10. , 5/10. , 5/10., 5/10., 5/10., 5/10., 5/10., 5/10., 5/10., 5/10., 6/10., 7/10., 8/10., 9/10., 1. ], dtype = float ) for u_, u_ex_ in zip( u, u_ex ): self.assertAlmostEqual( u_, u_ex_ ) # def test_bar4( self ): '''Clamped bar 3 domains, each with 2 elems (displ at right end) [0]-[1]-[2] [3]-[4]-[5] [6]-[7]-[8] u[0] = 0, u[2] = u[3], u[5] = u[6], u[8] = 1''' self.fe_domain1.set( coord_min = (0,0,0), coord_max = (2,0,0), shape = (2,) ) self.fe_domain2.set( coord_min = (2,0,0), coord_max = (4,0,0), shape = (2,) ) self.fe_domain3.set( coord_min = (4,0,0), coord_max = (6,0,0), shape = (2,) ) self.ts.set( sdomain = [ self.fe_domain1, self.fe_domain2, self.fe_domain3 ], dof_resultants = True, bcond_list = [BCDof(var='u', dof = 0, value = 0.), BCDof(var='u', dof = 2, link_dofs = [3], link_coeffs = [1.], value = 0. ), BCDof(var='u', dof = 5, link_dofs = [6], link_coeffs = [1.], value = 0. ), BCDof(var='u', dof = 8, value = 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), ] ) # system solver u = self.tloop.eval() # expected solution u_ex = array([0., 1/6., 1/3., 1/3., 1/2. , 2/3., 2/3., 5/6., 1. ], dtype = float ) for u_, u_ex_ in zip( u, u_ex ): self.assertAlmostEqual( u_, u_ex_ ) # def test_bar5( self ): '''Clamped bar with 4 elements. Elements 2-4 are reinforced with another bar with 3 elements [0]-[1]-[2]-[3]-[4] [5]-[6]-[7] u[0] = 0, u[1] = u[5], u[3] = u[7], u[4] = 1 ''' self.fe_domain1.set( coord_min = (0,0,0), coord_max = (4,0,0), shape = (4,) ) self.fe_domain2.set( coord_min = (1,0,0), coord_max = (3,0,0), shape = (2,) ) self.ts.set( sdomain = [ self.fe_domain1, self.fe_domain2 ], bcond_list = [ BCDof(var='u', dof = 0, value = 0.), BCDof(var='u', dof = 5, link_dofs = [1], link_coeffs = [1.], value = 0. ), BCDof(var='u', dof = 7, link_dofs = [3], link_coeffs = [1.], value = 0. ), BCDof(var='u', dof = 4, value = 1 ) ] ) u = self.tloop.eval() # expected solution u_ex = array([0., 1/3., 0.5, 2/3., 1., 1/3., 0.5, 2/3.], dtype = float ) for u_, u_ex_ in zip( u, u_ex ): self.assertAlmostEqual( u_, u_ex_ ) def test_bar6( self ): '''Clamped bar with 4 elements. Elements 2-4 are reinforced with another bar with 1 element linked proportianally [0]-[1]-[2]-[3]-[4] [5]-[6] u[0] = 0, u[1] = u[5], u[3] = u[7], u[4] = 1''' self.fe_domain1.set( coord_min = (0,0,0), coord_max = (4,0,0), shape = (4,) ) self.fe_domain2.set( coord_min = (1.5,0,0), coord_max = (2.5,0,0), shape = (1,) ) self.ts.set( sdomain = [ self.fe_domain1, self.fe_domain2 ], bcond_list = [ BCDof(var='u', dof = 0, value = 0.), BCDof(var='u', dof = 5, link_dofs = [1,2], link_coeffs = [.5,.5] ), BCDof(var='u', dof = 6, link_dofs = [2,3], link_coeffs = [.5,.5] ), BCDof(var='u', dof = 4, value = 1 ) ] ) u = self.tloop.eval() # expected solution u_ex = array([-0., 0.3, 0.5 , 0.7 , 1. , 0.4, 0.6], dtype = float ) for u_, u_ex_ in zip( u, u_ex ): self.assertAlmostEqual( u_, u_ex_ ) def test_bar7( self ): '''Two clamped beams link in parallel and loaded by force at right end [5]-[6]-[7]-[8]-[9] [0]-[1]-[2]-[3]-[4] u[5] = u[0], u[0] = 0, u[4] = u[9], R[4] = 1''' self.fe_domain1.set( coord_min = (0,0,0), coord_max = (4,0,0), shape = (4,) ) self.fe_domain2.set( coord_min = (0,0,0), coord_max = (4,0,0), shape = (4,) ) self.ts.set( sdomain = [ self.fe_domain1, self.fe_domain2 ], bcond_list = [BCDof(var='u', dof = 0, value = 0.), BCDof(var='u', dof = 5, link_dofs = [0], link_coeffs = [1.] ), BCDof(var='u', dof = 4, link_dofs = [9], link_coeffs = [0.5] ), BCDof(var='f', dof = 4, value = 1 ), BCDof(var='f', dof = 9, value = 1 ) ] ) u = self.tloop.eval() # expected solution u_ex = array([-0. , 0.06, 0.12, 0.18, 0.24, 0., 0.12, 0.24 , 0.36, 0.48], dtype = float ) for u_, u_ex_ in zip( u, u_ex ): self.assertAlmostEqual( u_, u_ex_ )
fineness_bond = 6 #fineness_no_bond = 2 bond_length = 0.005 #all lengths in meter #no_bond_length = 0.001 width = 0.005 height = width fets_reinf = FETS1D52B4ULRH(mats_eval = MATS1D5Bond(Ef = 17000., #MN/m2 Af = 2.65e-6/4., Am = 0., Em = 0., tau_max = 10.5, #10 tau_fr = 10.5, s_cr = 0.03e-2 )) fe_domain1 = FEGrid( coord_min = (0.,-0.0003, 0.), coord_max = (bond_length, 0. ,0.), shape = ( fineness_bond * 1 ,1 ), fets_eval = fets_reinf ) # characteristic element size concrete = MATS3DMicroplaneDamage( model_version = 'stiffness', E = 34e3, nu = 0.2, phi_fn = PhiFnStrainSoftening( f_t = 2.8968, G_f = 0.001117, h = bond_length / fineness_bond ) ) fets_eval_mdm = FETS3D8H( mats_eval = concrete ) fets_eval2 = fets_eval_mdm fets_eval2.vtk_r *= 0.8
# x,y = - r * cos( phi ), r * sin( phi ) # return c_[ x,y ] # The 'coord_max'-coordinates of FEGrid # are derived in the method arch2d and # automatically considered in the transformation length = 1. height = 1. # 100 linear elements shape = (4*20,1) # Discretization domain = FEGrid( coord_max = (length,height,0.), shape = shape, fets_eval = fets_eval, geo_transform = arch_2d ) # #right_dofs, right_dof_r = domain.get_right_dofs() #right_dof = right_dofs[0,0] #print 'right_dof',right_dof top_middle_dofs, top_middle_dof_r = domain.get_top_middle_dofs() # dof in global y-direction top_middle_dof = top_middle_dofs[0,1] print 'top_middle_dofs',top_middle_dofs print 'top_middle_dof' ,top_middle_dof top_dofs, top_dof_r = domain.get_top_dofs() # dof in global y-direction print 'fets_eval.n_e_dofs' , fets_eval.n_e_dofs
def example_with_new_domain(): from ibvpy.api import \ TStepper as TS, MGridDomain, RTraceGraph, RTraceDomainField, TLoop, \ TLine, IBVPSolve as IS, DOTSEval from ibvpy.api import BCDofGroup from ibvpy.mats.mats1D5.mats1D5bond import MATS1D5Bond from ibvpy.mesh.mgrid_domain import MeshGridAdaptor from ibvpy.mesh.fe_grid import FEGrid from ibvpy.fets.fets1D5.fets1D52b4uLRH import FETS1D52B4ULRH from mathkit.mfn.mfn_line.mfn_line import MFnLineArray fets_eval = FETS1D52B4ULRH(mats_eval = MATS1D5Bond(Ef = 0., Af =0., Em = 0., Am = 0., bond_fn = MFnLineArray(xdata = [0.,1.], ydata = [0.,1.]))) # Tseval for a discretized line domain tseval = DOTSEval( fets_eval = fets_eval ) domain = FEGrid( coord_max = (1., 0.1, 0.0), #new domain shape = (2,1), n_nodal_dofs = 1, dof_r = [[-1,-1],[1,-1],[1,1],[-1,1]], geo_r = [[-1,-1],[1,-1],[1,1],[-1,1]]) ts = TS( tse = tseval, sdomain = domain, # conversion to list (square brackets) is only necessary for slicing of # single dofs, e.g "get_left_dofs()[0,1]" bcond_list = [BCDofGroup(var='u', value = 0.,dims = [0], get_dof_method = domain.get_top_dofs), # BCDofGroup(var='u', value = 0.,dims = [0], # get_dof_method = domain.get_bottom_left_dofs), # imposed displacement for all right dofs in y-direction: # BCDofGroup(var='f', value = -1., dims = [0], # get_dof_method = domain.get_bottom_left_dofs), BCDofGroup(var='f', value = 1./3., dims = [0], get_dof_method = domain.get_bottom_dofs )], rtrace_list = [ RTraceGraph(name = 'Internal Force - Displacement' , var_y = 'F_int', idx_y = domain.get_bottom_right_dofs()[0][0,0], var_x = 'U_k', idx_x = domain.get_bottom_right_dofs()[0][0,0]), RTraceDomainField(name = 'Stress' , #position = 'int_pnts', var = 'sig_app', idx = 0), RTraceDomainField(name = 'Displacement' , var = 'u', idx = 0), RTraceDomainField(name = 'Strain' , var = 'eps_app', idx = 0), RTraceDomainField(name = 'Slip' , var = 'slip', idx = 0), RTraceDomainField(name = 'Shear' , var = 'shear', idx = 0) # RTraceDomainField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ] ) # Add the time-loop control tloop = TLoop( tstepper = ts, DT = 1., tline = TLine( min = 0.0, max = 1.0 )) 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()
#------------------------- # element type: #------------------------- if element_type == 'linear': fets_eval = FETS2D4Q( mats_eval = cmdm ) elif element_type == 'quadratic': fets_eval = FETS2D9Q( mats_eval = cmdm) #------------------------- # Discretization #------------------------- domain = FEGrid( coord_max = (length,height,0.), shape = shape, fets_eval = fets_eval ) # OSOLET: Use individual domains instead for notched specimen. # For a notched beam deactivate the center element at the bottom of the beam: # domain.deactivate( (shape[0]/2,0) ) # Note: For the center element an odd numer is necessary for n_elem[0]. # For the center loading at top an even numkber is necessary. #------------------------- # ts: #------------------------- #right_dofs = domain[0, 0, 0, 0].dofs[0,0,0] #print 'right_dofs', right_dofs
#------------------------- # Discretization: #------------------------- # The 'coord_max'-coordinates of FEGrid # are derived in the method arch2d and # automatically considered in the transformation # therefore the values define here do not effect # the calculation length = 1. height = 1. domain = FEGrid( coord_max = (length,height,0.), shape = shape, fets_eval = fets_eval, geo_transform = arch_2d ) #------------------------- # ts: #------------------------- # Depends on the choice of loading specified in the calculation # parameters defined above ('symmetric' or 'asymmetric' loading): # --- (single displacement at top of the arc) if loading_type == 'symmetric': # get dofs corresponding to the loading case: top_middle_dofs, top_middle_dof_points = domain.get_top_middle_dofs() # dof in global y-direction:
from ibvpy.api import \ TStepper as TS, RTraceGraph, RTraceDomainField, TLoop, \ TLine, BCDof, IBVPSolve as IS, DOTSEval from ibvpy.mats.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic from ibvpy.bcond.bc_slice import BCSlice from ibvpy.mesh.fe_grid import FEGrid from ibvpy.fets.fets1D.fets1D2l import FETS1D2L if __name__ == '__main__': fets_eval = FETS1D2L(mats_eval = MATS1DElastic(E=10., A=1.)) # Discretization domain = FEGrid( coord_max = (10.,0.,0.), shape = (1,), fets_eval = fets_eval ) ts = TS( sdomain = domain, dof_resultants = True ) tloop = TLoop( tstepper = ts, tline = TLine( min = 0.0, step = 1, max = 1.0 )) domain.coord_max = (10,0,0) domain.shape = (10,) bc_left = BCSlice( var = 'u', value = 0., slice = domain[ 0, 0] ) bc_right = BCSlice( var = 'u', value = 1., slice = domain[1:,:] ) ts.bcond_list = [ bc_left, bc_right ]
# Geometric transformation # def arch_2d( points ): x = points[:,0] y = points[:,1] l = x[-1] - x[0] R = 10. phi = x / l * pi r = R + y x,y = - r * cos( phi ), r * sin( phi ) return c_[ x,y ] # Discretization domain = FEGrid( coord_max = (length,height,0.), shape = (10,5), # shape = (5,2), fets_eval = fets_eval, geo_transform = arch_2d ) # right_dofs, right_dof_r = domain.get_right_dofs() right_dof = right_dofs[0,0] print 'right_dof',right_dof tstepper = TS( sdomain = domain, bcond_list = [ BCDofGroup( var='u', value = 0., dims = [0,1], get_dof_method = domain.get_left_dofs ), BCDofGroup( var='u', value = 0.01125, 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,