def _get_explorer_config(self): from ibvpy.api import TLine, RTraceGraph, BCDof ec = super(MATS1DDamage, self)._get_explorer_config() ec['mats_eval'] = MATS1DDamage(E=1.0, epsilon_0=1.0, epsilon_f=5) ec['bcond_list'] = [ BCDof(var='u', dof=0, value=1.7, time_function=lambda t: (1 + 0.1 * t) * sin(t)) ] ec['tline'] = TLine(step=0.1, max=10) ec['rtrace_list'] = [ RTraceGraph(name='strain - stress', var_x='eps_app', idx_x=0, var_y='sig_app', idx_y=0, record_on='update'), RTraceGraph(name='time - damage', var_x='time', idx_x=0, var_y='omega', idx_y=0, record_on='update') ] return ec
def _get_explorer_config(self): from ibvpy.api import TLine, BCDof, RTraceGraph c = super(MATS1DPlastic, self)._get_explorer_config() # overload the default configuration c['bcond_list'] = [ BCDof(var='u', dof=0, value=2.0, time_function=lambda t: sin(t)) ] c['rtrace_list'] = [ RTraceGraph(name='strain - stress', var_x='eps_app', idx_x=0, var_y='sig_app', idx_y=0, record_on='update'), RTraceGraph(name='time - plastic_strain', var_x='time', idx_x=0, var_y='eps_p', idx_y=0, record_on='update'), RTraceGraph(name='time - back stress', var_x='time', idx_x=0, var_y='q', idx_y=0, record_on='update'), RTraceGraph(name='time - hardening', var_x='time', idx_x=0, var_y='alpha', idx_y=0, record_on='update') ] c['tline'] = TLine(step=0.3, max=10) return c
def test_bar1(self): '''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''' self.domain.coord_max = (10, 0, 0) self.domain.shape = (10, ) self.ts.bcond_list = [ BCDof(var='u', dof=0, value=0.), BCDof(var='u', dof=10, value=1.) ] self.ts.rtrace_list = [ RTraceGraph(name='Fi,right over u_right (iteration)', var_y='F_int', idx_y=10, var_x='U_k', idx_x=10) ] u = self.tloop.eval() # expected solution u_ex = array([0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.], dtype=float) difference = sqrt(norm(u - u_ex)) self.assertAlmostEqual(difference, 0) # compare the reaction at the left end F = self.ts.F_int[0] self.assertAlmostEqual(F, -1)
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 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_f_dof(self): return RTraceGraph(name='Fi,right over u_right (iteration)', var_y='F_int', idx_y=self.dof, var_x='U_k', idx_x=self.dof + 2, record_on='update')
def example_3d(): from ibvpy.mats.mats3D.mats3D_elastic.mats3D_elastic import MATS3DElastic from ibvpy.fets.fets3D.fets3D8h import FETS3D8H fets_eval = FETS3D8H(mats_eval=MATS3DElastic()) fe_domain = FEDomain() fe_level1 = FERefinementGrid(domain=fe_domain, fets_eval=fets_eval) # Discretization fe_domain1 = FEGrid(coord_max=(2., 5., 3.), shape=(2, 3, 2), level=fe_level1, fets_eval=fets_eval) fe_child_domain = FERefinementGrid(parent=fe_domain1, fine_cell_shape=(2, 2, 2)) fe_child_domain.refine_elem((1, 1, 0)) fe_child_domain.refine_elem((0, 1, 0)) fe_child_domain.refine_elem((1, 1, 1)) fe_child_domain.refine_elem((0, 1, 1)) ts = TS( dof_resultants=True, sdomain=fe_domain, bcond_list=[ BCDofGroup(var='f', value=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_explorer_config(self): from ibvpy.api import BCDof, TLine, RTraceGraph return {'bcond_list': [BCDof(var='u', dof=0, value=0.01, time_function=lambda t: t)], 'rtrace_list': [RTraceGraph(name='strain - stress', var_x='eps_app', idx_x=0, var_y='sig_app', idx_y=0, record_on='update'), RTraceGraph(name='strain - strain', var_x='eps_app', idx_x=0, var_y='eps_app', idx_y=1, record_on='update'), RTraceGraph(name='stress - stress', var_x='sig_app', idx_x=0, var_y='sig_app', idx_y=1, record_on='update'), RTraceGraph(name='Stress - Strain', var_x='F_int', idx_x=0, var_y='U_k', idx_y=0, record_on='update'), RTraceGraph(name='Strain - Strain', var_x='U_k', idx_x=0, var_y='U_k', idx_y=1, record_on='update'), RTraceGraph(name='Stress - Stress', var_x='F_int', idx_x=0, var_y='F_int', idx_y=1, record_on='update'), RTraceGraph(name='sig1 - eps1', var_x='F_int', idx_x=0, var_y='U_k', idx_y=0, record_on='update'), RTraceGraph(name='sig2 - sig3', var_x='F_int', idx_x=1, var_y='F_int', idx_y=2, record_on='update'), RTraceGraph(name='eps2 - eps3', var_x='U_k', idx_x=1, var_y='U_k', idx_y=2, record_on='update') ], 'tline': TLine(step=0.1, max=1.0) } def _set_explorer_config(self, value): self._explorer_config = value
def _get_explorer_rtrace_list(self): '''Return the list of relevant tracers to be used in mats_explorer. ''' return [ RTraceGraph(name='strain - stress', var_x='eps_app', idx_x=0, var_y='sig_app', idx_y=0, record_on='update') ]
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 __demo__(): from ibvpy.api import \ TStepper as TS, RTraceGraph, RTraceDomainListField, TLoop, \ TLine, BCDof 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 # 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=[ 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. # app = IBVPyApp(ibv_resource=tloop) app.main()
def _get_f_w_diagram(self): domain = self.fe_grid_roof w_z = domain[-1, -1, -1, -1, -1, -1].dofs[0, 0, 2] return RTraceGraph( name='load - corner deflection', var_x='U_k', idx_x=w_z, transform_x='-x', var_y='time', idx_y=0, # transform_y='y * %g' % self.lambda_factor, record_on='update')
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 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 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 example_with_new_domain(): from ibvpy.api import \ TStepper as TS, RTraceGraph, 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=[ 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), 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 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 = RTraceGraph(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 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()
value=0., dims=[0], get_dof_method=domain.get_left_dofs), BCDofGroup(var='u', 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=[ RTraceGraph(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=0), # RTraceDomainListField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ]) # Add the time-loop control global tloop tloop = TLoop(tstepper=ts, DT=0.5, tline=TLine(min=0.0, max=1.0, step=0.1))
def app(): avg_radius = 0.03 md = MATS2DScalarDamage(E=20.0e3, nu=0.2, epsilon_0=1.0e-4, epsilon_f=8.0e-4, #epsilon_f = 12.0e-4, #test doubling the e_f stress_state="plane_strain", stiffness="secant", #stiffness = "algorithmic", strain_norm=Rankine()) me = MATS2DElastic(E=20.0e3, nu=0.2, stress_state="plane_strain") fets_eval = FETS2D4Q(mats_eval=md)#, ngp_r = 3, ngp_s = 3) n_el_x = 40 # Discretization fe_grid = FEGrid(coord_max=(.6, .2, 0.), shape=(n_el_x, n_el_x / 3), fets_eval=fets_eval) mf = MFnLineArray(xdata=array([0, 1, 2, 3, 4 ]), ydata=array([0, 2., 2.5, 3., 3.2 ])) #averaging function avg_processor = RTNonlocalAvg(avg_fn=QuarticAF(radius=avg_radius, correction=True)) ts = TS(sdomain=fe_grid, u_processor=avg_processor, bcond_list=[ # constraint for all left dofs in y-direction: BCSlice(var='u', slice=fe_grid[0, 0, 0, 0], dims=[0, 1], value=0.), BCSlice(var='u', slice=fe_grid[-1, 0, -1, 0], dims=[1], value=0.), BCSlice(var='u', slice=fe_grid[n_el_x / 2, -1, 0, -1], dims=[1], time_function=mf.get_value, value= -2.0e-5), ], rtrace_list=[ RTraceGraph(name='Fi,right over u_right (iteration)' , var_y='F_int', idx_y=right_dof, var_x='U_k', idx_x=right_dof, record_on='update'), RTraceDomainListField(name='Strain' , var='eps_app', idx=0, record_on='update'), RTraceDomainListField(name='Displacement' , var='u', idx=1, record_on='update', warp=True), RTraceDomainListField(name='Damage' , var='omega', idx=0, record_on='update', warp=True), # RTraceDomainField(name = 'Stress' , # var = 'sig', idx = 0, # record_on = 'update'), # RTraceDomainField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ] ) # Add the time-loop control # tl = TLoop(tstepper=ts, tolerance=5.0e-5, KMAX=50, tline=TLine(min=0.0, step=1., max=10.0)) tl.eval() # Put the whole stuff into the simulation-framework to map the # individual pieces of definition into the user interface. # from ibvpy.plugins.ibvpy_app import IBVPyApp ibvpy_app = IBVPyApp(ibv_resource=ts) ibvpy_app.main()
if __name__ == '__main__': from ibvpy.api import TLoop, TLine, BCDof, \ IBVPSolve as IS tl = TLoop(tstepper=TS(tse=TSFn1D()), tolerance=1e-8, # debug = True, KMAX=4, verbose_iteration=True, tline=TLine(min=0.0, step=0.25, max=1.0)) # tl.tstepper.bcond_list = [ BCDof( var = 'u', dof = 0, value = 1.0 ) ] tl.tstepper.bcond_list = [BCDof(var='f', dof=0, value=0.9)] tl.tstepper.rtrace_list = [ RTraceGraph(name='u_update', var_x='U_k', idx_x=0, var_y='F_int', idx_y=0, record_on='update'), RTraceGraph(name='u_iter', var_x='U_k', idx_x=0, var_y='F_int', idx_y=0, record_on='iteration') ] tl.eval() for rt in tl.tstepper.rtrace_list: rt.refresh() rt.trace.plot(p, 'o-') p.show()
'sig_norm': self.get_sig_norm, 'eps_p': self.get_eps_p } if __name__ == '__main__': #------------------------------------------------------------------------- # Example using the mats2d_explore #------------------------------------------------------------------------- from ibvpy.api import RTraceGraph from ibvpy.mats.mats2D.mats2D_explore import MATS2DExplore from yield_face2D import J2 mats2D_explore = \ MATS2DExplore(mats2D_eval=MATS2DPlastic(yf=J2()), rtrace_list=[RTraceGraph(name='strain 0 - stress 0', var_x='eps_app', idx_x=0, var_y='sig_app', idx_y=0, record_on='update'), RTraceGraph(name='strain 0 - strain 1', var_x='eps_app', idx_x=0, var_y='eps_app', idx_y=1, record_on='update'), RTraceGraph(name='stress 0 - stress 1', var_x='sig_app', idx_x=0, var_y='sig_app', idx_y=1, record_on='update'), RTraceGraph(name='time - sig_norm', var_x='time', idx_x=0, var_y='sig_norm', idx_y=0, record_on='update') ])
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 peval(self): '''Evaluation procedure. ''' #mv = MATS1DDamageView( model = mats_eval ) #mv.configure_traits() right_dof_m = self.fe_grid_m[-1, -1].dofs[0, 0, 0] right_dof_fb = self.fe_grid_fb[-1, -1, -1, -1].dofs[0, 0, 0] # Response tracers A = self.A_m + self.A_f self.sig_eps_m = RTraceGraph(name='F_u_m', var_y='F_int', idx_y=right_dof_m, var_x='U_k', idx_x=right_dof_m, transform_y='y / %g' % A) # Response tracers self.sig_eps_f = RTraceGraph(name='F_u_f', var_y='F_int', idx_y=right_dof_fb, var_x='U_k', idx_x=right_dof_fb, transform_y='y / %g' % A) self.eps_m_field = RTraceDomainListField(name='eps_m', position='int_pnts', var='eps_app', warp=False) self.eps_f_field = RTraceDomainListField(name='eps_f', position='int_pnts', var='mats_phase2_eps_app', warp=False) # Response tracers self.sig_m_field = RTraceDomainListField(name='sig_m', position='int_pnts', var='sig_app') self.sig_f_field = RTraceDomainListField(name='sig_f', position='int_pnts', var='mats_phase2_sig_app') self.omega_m_field = RTraceDomainListField(name='omega_m', position='int_pnts', var='omega', warp=False) self.shear_flow_field = RTraceDomainListField(name='shear flow', position='int_pnts', var='shear_flow', warp=False) self.slip_field = RTraceDomainListField(name='slip', position='int_pnts', var='slip', warp=False) avg_processor = None if self.avg_radius > 0.0: n_dofs = self.fe_domain.n_dofs avg_processor = RTUAvg(sd=self.fe_m_level, n_dofs=n_dofs, avg_fn=QuarticAF(radius=self.avg_radius)) ts = TStepper( u_processor=avg_processor, dof_resultants=True, sdomain=self.fe_domain, bcond_list=[ # define the left clamping BCSlice(var='u', value=0., dims=[0], slice=self.fe_grid_fb[0, 0, 0, :]), # BCSlice( var = 'u', value = 0., dims = [0], slice = self.fe_grid_m[ 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=self.final_displ, dims=[0], slice=self.fe_grid_fb[-1, -1, -1, :], time_function=self.time_function), # BCSlice( var = 'u', value = self.final_displ, dims = [0], slice = self.fe_grid_m[-1, -1], # time_function = self.time_function ), # 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=self.fe_grid_fb[:, :, :, :]), # # Connect bond and matrix domains BCDofGroup(var='u', value=0., dims=[0], get_link_dof_method=self.fe_grid_fb.get_bottom_dofs, get_dof_method=self.fe_grid_m.get_all_dofs, link_coeffs=[1.]) ], rtrace_list=[ self.sig_eps_m, self.sig_eps_f, self.eps_m_field, self.eps_f_field, self.sig_m_field, self.sig_f_field, self.omega_m_field, self.shear_flow_field, self.slip_field, ]) # Add the time-loop control tloop = TLoop(tstepper=ts, KMAX=300, tolerance=1e-5, debug=False, verbose_iteration=True, verbose_time=False, tline=TLine(min=0.0, step=self.step_size, max=1.0)) tloop.on_accept_time_step = self.plot U = tloop.eval() self.sig_eps_f.refresh() max_sig_m = max(self.sig_eps_m.trace.ydata) return array([U[right_dof_m], max_sig_m], dtype='float_')
def test_bar4(): '''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''' fets_eval = FETS1D2L(mats_eval=MATS1DElastic(E=10., A=1.)) # Discretization fe_domain1 = FEGrid(coord_max=(2., 0., 0.), shape=(2, ), n_nodal_dofs=1, dof_r=fets_eval.dof_r, geo_r=fets_eval.geo_r) fe_domain2 = FEGrid(coord_min=(2., 0., 0.), coord_max=(4., 0., 0.), shape=(2, ), n_nodal_dofs=1, dof_r=fets_eval.dof_r, geo_r=fets_eval.geo_r) fe_domain3 = FEGrid(coord_min=(4., 0., 0.), coord_max=(6., 0., 0.), shape=(2, ), 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), (fets_eval, 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), RTraceDomainListField(name='Displacement', var='u', idx=0) ]) # 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 app = IBVPyApp(ibv_resource=tloop) app.main()
def run(): #------------------------------------------------------------------------- # Example using the mats2d_explore #------------------------------------------------------------------------- from ibvpy.mats.mats2D.mats2D_explore import MATS2DExplore from ibvpy.mats.mats2D.mats2D_rtrace_cylinder import MATS2DRTraceCylinder from ibvpy.mats.mats2D.mats2D_cmdm.mats2D_cmdm_rtrace_Gf_mic import \ MATS2DMicroplaneDamageTraceGfmic, \ MATS2DMicroplaneDamageTraceEtmic, MATS2DMicroplaneDamageTraceUtmic from ibvpy.mats.mats2D.mats2D_cmdm.mats2D_cmdm_rtrace_Gf_mac import \ MATS2DMicroplaneDamageTraceGfmac, \ MATS2DMicroplaneDamageTraceEtmac, MATS2DMicroplaneDamageTraceUtmac from ibvpy.mats.mats2D.mats2D_cmdm.mats2D_cmdm import \ MATS2DMicroplaneDamage, MATS1DMicroplaneDamage from ibvpy.mats.matsXD.matsXD_cmdm import \ PhiFnGeneral, PhiFnStrainHardening from ibvpy.api import RTraceGraph, RTraceArraySnapshot from mathkit.mfn import MFnLineArray from numpy import array, hstack from ibvpy.mats.mats2D.mats2D_explorer_bcond import BCDofProportional from os.path import join ec = { # overload the default configuration 'bcond_list': [BCDofProportional(max_strain=1.0, alpha_rad=0.0)], 'rtrace_list': [ RTraceGraph(name='stress - strain', var_x='eps_app', idx_x=0, var_y='sig_app', idx_y=0, record_on='iteration'), ], } mats_eval = MATS2DMicroplaneDamage( n_mp=15, # mats_eval = MATS1DMicroplaneDamage( elastic_debug=False, stress_state='plane_stress', symmetrization='sum-type', model_version='compliance', phi_fn=PhiFnGeneral, ) # print 'normals', mats_eval._MPN # print 'weights', mats_eval._MPW fitter = MATSCalibDamageFn( KMAX=300, tolerance=5e-4, # 0.01, RESETMAX=0, dim=MATS2DExplore( mats_eval=mats_eval, explorer_config=ec, ), store_fitted_phi_fn=True, log=False) #------------------------------------------- # run fitter for entire available test data: #------------------------------------------- calibrate_all = False if calibrate_all: from matresdev.db.exdb.ex_run_table import \ ExRunClassExt # from matresdev.db.exdb.ex_composite_tensile_test import \ # ExCompositeTensileTest # ex = ExRunClassExt(klass=ExCompositeTensileTest) # for ex_run in ex.ex_run_list: # if ex_run.ready_for_calibration: # print 'FITTING', ex_run.ex_type.key # # 'E_c' of each test is different, therefore 'mats_eval' # # needs to be defined for each test separately. # # # E_c = ex_run.ex_type.E_c # nu = ex_run.ex_type.ccs.concrete_mixture_ref.nu # # # run calibration # # # fitter.ex_run = ex_run # fitter.dim.mats_eval.E = E_c # fitter.dim.mats_eval.nu = nu # fitter.init() # fitter.fit_response() else: test_file = join( simdb.exdata_dir, 'tensile_tests', 'dog_bone', # 'buttstrap_clamping', '2010-02-09_TT-10g-3cm-a-TR_TRC11', # 'TT11-10a-average.DAT' ) 'TT-10g-3cm-a-TR-average.DAT') #----------------------------------- # tests for 'BT-3PT-12c-6cm-TU_ZiE' #----------------------------------- # 'ZiE-S1': test series no. 1 (age = 11d) # # '2011-05-23_TT-12c-6cm-0-TU_ZiE', # 'TT-12c-6cm-0-TU-V2.DAT') # 'ZiE-S2': test series no. 2 (age = 9d) # # '2011-06-10_TT-12c-6cm-0-TU_ZiE', # 'TT-12c-6cm-0-TU-V2.DAT') #----------------------------------- # tests for 'BT-4PT-12c-6cm-TU_SH4' # tests for 'ST-12c-6cm-TU' (fresh) #----------------------------------- # @todo: add missing front strain information from Aramis3d testing # # '2012-04-12_TT-12c-6cm-0-TU_SH4-Aramis3d', # 'TT-12c-6cm-0-TU-SH4-V2.DAT') # '2012-02-14_TT-12c-6cm-0-TU_SH2', # 'TT-12c-6cm-0-TU-SH2-V2.DAT') # '2012-02-14_TT-12c-6cm-0-TU_SH2', # 'TT-12c-6cm-0-TU-SH2F-V3.DAT') # used for suco(!) # '2012-02-14_TT-12c-6cm-0-TU_SH2', # 'TT-12c-6cm-0-TU-SH2-V1.DAT') #----------------------------------- # tests for 'BT-3PT-6c-2cm-TU_bs' #----------------------------------- # barrelshell # # # TT-bs1 # '2013-05-17_TT-6c-2cm-0-TU_bs1', # 'TT-6c-2cm-0-TU-V3_bs1.DAT') # # TT-bs2 # '2013-05-21-TT-6c-2cm-0-TU_bs2', # 'TT-6c-2cm-0-TU-V1_bs2.DAT') # # TT-bs3 # '2013-06-12_TT-6c-2cm-0-TU_bs3', # 'TT-6c-2cm-0-TU-V1_bs3.DAT') # # TTb-bs4-Aramis3d # '2013-07-09_TTb-6c-2cm-0-TU_bs4-Aramis3d', # 'TTb-6c-2cm-0-TU-V2_bs4.DAT') #----------------------------------- # tests for 'TT-6c-2cm-90-TU' #----------------------------------- # # '2013-05-22_TTb-6c-2cm-90-TU-V3_bs1', # 'TTb-6c-2cm-90-TU-V3_bs1.DAT') # '2013-05-17_TT-6c-2cm-0-TU_bs1', # 'TT-6c-2cm-90-TU-V3_bs1.DAT') # test_file = join(simdb.exdata_dir, # 'tensile_tests', # 'buttstrap_clamping', # '2013-07-18_TTb-6c-2cm-0-TU_bs5', # 'TTb-6c-2cm-0-TU-V1_bs5.DAT') # # 'TTb-6c-2cm-0-TU-V3_bs5.DAT') # # test_file = join(simdb.exdata_dir, # 'tensile_tests', # 'buttstrap_clamping', # '2013-07-09_TTb-6c-2cm-0-TU_bs4-Aramis3d', # 'TTb-6c-2cm-0-TU-V2_bs4.DAT') #----------------------------------- # tests for 'TT-6g-2cm-0-TU' (ARG-1200-TU) #----------------------------------- # # test series no.1 # # test_file = join(simdb.exdata_dir, # 'tensile_tests', # 'dog_bone', # '2012-12-10_TT-6g-2cm-0-TU_bs', # 'TT-6g-2cm-0-V2.DAT') # test series no.3 # # test_file = join(simdb.exdata_dir, # 'tensile_tests', # 'buttstrap_clamping', # '2013-07-09_TTb-6g-2cm-0-TU_bs4-Aramis3d', # 'TTb-6g-2cm-0-TU-V1_bs4.DAT') # test series NxM_1 # # test_file = join(simdb.exdata_dir, # 'tensile_tests', # 'buttstrap_clamping', # '2014-04-30_TTb-6c-2cm-0-TU_NxM1', # 'TTb-6c-2cm-0-TU-V16_NxM1.DAT') #------------------------------------------------------------------ # set 'ex_run' of 'fitter' to selected calibration test #------------------------------------------------------------------ # ex_run = ExRun(data_file=test_file) fitter.ex_run = ex_run #------------------------------------------------------------------ # specify the parameters used within the calibration #------------------------------------------------------------------ # # get the composite E-modulus and Poisson's ratio as stored # in the experiment data base for the specified age of the tensile test # E_c = ex_run.ex_type.E_c print('E_c', E_c) # # use the value as graphically determined from the tensile test (= initial stiffness for tension) # E_c = 28000. # age, Em(age), and nu of the slab test or bending test determines the # calibration parameters. Those are used for calibration and are store in the 'param_key' # appendet to the calibration-test-key # age = 28 # E-modulus of the concrete matrix at the age of testing # NOTE: value is more relevant as compression behavior is determined by it in the bending tests and slab tests; # behavior in the tensile zone is defined by calibrated 'phi_fn' with the predefined 'E_m' # E_m = ex_run.ex_type.ccs.get_E_m_time(age) E_c = ex_run.ex_type.ccs.get_E_c_time(age) # use average E-modul from 0- and 90-degree direction for fitter in both directions # this yields the correct tensile behavior and returns the best average compressive behavior # # E_c = 22313.4 # alternatively use maximum E-modul from 90-direction also for 0-degree direction for fitting # this yields the correct tensile behavior also in the linear elastic regime for both directions corresponding to the # tensile test behavior (note that the compressive E-Modulus in this case is overestimated in 0-degree direction; minor influence # assumed as behavior is governed by inelastic tensile behavior and anisotropic redistrirbution; # # E_c = 29940.2 # E_c = 29100. # E_c = 22390.4 # E_c = 18709.5 E_c = 28700. # smallest value for matrix E-modulus obtained from cylinder tests (d=150mm) # E_m = 18709.5 # set 'nu' # @todo: check values stored in 'mat_db' # nu = 0.20 ex_run.ex_type.ccs.concrete_mixture_ref.nu = nu n_steps = 200 fitter.n_steps = n_steps fitter.format_ticks = True fitter.ex_run.ex_type.age = age print('age = %g used for calibration' % age) fitter.ex_run = ex_run # print 'E_m(age) = %g used for calibration' % E_m # fitter.dim.mats_eval.E = E_m print('E_c(age) = %g used for calibration' % E_c) fitter.dim.mats_eval.E = E_c print('nu = %g used for calibration' % nu) fitter.dim.mats_eval.nu = nu print('n_steps = %g used for calibration' % n_steps) max_eps = fitter.max_eps print('max_eps = %g used for calibration' % max_eps) #------------------------------------------------------------------ # set 'param_key' of 'fitter' to store calibration params in the name #------------------------------------------------------------------ # # param_key = '_age%g_Em%g_nu%g_nsteps%g' % (age, E_m, nu, n_steps) # param_key = '_age%g_Ec%g_nu%g_nsteps%g__smoothed' % (age, E_c, nu, n_steps, max_eps) param_key = '_age%g_Ec%g_nu%g_nsteps%g_smoothed' % (age, E_c, nu, n_steps) fitter.param_key = param_key print('param_key = %s used in calibration name' % param_key) #------------------------------------------------------------------ # run fitting procedure #------------------------------------------------------------------ # import pylab as p ax = p.subplot(111) fitter.mfn_line_array_target.mpl_plot(ax) p.show() fitter.init() fitter.fit_response() fitter.store() fitter.plot_trial_steps() return #--------------------------- # basic testing of fitter methods: #--------------------------- # set to True for basic testing of the methods: basic_tests = False if basic_tests: fitter.run_through() # fitter.tloop.rtrace_mngr.rtrace_bound_list[0].configure_traits() fitter.tloop.rtrace_mngr.rtrace_bound_list[0].redraw() last_strain_run_through = fitter.tloop.rtrace_mngr.rtrace_bound_list[ 0].trace.xdata[:] last_stress_run_through = fitter.tloop.rtrace_mngr.rtrace_bound_list[ 0].trace.ydata[:] print('last strain (run-through) value', last_strain_run_through) print('last stress (run-through) value', last_stress_run_through) fitter.tloop.reset() fitter.run_step_by_step() # fitter.tloop.rtrace_mngr.rtrace_bound_list[0].configure_traits() fitter.tloop.rtrace_mngr.rtrace_bound_list[0].redraw() last_strain_step_by_step = fitter.tloop.rtrace_mngr.rtrace_bound_list[ 0].trace.xdata[:] last_stress_step_by_step = fitter.tloop.rtrace_mngr.rtrace_bound_list[ 0].trace.ydata[:] print('last stress (step-by-step) value', last_stress_step_by_step) fitter.run_trial_step() fitter.run_trial_step() fitter.tloop.rtrace_mngr.rtrace_bound_list[0].redraw() strain_after_trial_steps = fitter.tloop.rtrace_mngr.rtrace_bound_list[ 0].trace.xdata[:] stress_after_trial_steps = fitter.tloop.rtrace_mngr.rtrace_bound_list[ 0].trace.ydata[:] print('stress after trial', stress_after_trial_steps) fitter.init() # fitter.mats2D_eval.configure_traits() lof = fitter.get_lack_of_fit(1.0) print('1', lof) lof = fitter.get_lack_of_fit(0.9) print('2', lof) # fitter.tloop.rtrace_mngr.configure_traits() fitter.run_trial_step() else: from ibvpy.plugins.ibvpy_app import IBVPyApp ibvpy_app = IBVPyApp(ibv_resource=fitter) 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
fets_eval=fets_eval) fe_domain2 = FEGrid(coord_min=(10., 0., 0.), coord_max=(20., 0., 0.), shape=(10,), fets_eval=fets_eval) fe_domain = FEDomain(subdomains=[fe_domain1, fe_domain2]) ts = TS(dof_resultants=True, sdomain=fe_domain, 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)) ts.set(sdomain=FEDomain(subdomains=[fe_domain1, fe_domain2])) ts.set(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)]) print tloop.eval()
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_' )
if __name__ == '__main__': #------------------------------------------------------------------------------ # Example #------------------------------------------------------------------------------ from ibvpy.api import RTraceGraph from ibvpy.mats.mats2D.mats2D_explore import MATS2DExplore mats2D_explore = \ MATS2DExplore(mats2D_eval=MATS2DScalarDamage(strain_norm_type='Rankine'), # stiffness = 'algorithmic' ), rtrace_list=[ RTraceGraph(name='strain - stress', var_x='eps_app', idx_x=0, var_y='sig_app', idx_y=0, record_on='update'), RTraceGraph(name='strain - strain', var_x='eps_app', idx_x=0, var_y='eps_app', idx_y=1, record_on='update'), RTraceGraph(name='stress - stress', var_x='sig_app', idx_x=0, var_y='sig_app', idx_y=1, record_on='update'), # RTraceGraph(name = 'time - sig_norm', # var_x = 'time', idx_x = 0, # var_y = 'sig_norm', idx_y = 0, # record_on = 'update' ), ] )