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 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 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 _set_sdomain(self, value): if isinstance(value, FEGrid): # construct FERefinementGrid and FEDomain self._sdomain = FEDomain() fe_rgrid = FERefinementGrid(domain=self._sdomain, fets_eval=value.fets_eval) value.level = fe_rgrid elif isinstance(value, FERefinementGrid): # construct FEDomain self._sdomain = FEDomain() value.domain = self._sdomain elif isinstance(value, list): self._sdomain = FEDomain() for d in value: if isinstance(d, FEGrid): fe_rgrid = FERefinementGrid(domain=self._sdomain, fets_eval=d.fets_eval) d.level = fe_rgrid elif isinstance(d, FESubDomain): d.domain = self._sdomain else: raise TypeError, 'The list can contain only FEGrid or FERefinementGrid' else: self._sdomain = value
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 combined_fe2D4q_with_fe2D4q8u(): fets_eval_4u_conc = FETS2D4Q(mats_eval=MATS2DElastic(E=28500, nu=0.2)) fets_eval_4u_steel = FETS2D4Q(mats_eval=MATS2DElastic(E=210000, nu=0.25)) fets_eval_8u = FETS2D4Q8U(mats_eval=MATS2DElastic()) # Discretization fe_domain = FEDomain() fe_grid_level1 = FERefinementGrid(name='master grid', fets_eval=fets_eval_4u_conc, domain=fe_domain) fe_grid = FEGrid(level=fe_grid_level1, coord_max=(2., 6., 0.), shape=(11, 30), fets_eval=fets_eval_4u_conc) fe_grid_level2 = FERefinementGrid(name='refinement grid', parent=fe_grid_level1, fets_eval=fets_eval_4u_steel, fine_cell_shape=(1, 1)) # fe_grid_level1[ 5, :5 ].refine_using( fe_grid_level2 ) # 1. first get the slice for the level - distinguish it from the slice at the subgrid # this includes slicing in the subgrids. what if the subgrid does not exist? # # Each subgrid must hold its own slice within the level. The index operator fills # the grid [...] instanciates the whole grid and returns the instance of # FEGridLevelSlice. The expanded subgrid contains its constructor slice. # # 2. If the slice is within an existing slice no change in the FESubgrid is required # only the instance of the slice is returned. The FEGridLevelSlice goes always into # an expanded part of FEGrid. # # 3. If the slice does not fit into any existing slice - all domain with an intersection # of the existing slice must be constructed as well. # # 2. deactivate elements # 3. # BUT how to impose the boundary conditions on the particular refinement? The # slice has an attribute fe_grid_level2.refine_elem((5, 0)) fe_grid_level2.refine_elem((5, 1)) fe_grid_level2.refine_elem((5, 2)) fe_grid_level2.refine_elem((5, 3)) fe_grid_level2.refine_elem((5, 4)) fe_grid_level2.refine_elem((5, 5)) # apply the boundary condition on a subgrid # print fe_grid_level2.fe_subgrids fe_first_grid = fe_grid_level2.fe_subgrids[0] ts = TS( dof_resultants=True, sdomain=fe_domain, bcond_list=[ BCSlice(var='f', value=1., dims=[0], slice=fe_grid[:, -1, :, -1]), BCSlice(var='u', value=0., dims=[0, 1], slice=fe_first_grid[:, 0, :, 0]) ], 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_level(self): '''Container for subgrids at the refinement level. ''' fe_grid_level = FERefinementGrid(domain=self.fe_domain, fets_eval=self.fets) return fe_grid_level
from ibvpy.mesh.fe_refinement_grid import FERefinementGrid from ibvpy.mesh.fe_domain import FEDomain from ibvpy.mesh.fe_spring_array import FESpringArray from ibvpy.fets.fets1D.fets1D2l import FETS1D2L from ibvpy.mats.mats1D import MATS1DElastic if __name__ == '__main__': fets_eval = FETS1D2L( mats_eval = MATS1DElastic( E = 1 ) ) # Discretization fe_domain = FEDomain() fe_patch_left = FERefinementGrid( name = 'left', fets_eval = fets_eval, domain = fe_domain ) fe_grid_left = FEGrid( level = fe_patch_left, coord_min = ( 0., ), coord_max = ( 1., ), shape = ( 1, ), fets_eval = fets_eval ) fe_patch_right = FERefinementGrid( name = 'refinement grid', fets_eval = fets_eval, domain = fe_domain ) fe_grid_right = FEGrid( level = fe_patch_right, coord_min = ( 2., ), coord_max = ( 3., ),
from ibvpy.fets.fets2D.fets2D4q8u import FETS2D4Q8U from ibvpy.api import\ BCDofGroup, TStepper as TS, TLoop, TLine, RTDofGraph from ibvpy.rtrace.rt_domain_list_field import RTraceDomainListField from ibvpy.mesh.fe_grid import FEGrid from ibvpy.mesh.fe_refinement_grid import FERefinementGrid from ibvpy.mesh.fe_domain import FEDomain if __name__ == '__main__': fets_eval_4u = FETS2D4Q(mats_eval = MATS2DElastic()) fets_eval_8u = FETS2D4Q8U(mats_eval = MATS2DElastic()) fe_domain = FEDomain() fe_rgrid1 = FERefinementGrid( name = 'fe_rgrid1', fets_eval = fets_eval_4u, domain = fe_domain ) fe_grid1 = FEGrid( name = 'fe_grid1', coord_max = (2.,6.,0.), shape = (1,3), fets_eval = fets_eval_4u, level = fe_rgrid1 ) fe_grid2 = FEGrid( name = 'fe_grid2', coord_min = (2., 6, 0.), coord_max = (10, 15, 0.), shape = (1,3), fets_eval = fets_eval_4u, level = fe_rgrid1 ) fe_rgrid2 = FERefinementGrid( name = 'fe_rgrid2', fets_eval = fets_eval_4u, domain = fe_domain ) fe_grid3 = FEGrid( name = 'fe_grid3', coord_min = (0, 0, 1.),