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 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 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 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 __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 example_0(): from ibvpy.fets.fets_eval import FETSEval fets_sample = FETSEval(dof_r=[[-1., -1], [0.5, -1], [1, 1], [-1, 1]], geo_r=[[-1., -1], [0.5, -1], [1, 1], [-1, 1]], n_nodal_dofs=1) fe_domain = FEDomain() fe_pgrid = FERefinementGrid(domain=fe_domain, fets_eval=fets_sample) fe_grid = FEGrid(coord_max=(1., 1., 0.), level=fe_pgrid, shape=(2, 2), inactive_elems=[1], fets_eval=fets_sample) print('elem_dof_map') print(fe_domain.elem_dof_map) print('elem_X_map') print(fe_domain.elem_X_map) fe_child_domain = FERefinementGrid(parent=fe_pgrid, fets_eval=fets_sample, fine_cell_shape=(2, 2)) fe_child_domain.refine_elem((1, 1)) fe_child_domain.refine_elem((0, 1)) print(fe_child_domain.elem_dof_map) print(fe_child_domain.elem_X_map) print('n_dofs', fe_child_domain.n_dofs) for e_id, e in enumerate(fe_child_domain.elements): print('idx', e_id) print(e) from ibvpy.plugins.ibvpy_app import IBVPyApp ibvpy_app = IBVPyApp(ibv_resource=fe_domain) ibvpy_app.main()
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 _get_shape(self): return len(self.elements) #------------------------------------------------------------------ # UI - related methods #------------------------------------------------------------------ traits_view = View(Item('source_domain@', show_label=False), Item('refresh_button', show_label=False), Item('ls_value', show_label=False), resizable=True, scrollable=True, height=0.5, width=0.5) if __name__ == '__main__': fe_domain = FEGrid(coord_min=(-2., -2., 0), coord_max=(2., 2., 0), shape=(10, 10), geo_r=[[-1, -1], [-1, 1], [1, 1], [1, -1]], dof_r=[[-1, -1], [-1, 1], [1, 1], [1, -1]]) ls_domain = FELevelSetDomain(source_domain=fe_domain, ls_function=lambda x, y: x**2 + y**2 - 1.) from ibvpy.plugins.ibvpy_app import IBVPyApp ibvpy_app = IBVPyApp(ibv_resource=ls_domain) ibvpy_app.main()
def get_sig_norm(self, sctx, eps_app_eng): sig_eng, D_mtx = self.get_corr_pred(sctx, eps_app_eng, 0, 0, 0) return array([scalar_sqrt(sig_eng[0]**2 + sig_eng[1]**2)]) # Declare and fill-in the rte_dict - it is used by the clients to # assemble all the available time-steppers. # rte_dict = Trait(Dict) def _rte_dict_default(self): return { 'sig_app': self.get_sig_app, 'eps_app': self.get_eps_app, 'sig_norm': self.get_sig_norm, 'strain_energy': self.get_strain_energy } if __name__ == '__main__': #------------------------------------------------------------------------- # Example using the mats2d_explore #------------------------------------------------------------------------- from ibvpy.mats.mats_explore import MATSExplore, MATS2DExplore mats_eval = MATS2DConduction() mats_explore = MATSExplore(dim=MATS2DExplore(mats_eval=mats_eval)) mats_explore.tloop.eval() # mme.configure_traits( view = 'traits_view_begehung' ) from ibvpy.plugins.ibvpy_app import IBVPyApp ibvpy_app = IBVPyApp(ibv_resource=mats_explore) ibvpy_app.main()
def example_with_new_domain(): from ibvpy.api import \ TStepper as TS, RTraceGraph, RTraceDomainListField, \ RTraceDomainListInteg, TLoop, \ TLine, BCDof, IBVPSolve as IS, DOTSEval from ibvpy.mats.mats2D.mats2D_elastic.mats2D_elastic import MATS2DElastic from ibvpy.mats.mats2D.mats2D_sdamage.mats2D_sdamage import MATS2DScalarDamage from ibvpy.api import BCDofGroup mats_eval = MATS2DElastic() fets_eval = FETS2D4Q(mats_eval=mats_eval) #fets_eval = FETS2D4Q(mats_eval = MATS2DScalarDamage()) print fets_eval.vtk_node_cell_data from ibvpy.mesh.fe_grid import FEGrid from ibvpy.mesh.fe_refinement_grid import FERefinementGrid from ibvpy.mesh.fe_domain import FEDomain from mathkit.mfn import MFnLineArray # Discretization fe_grid = FEGrid(coord_max=(10., 4., 0.), shape=(10, 3), fets_eval=fets_eval) bcg = BCDofGroup(var='u', value=0., dims=[0], get_dof_method=fe_grid.get_left_dofs) bcg.setup(None) print 'labels', bcg._get_labels() print 'points', bcg._get_mvpoints() mf = MFnLineArray( # xdata = arange(10), ydata=array([0, 1, 2, 3])) right_dof = 2 tstepper = TS( sdomain=fe_grid, bcond_list=[ BCDofGroup(var='u', value=0., dims=[0, 1], get_dof_method=fe_grid.get_left_dofs), # BCDofGroup( var='u', value = 0., dims = [1], # get_dof_method = fe_grid.get_bottom_dofs ), BCDofGroup(var='u', value=.005, dims=[1], time_function=mf.get_value, get_dof_method=fe_grid.get_right_dofs) ], rtrace_list=[ RTraceGraph(name='Fi,right over u_right (iteration)', var_y='F_int', idx_y=right_dof, var_x='U_k', idx_x=right_dof, record_on='update'), RTraceDomainListField(name='Stress', var='sig_app', idx=0, position='int_pnts', record_on='update'), # RTraceDomainListField(name = 'Damage' , # var = 'omega', idx = 0, # # record_on = 'update', # warp = True), RTraceDomainListField(name='Displacement', var='u', idx=0, record_on='update', warp=True), RTraceDomainListField(name='Strain energy', var='strain_energy', idx=0, record_on='update', warp=False), RTraceDomainListInteg(name='Integ strain energy', var='strain_energy', idx=0, record_on='update', warp=False), # RTraceDomainListField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ]) # Add the time-loop control #global tloop tloop = TLoop(tstepper=tstepper, KMAX=300, tolerance=1e-4, tline=TLine(min=0.0, step=1.0, max=1.0)) #import cProfile #cProfile.run('tloop.eval()', 'tloop_prof' ) # print tloop.eval() #import pstats #p = pstats.Stats('tloop_prof') # p.strip_dirs() # print 'cumulative' # p.sort_stats('cumulative').print_stats(20) # print 'time' # p.sort_stats('time').print_stats(20) tloop.eval() # Put the whole thing into the simulation-framework to map the # individual pieces of definition into the user interface. # from ibvpy.plugins.ibvpy_app import IBVPyApp app = IBVPyApp(ibv_resource=tloop) app.main()
def example_2d(): from ibvpy.mats.mats2D.mats2D_elastic.mats2D_elastic import MATS2DElastic from ibvpy.fets.fets2D.fets2D4q import FETS2D4Q from ibvpy.fets.fets2D.fets2D4q8u import FETS2D4Q8U from ibvpy.fets.fets2D.fets2D4q9u import FETS2D4Q9U from ibvpy.fets.fets2D.fets2D9q import FETS2D9Q fets_eval = FETS2D4Q(mats_eval=MATS2DElastic(E=1., nu=0.)) xfets_eval = FETSBimaterial(parent_fets=fets_eval, int_order=3, mats_eval=MATS2DElastic(E=1., nu=0.), mats_eval2=MATS2DElastic(E=5., nu=0.)) # Discretization fe_domain = FEDomain() fe_level1 = FERefinementGrid(domain=fe_domain, fets_eval=fets_eval) fe_grid1 = FEGrid(coord_max=(3., 1., 0.), shape=(3, 1), fets_eval=fets_eval, level=fe_level1) fe_xdomain = XFESubDomain( domain=fe_domain, fets_eval=xfets_eval, #fe_grid_idx_slice = fe_grid1[1,0], fe_grid_slice=fe_grid1['X - 1.5']) ts = TS( dof_resultants=True, sdomain=fe_domain, bcond_list=[ BCDofGroup(var='u', value=1., dims=[0], get_dof_method=fe_grid1.get_right_dofs), BCDofGroup(var='u', value=0., dims=[1], get_dof_method=fe_grid1.get_right_dofs), BCDofGroup(var='u', value=0., dims=[0, 1], get_dof_method=fe_grid1.get_left_dofs), ], rtrace_list=[ # RTraceGraph(name = 'Fi,right over u_right (iteration)' , # var_y = 'F_int', idx_y = 0, # var_x = 'U_k', idx_x = 1), # RTraceDomainListField(name = 'Stress' , # var = 'sig_app', idx = 0, warp = True ), RTraceDomainListField(name='Displacement', var='u', idx=0, warp=True), RTraceDomainListField(name='Strain', var='eps', idx=0, warp=True), # RTraceDomainField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ]) # # # Add the time-loop control tloop = TLoop( tstepper=ts, # tolerance = 1e-4, KMAX = 4, # debug = True, RESETMAX = 2, tline=TLine(min=0.0, step=1., max=1.0)) #print "elements ",fe_xdomain.elements[0] fe_xdomain.deactivate_sliced_elems() print 'parent elems ', fe_xdomain.fe_grid_slice.elems print 'parent dofs ', fe_xdomain.fe_grid_slice.dofs print "dofmap ", fe_xdomain.elem_dof_map print "ls_values ", fe_xdomain.dots.dof_node_ls_values print 'intersection points ', fe_xdomain.fe_grid_slice.r_i print "triangles ", fe_xdomain.dots.rt_triangles print "vtk points ", fe_xdomain.dots.vtk_X print "vtk data ", fe_xdomain.dots.get_vtk_cell_data('blabla', 0, 0) print 'ip_triangles', fe_xdomain.dots.int_division print 'ip_coords', fe_xdomain.dots.ip_coords print 'ip_weigths', fe_xdomain.dots.ip_weights print 'ip_offset', fe_xdomain.dots.ip_offset print 'ip_X_coords', fe_xdomain.dots.ip_X print 'ip_ls', fe_xdomain.dots.ip_ls_values print 'vtk_ls', fe_xdomain.dots.vtk_ls_values print 'J_det ', fe_xdomain.dots.J_det_grid print tloop.eval() # #ts.setup() from ibvpy.plugins.ibvpy_app import IBVPyApp ibvpy_app = IBVPyApp(ibv_resource=ts) ibvpy_app.main()
from ibvpy.mats.mats2D.mats2D_cmdm.mats2D_cmdm import \ MATS2DMicroplaneDamage from ibvpy.mats.matsXD.matsXD_cmdm import \ PhiFnStrainHardeningLinear, PhiFnStrainSoftening, \ PhiFnStrainHardening # from ibvpy.mats.mats2D5.mats2D5_cmdm.mats2D5_cmdm import \ # MATS2D5MicroplaneDamage # # from ibvpy.mats.mats3D.mats3D_elastic.mats3D_elastic import \ # MATS3DElastic # # from ibvpy.mats.matsXD.matsXD_cmdm.matsXD_cmdm_phi_fn import \ # PhiFnStrainHardeningLinear # # phi_fn = PhiFnStrainHardeningLinear(alpha=0.5, beta=0.7) # explorer = MATSExplore( # dim=MATS3DExplore(mats_eval=MATS3DElastic(E=30000., nu=0.2))) # phi_fn = PhiFnStrainHardeningLinear(alpha=0.5, beta=0.7) # phi_fn = PhiFnStrainHardening(Epp=1e-4, Efp=2e-4, Dfp=0.1, Elimit=8e-2) phi_fn = PhiFnStrainSoftening(Epp=1e-4, Efp=2e-4, h=1.0) mats_eval = MATS2DMicroplaneDamage(nu=0.3, n_mp=30, phi_fn=phi_fn) explorer = MATSExplore(dim=MATS2DExplore(mats_eval=mats_eval), n_steps=10) from ibvpy.plugins.ibvpy_app import IBVPyApp ibvpy_app = IBVPyApp(ibv_resource=explorer) ibvpy_app.main()
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 example(): from ibvpy.api import \ TStepper as TS, RTDofGraph, RTraceDomainListField, TLoop, \ TLine, IBVPSolve as IS, DOTSEval, BCSlice from ibvpy.mesh.fe_grid import FEGrid from mathkit.mfn import MFnLineArray stiffness_concrete = 34000 * 0.03 * 0.03 A_fiber = 1. E_fiber = 1. stiffness_fiber = E_fiber * A_fiber d = 2 * sqrt(Pi) tau_max = 0.1 * d * Pi G = 100 u_max = 0.023 f_max = 0.2 mats_eval = MATS1D5Bond(mats_phase1=MATS1DElastic(E=stiffness_fiber), mats_phase2=MATS1DElastic(E=0), mats_ifslip=MATS1DPlastic(E=G, sigma_y=tau_max, K_bar=0., H_bar=0.), mats_ifopen=MATS1DElastic(E=0)) fets_eval = FETS1D52L4ULRH(mats_eval=mats_eval) domain = FEGrid(coord_max=(1., 0.2), shape=(16, 1), fets_eval=fets_eval) end_dof = domain[-1, 0, -1, 0].dofs[0, 0, 0] ts = TS(dof_resultants=True, sdomain=domain, # conversion to list (square brackets) is only necessary for slicing of # single dofs, e.g "get_left_dofs()[0,1]" bcond_list=[ BCSlice(var='u', value=0., dims=[0], slice=domain[:, :, :, -1]), BCSlice(var='u', value=0., dims=[1], slice=domain[:, :, :, :]), BCSlice(var='f', value=f_max, dims=[0], slice=domain[-1, 0, -1, 0]) ], rtrace_list=[RTDofGraph(name='Fi,right over u_right (iteration)', var_y='F_int', idx_y=end_dof, var_x='U_k', idx_x=end_dof), RTraceDomainListField(name='slip', var='slip', idx=0), RTraceDomainListField(name='eps1', var='eps1', idx=0), RTraceDomainListField(name='eps2', var='eps2', idx=0), RTraceDomainListField(name='shear_flow', var='shear_flow', idx=0), RTraceDomainListField(name='sig1', var='sig1', idx=0), RTraceDomainListField(name='sig2', var='sig2', idx=0), RTraceDomainListField(name='Displacement', var='u', idx=0) ]) # Add the time-loop control tloop = TLoop(tstepper=ts, KMAX=30, debug=False, tline=TLine(min=0.0, step=0.1, max=1.0)) print(tloop.eval()) # Put the whole stuff into the simulation-framework to map the # individual pieces of definition into the user interface. # from ibvpy.plugins.ibvpy_app import IBVPyApp app = IBVPyApp(ibv_resource=tloop) app.main()
def __demo__(): from ibvpy.api import \ TStepper as TS, RTraceGraph, RTraceDomainListField, TLoop, \ TLine, BCSlice, FEDomain, FERefinementGrid from ibvpy.mats.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic fets_eval = FETS1D2L(mats_eval = MATS1DElastic(E = 10.)) from ibvpy.mesh.fe_grid import FEGrid fe_domain = FEDomain() r1 = FERefinementGrid(fets_eval = fets_eval, domain = fe_domain) r2 = FERefinementGrid(fets_eval = fets_eval, domain = fe_domain) # Discretization domain1 = FEGrid(coord_max = (3.,), shape = (3,), fets_eval = fets_eval, level = r1) domain2 = FEGrid(coord_min = (3.,), coord_max = (6.,), shape = (3,), fets_eval = fets_eval, level = r2) ts = TS(dof_resultants = True, sdomain = fe_domain, bcond_list = [BCSlice(var = 'u', dims = [0], value = 0, slice = domain1[0, 0]), BCSlice(var = 'u', dims = [0], value = 0, slice = domain1[-1, -1], link_slice = domain2[0, 0], link_coeffs = [1.]), BCSlice(var = 'f', dims = [0], value = 1, slice = domain2[-1, -1]) ], rtrace_list = [RTraceGraph(name = 'Fi,right over u_right (iteration)' , var_y = 'F_int', idx_y = 0, var_x = 'U_k', idx_x = 1), RTraceDomainListField(name = 'Stress' , var = 'sig_app', idx = 0), RTraceDomainListField(name = 'Displacement' , var = 'u', idx = 0, warp = True), RTraceDomainListField(name = 'N0' , var = 'N_mtx', idx = 0, record_on = 'update') ] ) # Add the time-loop control tloop = TLoop(tstepper = ts, tline = TLine(min = 0.0, step = 0.5, max = 1.0)) print '---- result ----' print tloop.eval() print ts.F_int print ts.rtrace_list[0].trace.ydata # Put the whole stuff into the simulation-framework to map the # individual pieces of definition into the user interface. # from ibvpy.plugins.ibvpy_app import IBVPyApp app = IBVPyApp(ibv_resource = tloop) app.main()
def __demo__(): from ibvpy.api import \ TStepper as TS, RTraceDomainListField, TLoop, \ TLine, BCSlice, FEDomain, FERefinementGrid, FEGrid from ibvpy.mats.mats2D.mats2D_elastic.mats2D_elastic import MATS2DElastic fets_eval = FETS2D4Q8U(mats_eval=MATS2DElastic()) fe_domain = FEDomain() r1 = FERefinementGrid(fets_eval=fets_eval, domain=fe_domain) r2 = FERefinementGrid(fets_eval=fets_eval, domain=fe_domain) # Discretization domain1 = FEGrid(coord_max=(3., 3.), shape=(10, 4), fets_eval=fets_eval, level=r1) domain2 = FEGrid(coord_min=(3., 0.), coord_max=(6., 3), shape=(10, 4), fets_eval=fets_eval, level=r2) ts = TS( dof_resultants=True, sdomain=[domain1, domain2], # fe_domain, bcond_list=[ # Fix the left edge of domain1 BCSlice(var='u', dims=[0, 1], value=0, slice=domain1[0, :, 0, :]), # Link the right edge of domain1 with the left edge of domain2 # # note that following arrays must have the same lengths: # slice and link_slice # dims, link_dims and link_coeffs must have the same lengths # VAR-1: # linking along the complete line between 'domain1' and 'domain2' # all nodes along the y-axis # (used linking of more nodes at once in 'BCSlice') # BCSlice(var='u', dims=[0, 1], value=0.0, slice=domain1[-1, :, -1, :], link_slice=domain2[0, :, 0, :], link_dims=[0, 1], link_coeffs=[1., 1.]), # VAR-2: # linking along individual points between 'domain1' and 'domain2' # (used linking of single nodes in 'BCSlice') # # BCSlice(var='u', dims=[0, 1], value=0.0, # slice=domain1[-1, -1, -1, -1], # link_slice=domain2[0, -1, 0, -1], # link_dims=[0, 1], # link_coeffs=[1., 1.]), # BCSlice(var='u', dims=[0, 1], value=0.0, # slice=domain1[-1, 0, -1, 0], # link_slice=domain2[0, 0, 0, 0], # link_dims=[0, 1], # link_coeffs=[1., 1.]), # Load the right edge of domain2 BCSlice(var='f', dims=[0], value=1, slice=domain2[-1, :, -1, :]) ], rtrace_list=[ RTraceDomainListField(name='Stress', var='sig_app', idx=0), RTraceDomainListField(name='Displacement', var='u', idx=0, warp=True), ]) # Add the time-loop control tloop = TLoop(tstepper=ts, debug=False, tline=TLine(min=0.0, step=1.0, max=1.0)) print '---- result ----' print tloop.eval() # Put the whole stuff into the simulation-framework to map the # individual pieces of definition into the user interface. # from ibvpy.plugins.ibvpy_app import IBVPyApp app = IBVPyApp(ibv_resource=tloop) app.main()
def app(): avg_radius = 0.03 md = MATS2DScalarDamage( E=20.0e3, nu=0.2, epsilon_0=1.0e-4, epsilon_f=8.0e-4, #epsilon_f = 12.0e-4, #test doubling the e_f stress_state="plane_strain", stiffness="secant", #stiffness = "algorithmic", strain_norm=Rankine()) mdm = MATS2DMicroplaneDamage( E=20.0e3, nu=0.2, #epsilon_f = 12.0e-4, #test doubling the e_f stress_state="plane_strain", model_version='compliance', phi_fn=PhiFnStrainSoftening(G_f=0.0014, f_t=2.0, md=0.0, h=2. * avg_radius)) # mp = MATSProxy( mats_eval = mdm ) # mp.varpars['epsilon_0'].switch = 'varied' # mp.varpars['epsilon_0'].spatial_fn = MFnNDGrid( shape = ( 8, 5, 1 ), # active_dims = ['x', 'y'], # x_mins = GridPoint( x = 0., y = 0. ), # x_maxs = GridPoint( x = length, y = heigth ) ) # mp.varpars['epsilon_0'].spatial_fn.set_values_in_box( 500., [0, 0, 0], [0.2, 0.2, 0.] ) # mp.varpars['epsilon_0'].spatial_fn.set_values_in_box( 500., [0.8, 0, 0], [1., 0.2, 0.] ) # mp.varpars['epsilon_0'].spatial_fn.set_values_in_box( 50., [0., 0.46, 0], [1., 0.5, 0.] ) # me = MATS2DElastic( E = 20.0e3, # nu = 0.2, # stress_state = "plane_strain" ) fets_eval = FETS2D4Q(mats_eval=mdm) #, ngp_r = 3, ngp_s = 3) n_el_x = 20 # 60 # Discretization fe_grid = FEGrid(coord_max=(.6, .15, 0.), shape=(n_el_x, n_el_x / 4), fets_eval=fets_eval) mf = MFnLineArray(xdata=array([0, 1, 2]), ydata=array([0, 3., 3.2])) #averaging function avg_processor = RTNonlocalAvg( avg_fn=QuarticAF(radius=avg_radius, correction=True)) loading_dof = fe_grid[n_el_x / 2, -1, 0, -1].dofs.flatten()[1] print('loading_dof', loading_dof) ts = TS( sdomain=fe_grid, u_processor=avg_processor, bcond_list=[ # constraint for all left dofs in y-direction: BCSlice(var='u', slice=fe_grid[0, 0, 0, 0], dims=[0, 1], value=0.), BCSlice(var='u', slice=fe_grid[-1, 0, -1, 0], dims=[1], value=0.), BCSlice(var='u', slice=fe_grid[n_el_x / 2, -1, 0, -1], dims=[1], time_function=mf.get_value, value=-2.0e-4), ], rtrace_list=[ RTDofGraph(name='Fi,right over u_right (iteration)', var_y='F_int', idx_y=loading_dof, var_x='U_k', idx_x=loading_dof, record_on='update'), RTraceDomainListField(name='Deformation', var='eps_app', idx=0, record_on='update'), RTraceDomainListField(name='Deformation', var='sig_app', idx=0, record_on='update'), RTraceDomainListField(name='Displacement', var='u', idx=1, record_on='update', warp=True), RTraceDomainListField(name='fracture_energy', var='fracture_energy', idx=0, record_on='update', warp=True), RTraceDomainListField(name='Damage', var='omega_mtx', idx=0, warp=True, record_on='update'), # RTraceDomainField(name = 'Stress' , # var = 'sig', idx = 0, # record_on = 'update'), # RTraceDomainField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ]) # Add the time-loop control # tl = TLoop(tstepper=ts, tolerance=5.0e-5, KMAX=200, tline=TLine(min=0.0, step=.1, max=1.0)) tl.eval() # Put the whole stuff into the simulation-framework to map the # individual pieces of definition into the user interface. # from ibvpy.plugins.ibvpy_app import IBVPyApp ibvpy_app = IBVPyApp(ibv_resource=ts) ibvpy_app.main()
# # Define a mesh domain adaptor as a cached property to # be constracted on demand # mgrid_adaptor = MeshGridAdaptor( n_nodal_dofs = 2, # # NOTE: the following properties must be defined and # # must correspond to the used element formulation # n_e_nodes_geo = (1,1,0), # n_e_nodes_dof = (1,1,0), # node_map_geo = [0,1,3,2], # node_map_dof = [0,1,3,2] ) # Discretization # grid_domain = MGridDomain(lengths=(3., 3., 0.), shape=(1, 1, 1), adaptor=mgrid_adaptor) # grid_domain.configure_traits() grid_domain.elements # grid_domain.changed = True from ibvpy.plugins.ibvpy_app import IBVPyApp ibvpy_app = IBVPyApp(ibv_resource=grid_domain) ibvpy_app.main() class RTraceSubDomainField(RTraceDomainField): recursion = False
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()
return full_node_map #------------------------------------------------------------------ # UI - related methods #------------------------------------------------------------------ traits_view = View(Item('grid_cell_spec'), Item('refresh_button'), Item('node_map'), resizable=True, height=0.5, width=0.5) class MGridPntCell(MGridCell): ''' ''' class MGridDofCell(MGridCell): ''' ''' if __name__ == '__main__': mgc = MGridCell(grid_cell_spec=MGridCellSpec()) from ibvpy.plugins.ibvpy_app import IBVPyApp ibvpy_app = IBVPyApp(ibv_resource=mgc) ibvpy_app.main()
def xtest_L_shaped(): '''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''' mp = MATS2DScalarDamage( E=34.e3, nu=0.2, epsilon_0=59.e-6, epsilon_f=3.2e-3, #epsilon_f = 3.2e-1, #stiffness = "algorithmic", strain_norm_type='Mises') # mp = MATS2DElastic( E = 34.e3, # nu = 0.2 ) fets_eval = FETS2D4Q(mats_eval=mp) discr = (10, 10) # Discretization fe_domain1 = FEGrid(coord_min=(0, 0, 0), coord_max=(1., 1., 0.), shape=discr, n_nodal_dofs=fets_eval.n_nodal_dofs, dof_r=fets_eval.dof_r, geo_r=fets_eval.geo_r) fe_domain2 = FEGrid(coord_min=(0., 1., 0), coord_max=(1., 2., 0.), shape=discr, n_nodal_dofs=fets_eval.n_nodal_dofs, dof_r=fets_eval.dof_r, geo_r=fets_eval.geo_r) fe_domain3 = FEGrid(coord_min=(1., 1., 0), coord_max=(2., 2., 0.), shape=discr, n_nodal_dofs=fets_eval.n_nodal_dofs, 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=[ BCDofGroup(var='u', value=0., dims=[0, 1], get_dof_method=fe_domain1.get_bottom_dofs), BCDofGroup(var='u', value=0., dims=[0, 1], get_dof_method=fe_domain3.get_left_dofs, get_link_dof_method=fe_domain2.get_right_dofs, link_coeffs=[1.]), BCDofGroup(var='u', value=0., dims=[0, 1], get_dof_method=fe_domain2.get_bottom_dofs, get_link_dof_method=fe_domain1.get_top_dofs, link_coeffs=[1.]), BCDofGroup(var='u', value=0.0004, dims=[1], get_dof_method=fe_domain3.get_right_dofs) ], rtrace_list=[ RTraceDomainListField(name='Displacement', var='u', idx=1), RTraceDomainListField(name='Damage', var='omega', idx=0, record_on='update', warp=True), # RTraceDomainListField(name = 'Stress' , # var = 'sig_app', idx = 0, # record_on = 'update', # warp = False), # RTraceDomainListField(name = 'Strain' , # var = 'eps_app', idx = 0, # record_on = 'update', # warp = False), ]) # Add the time-loop control global tloop tloop = TLoop(tstepper=ts, tolerance=1e-4, KMAX=50, tline=TLine(min=0.0, step=0.2, max=1.0)) tloop.eval() # import cProfile # cProfile.run('tloop.eval()', 'tloop_prof' ) # # 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) from ibvpy.plugins.ibvpy_app import IBVPyApp app = IBVPyApp(ibv_resource=tloop) app.main()
def example_with_new_domain(): from ibvpy.api import \ TStepper as TS, RTraceDomainListField, TLoop, \ TLine, BCSlice from ibvpy.fets.fets2D.fets2D4q8u import FETS2D4Q8U from ibvpy.tmodel.mats3D.mats3D_cmdm import \ MATS3DMicroplaneDamage from ibvpy.tmodel.matsXD.matsXD_cmdm import PhiFnStrainSoftening # tmodel = MATS2DElastic(E=2,nu= .2, # stress_state= 'rotational_symetry') mats = MATS3DMicroplaneDamage(model_version='stiffness', E=34e3, nu=0.2, phi_fn=PhiFnStrainSoftening(G_f=0.001117, f_t=2.8968)) fets_eval = FETS2Drotsym(prototype_fets=FETS2D4Q8U(), mats_eval=mats) fets_eval.vtk_r *= 0.9 from ibvpy.mesh.fe_grid import FEGrid radius = sqrt(1. / pi) # f_i = (radius/2.)*2*pi # f_o = (radius)*2*pi # print 'f ',f_i,' ', f_o # Discretization fe_grid = FEGrid( # coord_min = (0.,radius/2.,0.), coord_max=(1., radius, 0.), shape=(20, 20), fets_eval=fets_eval) tstepper = TS(sdomain=fe_grid, bcond_list=[ BCSlice(var='u', value=0., dims=[0], slice=fe_grid[0, :, 0, :]), BCSlice(var='u', value=0., dims=[1], slice=fe_grid[0, 0, 0, 0]), BCSlice(var='u', value=1.e-3, dims=[0], slice=fe_grid[-1, :, -1, :]), ], rtrace_list=[ RTraceDomainListField(name='Stress', var='sig_app', idx=0, warp=True, record_on='update'), RTraceDomainListField(name='fracture_energy', var='fracture_energy', idx=0, warp=True, record_on='update'), RTraceDomainListField(name='Displacement', var='u', idx=0, record_on='update', warp=True), # RTraceDomainListField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ] ) # Add the time-loop control #global tloop tloop = TLoop(tstepper=tstepper, KMAX=300, tolerance=1e-4, tline=TLine(min=0.0, step=1.0, max=1.0)) #import cProfile #cProfile.run('tloop.eval()', 'tloop_prof' ) print(tloop.eval()) #import pstats #p = pstats.Stats('tloop_prof') # p.strip_dirs() # print 'cumulative' # p.sort_stats('cumulative').print_stats(20) # print 'time' # p.sort_stats('time').print_stats(20) # Put the whole thing into the simulation-framework to map the # individual pieces of definition into the user interface. # from ibvpy.plugins.ibvpy_app import IBVPyApp app = IBVPyApp(ibv_resource=tloop) app.main()
def example_with_new_domain(): from ibvpy.api import \ TStepper as TS, RTraceDomainListField, TLoop, TLine from ibvpy.tmodel.mats2D5.mats2D5_bond.mats2D_bond import MATS2D5Bond from ibvpy.api import BCDofGroup from ibvpy.fets.fets2D.fets2D4q import FETS2D4Q fets_eval = FETS2DTF(parent_fets=FETS2D4Q(), mats_eval=MATS2D5Bond(E_m=30, nu_m=0.2, E_f=10, nu_f=0.1, G=10.)) from ibvpy.mesh.fe_grid import FEGrid from mathkit.mfn import MFnLineArray # Discretization fe_grid = FEGrid(coord_max=(10., 4., 0.), n_elems=(10, 3), fets_eval=fets_eval) mf = MFnLineArray( # xdata = arange(10), ydata=array([0, 1, 2, 3])) tstepper = TS(sdomain=fe_grid, bcond_list=[BCDofGroup(var='u', value=0., dims=[0, 1], get_dof_method=fe_grid.get_left_dofs), # BCDofGroup( var='u', value = 0., dims = [1], # get_dof_method = fe_grid.get_bottom_dofs ), BCDofGroup(var='u', value=.005, dims=[0], time_function=mf.get_value, get_dof_method=fe_grid.get_right_dofs)], rtrace_list=[ # RTDofGraph(name = 'Fi,right over u_right (iteration)' , # var_y = 'F_int', idx_y = right_dof, # var_x = 'U_k', idx_x = right_dof, # record_on = 'update'), # RTraceDomainListField(name = 'Stress' , # var = 'sig_app', idx = 0, # #position = 'int_pnts', # record_on = 'update'), # RTraceDomainListField(name = 'Damage' , # var = 'omega', idx = 0, # record_on = 'update', # warp = True), RTraceDomainListField(name='Displ matrix', var='u_m', idx=0, record_on='update', warp=True), RTraceDomainListField(name='Displ reinf', var='u_f', idx=0, record_on='update', warp=True), # RTraceDomainListField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ] ) # Add the time-loop control #global tloop tloop = TLoop(tstepper=tstepper, KMAX=300, tolerance=1e-4, tline=TLine(min=0.0, step=1.0, max=1.0)) #import cProfile #cProfile.run('tloop.eval()', 'tloop_prof' ) print(tloop.eval()) #import pstats #p = pstats.Stats('tloop_prof') # p.strip_dirs() # print 'cumulative' # p.sort_stats('cumulative').print_stats(20) # print 'time' # p.sort_stats('time').print_stats(20) # Put the whole thing into the simulation-framework to map the # individual pieces of definition into the user interface. # from ibvpy.plugins.ibvpy_app import IBVPyApp app = IBVPyApp(ibv_resource=tloop) app.main()
def example_1d(): fets_eval = FETS1D2L3U(mats_eval=MATS1DElastic(E=20.)) xfets_eval = FETSCrack(parent_fets=fets_eval, int_order=2) # Discretization fe_domain = FEDomain() fe_level1 = FERefinementGrid(domain=fe_domain, fets_eval=fets_eval) fe_grid1 = FEGrid(coord_max=(2., 0., 0.), shape=(2, ), fets_eval=fets_eval, level=fe_level1) enr = True if enr: fe_xdomain = XFESubDomain( domain=fe_domain, fets_eval=xfets_eval, #fe_grid_idx_slice = fe_grid1[1,0], fe_grid_slice=fe_grid1['X - .75']) fe_xdomain.deactivate_sliced_elems() ts = TS( dof_resultants=True, sdomain=fe_domain, bcond_list=[ BCSlice(var='u', value=-1. / 2., dims=[0], slice=fe_grid1[0, 0]), BCSlice(var='u', value=0., dims=[0], slice=fe_grid1[-1, -1]), ], rtrace_list=[ # RTDofGraph(name = 'Fi,right over u_right (iteration)' , # var_y = 'F_int', idx_y = 0, # var_x = 'U_k', idx_x = 1), RTraceDomainListField(name='Stress', var='eps', idx=0, warp=True), RTraceDomainListField(name='Displacement', var='u', idx=0, warp=True), # RTraceDomainField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ]) # # # Add the time-loop control tloop = TLoop(tstepper=ts, debug=True, tolerance=1e-4, RESETMAX=0, tline=TLine(min=0.0, step=1, max=1.0)) #print "elements ",fe_xdomain.elements[0] if enr: print('parent elems ', fe_xdomain.fe_grid_slice.elems) print('parent dofs ', fe_xdomain.fe_grid_slice.dofs) print("dofmap ", fe_xdomain.elem_dof_map) print("ls_values ", fe_xdomain.dots.dof_node_ls_values) print('intersection points ', fe_xdomain.fe_grid_slice.r_i) # print("triangles ", fe_xdomain.dots.int_division) print('ip_coords', fe_xdomain.dots.ip_coords) print('ip_weigths', fe_xdomain.dots.ip_weights) print('ip_offset ', fe_xdomain.dots.ip_offset) print('ip_X_coords', fe_xdomain.dots.ip_X) print('ip_ls', fe_xdomain.dots.ip_ls_values) print('vtk_X ', fe_xdomain.dots.vtk_X) print('vtk triangles ', fe_xdomain.dots.rt_triangles) print("vtk data ", fe_xdomain.dots.get_vtk_cell_data('blabla', 0, 0)) print('vtk_ls', fe_xdomain.dots.vtk_ls_values) print('J_det ', fe_xdomain.dots.J_det_grid) tloop.eval() from ibvpy.plugins.ibvpy_app import IBVPyApp ibvpy_app = IBVPyApp(ibv_resource=ts) ibvpy_app.main()
def app(): avg_radius = 0.03 md = MATS2DScalarDamage(E=20.0e3, nu=0.2, epsilon_0=1.0e-4, epsilon_f=8.0e-4, #epsilon_f = 12.0e-4, #test doubling the e_f stress_state="plane_strain", stiffness="secant", #stiffness = "algorithmic", strain_norm=Rankine()) # me = MATS2DElastic( E = 20.0e3, # nu = 0.2, # stress_state = "plane_strain" ) fets_eval = FETS2D4Q(mats_eval=md)#, ngp_r = 3, ngp_s = 3) n_el_x = 60 # Discretization fe_grid = FEGrid(coord_max=(.6, .15, 0.), shape=(n_el_x, 15), fets_eval=fets_eval) mf = MFnLineArray(xdata=array([0, 1, 2, 7, 8 , 28]), ydata=array([0, 3., 3.2, 3.3, 3.32, 3.72 ])) #averaging function avg_processor = RTNonlocalAvg(avg_fn=QuarticAF(radius=avg_radius, correction=True)) ts = TS(sdomain=fe_grid, u_processor=avg_processor, bcond_list=[ # constraint for all left dofs in y-direction: BCSlice(var='u', slice=fe_grid[0, 0, 0, 0], dims=[0, 1], value=0.), BCSlice(var='u', slice=fe_grid[-1, 0, -1, 0], dims=[1], value=0.), BCSlice(var='u', slice=fe_grid[n_el_x / 2, -1, 0, -1], dims=[1], time_function=mf.get_value, value= -2.0e-5), ], rtrace_list=[ # RTDofGraph(name = 'Fi,right over u_right (iteration)' , # var_y = 'F_int', idx_y = right_dof, # var_x = 'U_k', idx_x = right_dof, # record_on = 'update'), RTraceDomainListField(name='Deformation' , var='eps_app', idx=0, record_on='update'), RTraceDomainListField(name='Displacement' , var='u', idx=1, record_on='update', warp=True), RTraceDomainListField(name='Damage' , var='omega', idx=0, record_on='update', warp=True), # RTraceDomainField(name = 'Stress' , # var = 'sig', idx = 0, # record_on = 'update'), # RTraceDomainField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ] ) # Add the time-loop control # tl = TLoop(tstepper=ts, tolerance=5.0e-4, KMAX=100, tline=TLine(min=0.0, step=.25, max=10.0)) tl.eval() # Put the whole stuff into the simulation-framework to map the # individual pieces of definition into the user interface. # from ibvpy.plugins.ibvpy_app import IBVPyApp ibvpy_app = IBVPyApp(ibv_resource=ts) ibvpy_app.main()
def example_2d(): from ibvpy.api import FEDomain, FERefinementGrid, FEGrid, TStepper as TS, \ BCDofGroup, RTraceDomainListField from ibvpy.core.tloop import TLoop, TLine from ibvpy.mesh.xfe_subdomain import XFESubDomain from ibvpy.mats.mats2D.mats2D_elastic.mats2D_elastic import MATS2DElastic from ibvpy.mats.mats2D import MATS2DPlastic from ibvpy.fets.fets2D.fets2D4q import FETS2D4Q from ibvpy.fets.fets2D import FETS2D9Q from ibvpy.fets.fets2D.fets2D4q8u import FETS2D4Q8U from ibvpy.fets.fets_ls.fets_crack import FETSCrack #fets_eval = FETS2D4Q( mats_eval = MATS2DPlastic( E = 1., nu = 0. ) ) fets_eval = FETS2D4Q8U(mats_eval=MATS2DPlastic(E=1., nu=0.)) xfets_eval = FETSCrack(parent_fets=fets_eval, int_order=5, tri_subdivision=1) # Discretization fe_domain = FEDomain() fe_level1 = FERefinementGrid(domain=fe_domain, fets_eval=fets_eval) fe_grid1 = FEGrid(coord_max=(1., 1.), shape=(8, 8), fets_eval=fets_eval, level=fe_level1) #ls_function = lambda X, Y: X - Y - 0.13 ls_function = lambda X, Y: (X - 0.52)**2 + (Y - 0.72)**2 - 0.51**2 bls_function = lambda X, Y: -((X - 0.5)**2 + (Y - 0.21)**2 - 0.28**2) bls_function2 = lambda X, Y: -((X - 0.5)**2 + (Y - 0.21)**2 - 0.38**2) # design deficits: # - How to define a level set spanned over several fe_grids # (i.e. it is defined over the hierarchy of FESubDomains) # - Patching of subdomains within the FEPatchedGrid (FERefinementGrid) # - What are the compatibility conditions? # - What is the difference between FEGridLeveSetSlice # and FELSDomain? # FELSDomain is associated with a DOTS - Slice is not. # FEGrid has a multidimensional array - elem_grid # it can be accessed through this index. # it is masked by the activity map. The activity map can # be defined using slices and level sets. # the elems array enumerates the elements using the activity map. # in this way, the specialization of grids is available implicitly. # fe_xdomain = FELSDomain( domain=fe_domain, fets_eval=xfets_eval, fe_grid=fe_grid1, ls_function=ls_function, bls_function=bls_function, ) fe_tip_xdomain = FELSDomain( domain=fe_domain, fets_eval=xfets_eval, fe_grid=fe_xdomain, ls_function=bls_function, ) # deactivation must be done only after the dof enumeration has been completed fe_xdomain.deactivate_intg_elems_in_parent() fe_tip_xdomain.deactivate_intg_elems_in_parent() fe_xdomain.bls_function = bls_function2 fe_tip_xdomain.ls_function = bls_function2 # deactivation must be done only after the dof enumeration has been completed fe_xdomain.deactivate_intg_elems_in_parent() fe_tip_xdomain.deactivate_intg_elems_in_parent() # # General procedure: # 1) define the level sets with the boundaries # 2) use the bls to identify the tips of the level set # 3) use independent level sets to introduce indpendently junctions. # # get the extended dofs of the bls_elems and constrain it # cdofs = fe_tip_xdomain.elem_xdof_map.flatten() bc_list = [BCDof(var='u', dof=dof, value=0.0) for dof in cdofs] # construct the time stepper ts = TS( dof_resultants=True, sdomain=fe_domain, bcond_list=[ BCSlice( var='u', value=-0.1, dims=[1], slice=fe_grid1[:, 0, :, 0]), BCSlice( var='u', value=0., dims=[0], slice=fe_grid1[:, 0, :, 0]), BCSlice(var='u', value=0., dims=[0, 1], slice=fe_grid1[:, -1, :, -1]) ] + bc_list, rtrace_list=[ # RTDofGraph(name = 'Fi,right over u_right (iteration)' , # var_y = 'F_int', idx_y = 0, # var_x = 'U_k', idx_x = 1), RTraceDomainListField(name='Stress', var='sig_app', idx=0, warp=True), RTraceDomainListField(name='Displacement', var='u', idx=0, warp=True), # RTraceDomainField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ]) # do = 'print' if do == 'print': p = 'state' if p == 'grids': print('fe_xdomain.ls mask') print(fe_xdomain.ls_mask) print('fe_xdomain.idx mask') print(fe_xdomain.idx_mask) print('fe_xdomain.intg mask') print(fe_xdomain.intg_mask) print('fe_xdomain.xelems_mask') print(fe_xdomain.xelems_mask) print('fe_xdomain.xelems_grid_ix') print(fe_xdomain.xelems_grid_ix) print('fe_xdomain.ls_elem_grid') print(fe_xdomain.ls_elem_grid) print('fe_xdomain.ls_ielem_grid') print(fe_xdomain.ls_ielem_grid) print('fe_xdomain.intg_elem_grid') print(fe_xdomain.intg_elem_grid) print('fe_tip_xdomain.ls_mask`') print(fe_tip_xdomain.ls_mask) print('fe_tip_xdomain.intg_mask`') print(fe_tip_xdomain.intg_mask) print('fe_tip_xdomain.idx_mask`') print(fe_tip_xdomain.idx_mask) print('fe_tip_xdomain.xelems_mask') print(fe_tip_xdomain.xelems_mask) print('fe_tip_xdomain.xelems_grid_ix') print(fe_tip_xdomain.xelems_grid_ix) print('fe_tip_xdomain.ls_elem_grid') print(fe_tip_xdomain.ls_elem_grid) print('fe_tip_xdomain.ls_ielems_grid') print(fe_tip_xdomain.ls_ielem_grid) print('fe_tip_xdomain.intg_elem_grid') print(fe_tip_xdomain.intg_elem_grid) if p == 'maps': print('fe_xdomain.elem_dof_map') print(fe_xdomain.elem_dof_map) print('fe_tip_xdomain.elem_dof_map') print(fe_tip_xdomain.elem_dof_map) print('fe_xdomain.elems') print(fe_xdomain.elems) print('fe_tip_xdomain.elems') print(fe_tip_xdomain.elems) print('fe_xdomain.elem_X_map') print(fe_xdomain.elem_X_map) print('fe_tip_xdomain.elem_X_map') print(fe_tip_xdomain.elem_X_map) if p == 'fields': print("ls_values ", fe_xdomain.dots.dof_node_ls_values) print("tip ls_values ", fe_tip_xdomain.dots.dof_node_ls_values) print('intersection points ', fe_xdomain.ls_intersection_r) print('tip intersection points ', fe_tip_xdomain.ls_intersection_r) print("triangles ", fe_xdomain.dots.rt_triangles) print("vtk points ", fe_xdomain.dots.vtk_X) print("vtk data ", fe_xdomain.dots.get_vtk_cell_data('blabla', 0, 0)) print('ip_triangles', fe_xdomain.dots.int_division) print('ip_coords', fe_xdomain.dots.ip_coords) print('ip_weigths', fe_xdomain.dots.ip_weights) print('ip_offset', fe_xdomain.dots.ip_offset) print('ip_X_coords', fe_xdomain.dots.ip_X) print('ip_ls', fe_xdomain.dots.ip_ls_values) print('vtk_ls', fe_xdomain.dots.vtk_ls_values) print('J_det ', fe_xdomain.dots.J_det_grid) if p == 'state': # Add the time-loop control print('STATE: initial') print('fe_xdomain.dots.state_elem grid') print(fe_xdomain.dots.state_start_elem_grid) print('fe_tip_xdomain.dots.state_elem grid') print(fe_tip_xdomain.dots.state_start_elem_grid) print('fe_xdomain.dots.state_end_elem grid') print(fe_xdomain.dots.state_end_elem_grid) print('fe_tip_xdomain.dots.state_end_elem grid') print(fe_tip_xdomain.dots.state_end_elem_grid) fe_xdomain.dots.state_array[:] = 25.5 print('state_array 25', fe_xdomain.dots.state_array) fe_tip_xdomain.dots.state_array[:] = 58 bls_function3 = lambda X, Y: -((X - 0.5)**2 + (Y - 0.21)**2 - 0.58**2) fe_xdomain.bls_function = bls_function3 fe_tip_xdomain.ls_function = bls_function3 print('STATE: changed') print('fe_xdomain.dots.state_elem grid') print(fe_xdomain.dots.state_start_elem_grid) print('fe_tip_xdomain.dots.state_elem grid') print(fe_tip_xdomain.dots.state_start_elem_grid) print('fe_xdomain.dots.state_end_elem grid') print(fe_xdomain.dots.state_end_elem_grid) print('fe_tip_xdomain.dots.state_end_elem grid') print(fe_tip_xdomain.dots.state_end_elem_grid) print('state_array 25', fe_xdomain.dots.state_array.shape) print('state_array 25', fe_xdomain.dots.state_array[570:]) print('state_array 58', fe_tip_xdomain.dots.state_array.shape) elif do == 'ui': tloop = TLoop(tstepper=ts, debug=False, tolerance=1e-4, KMAX=3, RESETMAX=0, tline=TLine(min=0.0, step=1, max=1.0)) tloop.eval() from ibvpy.plugins.ibvpy_app import IBVPyApp ibvpy_app = IBVPyApp(ibv_resource=ts) ibvpy_app.main()
return nu if __name__ == '__main__': sim_model = SimBT4PTDB(ccs_unit_cell_key='FIL-10-09_2D-05-11_0.00462_all0', calibration_test='TT-12c-6cm-0-TU-SH2F-V3', age=23) do = 'ui' # do = 'validation' # do = 'show_last_results' if do == 'ui': sim_model.tloop.eval() from ibvpy.plugins.ibvpy_app import IBVPyApp app = IBVPyApp(ibv_resource=sim_model) app.main() if do == 'param_study': # influence of the calibration test # param_list = [ 'TT-12c-6cm-TU-SH1F-V1', 'TT-12c-6cm-0-TU-SH2F-V2', 'TT-12c-6cm-0-TU-SH2F-V3' ] for param_key in param_list: run_key = 'f_w_diagram_x_olmyz-22211_Ec-28600_nu-025_tol-m_nsteps-20_' + param_key sim_model = SimFourPointBendingDB( ccs_unit_cell_key='FIL-10-09_2D-05-11_0.00462_all0', calibration_test=param_key,
# x,y = - r * cos( phi ), r * sin( phi ) # return c_[ x,y ] # #fe_domain_arch_2d = FEGrid( geo_r = [[-1,-1 ], # [-1, 1 ], # [ 1,-1 ], # [ 1, 1 ]], # dof_r = [[-1,-1 ], # [-1, 1 ], # [ 1,-1 ], # [ 1, 1 ]], # shape = ( 10, 3 ), # geo_transform = arch_2d ) if __name__ == '__main__': from ibvpy.fets.fets_eval import FETSEval fets_eval = FETSEval(geo_r=[[-1, -1, -1], [-1, -1, 1], [-1, 1, -1], [-1, 1, 1], [1, -1, -1], [1, -1, 1], [1, 1, -1], [1, 1, 1]], dof_r=[[-1, 0, 0], [1, 0, 0], [0, 0, -1], [0, 0, 1], [0, -1, 0], [0, 1, 0]]) fe_domain_arch_3d = FEGrid(fets_eval=fets_eval, coord_max=(10., 1, 10.), shape=(10, 3, 10), geo_transform=arch_3d) from ibvpy.plugins.ibvpy_app import IBVPyApp ibvpy_app = IBVPyApp(ibv_resource=fe_domain_arch_3d) ibvpy_app.main()
dims=[1], get_dof_method=domain.get_bottom_left_dofs), BCDofGroup(var='u', value=0.002, dims=[0], get_dof_method=domain.get_right_dofs) ], rtrace_list=[ # RTDofGraph(name = 'Fi,right over u_right (iteration)' , # var_y = 'F_int', idx_y = right_dof, # var_x = 'U_k', idx_x = right_dof), # RTraceDomainField(name = 'Stress' , # var = 'sig_app', idx = 0, # record_on = 'update'), RTraceDomainListField(name='Displacement', var='u', idx=0), # RTraceDomainField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ]) # Add the time-loop control tl = TLoop(tstepper=ts, tline=TLine(min=0.0, step=0.5, max=1.0)) tl.eval() # Put the whole stuff into the simulation-framework to map the # individual pieces of definition into the user interface. # from ibvpy.plugins.ibvpy_app import IBVPyApp app = IBVPyApp(ibv_resource=tl) app.main()
def 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()