def _get_tloop(self): roof = self.fe_grid_roof column = self.fe_grid_column plate = self.fe_grid_plate ts = TS( sdomain=[roof, plate, column], dof_resultants=True, bcond_list= # boundary conditions # self.bc_roof_top_roof_low_link_list + self.bc_plate_column_link_list + self.bc_plate_roof_link_list + self.link_edge_list + self.bc_col_clamped_list + # loading # self.lc_g_list, rtrace_list=self.rtrace_list) # Add the time-loop control tloop = TLoop(tstepper=ts, tolerance=1e-4, tline=self.tline) self.edge_corner_1_dof = roof[0, 0, 0, 0, 0, 0].dofs self.edge_corner_2_dof = roof[-1, 0, -1, -1, 0, -1].dofs self.dof = roof[-1, 0, -1, -1, 0, -1].dofs[0][0][0] self.edge_roof_top = roof[:, -1, -1, :, -1, -1].dofs self.edge_roof_right = roof[-1, :, -1, -1, :, -1].dofs return tloop
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_tloop(self): self.fets.vtk_r *= 0.95 domain = self.fe_grid self.center_top_dof = domain[-1, -1, -1, -1].dofs # NOTE: additional line-loads at the edge of the roof need to be considered! # upper_surface = domain[:, :, -1, :, :, -1] # whole_domain = domain[:, :, :, :, :, :] bcond_list = [ BCSlice(var='u', dims=[0, 1], slice=domain[0, 0, 0, 0], value=0), BCSlice(var='u', dims=[0], slice=domain[0, -1, 0, -1], value=0), ] # w_z = domain[-1, -1, -1, -1].dofs[0] # self.f_w_diagram = RTraceGraph( name = 'load - corner deflection', # var_x = 'U_k', idx_x = w_z, # var_y = 'time', idx_y = 0, # record_on = 'update' ) # rtrace_list = self.rtrace_list#[ self.f_w_diagram ] + self.rtrace_list ts = TS(sdomain=[domain], dof_resultants=True, bcond_list=bcond_list, rtrace_list=self.rtrace_list) # Add the time-loop control tloop = TLoop(tstepper=ts, tolerance=1e-4, tline=self.tline) return tloop
def _get_tloop(self): # self.fets.vtk_r *= 0.95 roofs = self.fe_grid_roofs columns = self.fe_grid_columns r00, r10, r01, r11 = roofs self.corner_dof_r00 = r00[0, 0, 0, 0, 0, 0].dofs rtrace_list = self.rtrace_list ts = TS( sdomain=roofs + columns, dof_resultants=True, # bcond_list = self.wind_bc_list + self.displ_bc_list + self.link_bc_list, bcond_list=self.force_bc_list + self.displ_bc_list + self.link_bc_list, # bcond_list = self.displ_bc_list + self.link_bc_list, rtrace_list=rtrace_list) # Add the time-loop control tloop = TLoop(tstepper=ts, tolerance=1e-4, tline=self.tline) return tloop
def example_1d(): from ibvpy.mats.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic from ibvpy.fets.fets1D.fets1D2l import FETS1D2L fets_eval = FETS1D2L(mats_eval=MATS1DElastic()) # Discretization fe_domain = FEDomain() fe_level1 = FERefinementGrid(domain=fe_domain, fets_eval=fets_eval) fe_domain1 = FEGrid(coord_max=(3., 0., 0.), shape=(3, ), level=fe_level1, fets_eval=fets_eval) fe_child_domain = FERefinementGrid(parent_domain=fe_level1, fine_cell_shape=(2, )) fe_child_domain.refine_elem((1, )) ts = TS(domain=fe_domain, dof_resultants=True, sdomain=fe_domain, bcond_list=[ BCDof(var='u', dof=0, value=0.), BCDof(var='f', dof=3, value=1.) ]) # Add the time-loop control tloop = TLoop(tstepper=ts, debug=True, tline=TLine(min=0.0, step=1, max=1.0)) print tloop.eval()
def eval(self): '''Run the time loop. ''' # avg_processor = None if self.avg_radius > 0.0: avg_processor = RTNonlocalAvg(sd=self.fe_domain, avg_fn=QuarticAF( radius=self.avg_radius, correction=True)) ts = TS(u_processor=avg_processor, dof_resultants=True, sdomain=self.fe_domain, bcond_list=self.bc_list, rtrace_list=self.rt_list) # Add the time-loop control tloop = TLoop(tstepper=ts, KMAX=300, tolerance=1e-8, debug=False, verbose_iteration=False, verbose_time=False, tline=TLine(min=0.0, step=self.step_size, max=1.0)) tloop.eval() tloop.accept_time_step() self.plot_time_function() self.plot_tracers()
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 notched_bended_beam(): fets_eval_4u = FETS2D4Q(mats_eval=MATS2DScalarDamage()) fets_eval_cracked = FETSLSEval(parent_fets=fets_eval_4u) # Discretization fe_domain1 = FEGrid(coord_max=(5., 2., 0.), shape=(3, 2), fets_eval=fets_eval_4u) fe_child_domain = FERefinementGrid(parent_domain=fe_domain1, fets_eval=fets_eval_cracked, fine_cell_shape=(1, 1)) crack_level_set = lambda X: X[0] - 2.5 fe_child_domain.refine_elem((1, 0), crack_level_set) dots = fe_child_domain.new_dots() fe_domain = FEDomainList(subdomains=[fe_domain1]) fe_domain_tree = FEDomainTree(domain_list=fe_domain) ts = TS( dof_resultants=True, sdomain=[fe_domain1, fe_child_domain], bcond_list=[ BCDofGroup(var='u', value=0., dims=[0, 1], get_dof_method=fe_domain1.get_left_dofs), BCDofGroup(var='u', value=0., dims=[0, 1], get_dof_method=fe_domain1.get_right_dofs), BCDofGroup(var='f', value=-1., dims=[1], get_dof_method=fe_domain1.get_top_dofs), ], rtrace_list=[ # RTDofGraph(name = 'Fi,right over u_right (iteration)' , # var_y = 'F_int', idx_y = 0, # var_x = 'U_k', idx_x = 1), # RTraceDomainListField(name = 'Stress' , # var = 'sig_app', idx = 0, warp = True ), # RTraceDomainField(name = 'Displacement' , # var = 'u', idx = 0), # RTraceDomainField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') # ]) # Add the time-loop control tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=1, max=1.0)) print(tloop.eval())
def run_example(): from ibvpy.api import \ TStepper as TS, RTraceGraph, RTraceDomainListField, \ RTraceDomainListInteg, TLoop, \ TLine, BCDof, IBVPSolve as IS, DOTSEval from ibvpy.mats.mats2D.mats2D_conduction.mats2D_conduction import MATS2DConduction from ibvpy.api import BCDofGroup fets_eval = FETS2D4Q4T(mats_eval=MATS2DConduction(k=1.)) print fets_eval.vtk_node_cell_data from ibvpy.mesh.fe_grid import FEGrid from ibvpy.mesh.fe_refinement_grid import FERefinementGrid from ibvpy.mesh.fe_domain import FEDomain from mathkit.mfn import MFnLineArray # Discretization fe_grid = FEGrid(coord_max=(1., 1., 0.), shape=(2, 2), fets_eval=fets_eval) tstepper = TS( sdomain=fe_grid, bcond_list=[ BCDofGroup(var='u', value=0., dims=[0], get_dof_method=fe_grid.get_left_dofs), # BCDofGroup( var='u', value = 0., dims = [1], # get_dof_method = fe_grid.get_bottom_dofs ), BCDofGroup(var='u', value=.005, dims=[0], get_dof_method=fe_grid.get_top_right_dofs) ], rtrace_list=[ # RTraceDomainListField(name = 'Damage' , # var = 'omega', idx = 0, # record_on = 'update', # warp = True), # RTraceDomainListField(name = 'Displacement' , # var = 'u', idx = 0, # record_on = 'update', # warp = True), # RTraceDomainListField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ]) print tstepper.setup() return # Add the time-loop control tloop = TLoop(tstepper=tstepper, debug=False, tline=TLine(min=0.0, step=1.0, max=1.0)) tloop.eval()
def demo3d(): # Geometry # length = 1.0 from ibvpy.fets.fets3D import FETS3D8H, FETS3D8H20U, FETS3D8H27U, FETS3D8H20U from ibvpy.mats.mats3D import MATS3DElastic # Material and FE Formulation # lin_x_temperature = TemperatureLinFn(length=length, n_dims=3, offset=0.5) fets_eval = FETS3D8H20U(mats_eval=MATS3DElastic( E=30e3, nu=0.2, initial_strain=lin_x_temperature)) fets_eval.vtk_r *= 0.99 # Discretization # domain = FEGrid(coord_max=(length, length, length), shape=(6, 3, 3), fets_eval=fets_eval) bcond_list = [ BCSlice(var='u', dims=[0, 1, 2], slice=domain[0, 0, 0, 0, 0, 0], value=0), BCSlice(var='u', dims=[0, 1], slice=domain[0, 0, -1, 0, 0, -1], value=0), BCSlice(var='u', dims=[0], slice=domain[0, -1, 0, 0, -1, 0], value=0), ] rtrace_list = [ sig_trace, eps_trace, eps0_trace, eps1t_trace, max_p_sig_trace, u_trace ] for rtrace in rtrace_list: rtrace.position = 'int_pnts' rtrace.warp = False corner_dof = domain[-1, -1, -1, -1, -1, -1].dofs[0, 0, 2] ts = TS(sdomain=domain, bcond_list=bcond_list, rtrace_list=rtrace_list) # Time integration # tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=3, max=1.0)) tloop.eval() # Postprocessing # app = IBVPyApp(ibv_resource=tloop) app.main()
def setUp(self): self.fets_eval = FETS1D2L(mats_eval=MATS1DElastic(E=10.)) # Discretization self.domain = FEGrid(coord_max=(10., 0., 0.), shape=(1, ), fets_eval=self.fets_eval) self.ts = TS(sdomain=self.domain, dof_resultants=True) self.tloop = TLoop(tstepper=self.ts, tline=TLine(min=0.0, step=1, max=1.0))
def example_2d(): from ibvpy.mats.mats2D.mats2D_elastic.mats2D_elastic import MATS2DElastic from ibvpy.fets.fets2D.fets2D4q import FETS2D4Q fets_eval = FETS2D4Q(mats_eval=MATS2DElastic(E=2.1e5)) # Discretization fe_domain1 = FEGrid(coord_max=(2., 5., 0.), shape=(10, 10), fets_eval=fets_eval) fe_subgrid1 = FERefinementLevel(parent=fe_domain1, fine_cell_shape=(1, 1)) print 'children' print fe_domain1.children fe_subgrid1.refine_elem((5, 5)) fe_subgrid1.refine_elem((6, 5)) fe_subgrid1.refine_elem((7, 5)) fe_subgrid1.refine_elem((8, 5)) fe_subgrid1.refine_elem((9, 5)) fe_domain = FEDomain(subdomains=[fe_domain1]) ts = TS(dof_resultants=True, sdomain=fe_domain, bcond_list=[BCDofGroup(var='f', value=0.1, dims=[0], get_dof_method=fe_domain1.get_top_dofs), BCDofGroup(var='u', value=0., dims=[0, 1], get_dof_method=fe_domain1.get_bottom_dofs), ], rtrace_list=[RTraceGraph(name='Fi,right over u_right (iteration)', var_y='F_int', idx_y=0, var_x='U_k', idx_x=1), RTraceDomainListField(name='Stress', var='sig_app', idx=0, warp=True), # RTraceDomainField(name = 'Displacement' , # var = 'u', idx = 0), # RTraceDomainField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ] ) # Add the time-loop control tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=1, max=1.0)) # print tloop.eval() from ibvpy.plugins.ibvpy_app import IBVPyApp ibvpy_app = IBVPyApp(ibv_resource=tloop) ibvpy_app.main()
def __demo__(): from ibvpy.api import \ TStepper as TS, RTDofGraph, RTraceDomainListField, TLoop, \ TLine, BCDof from ibvpy.tmodel.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic fets_eval = FETS1D2L(mats_eval=MATS1DElastic(E=10.)) from ibvpy.mesh.fe_grid import FEGrid # Discretization domain = FEGrid(coord_max=(3., ), shape=(3, ), fets_eval=fets_eval) ts = TS(dof_resultants=True, sdomain=domain, bcond_list=[ BCDof(var='u', dof=0, value=0.), BCDof( var='f', dof=3, value=1, ) ], rtrace_list=[ RTDofGraph(name='Fi,right over u_right (iteration)', var_y='F_int', idx_y=0, var_x='U_k', idx_x=1), RTraceDomainListField(name='Stress', var='sig_app', idx=0), RTraceDomainListField(name='Displacement', var='u', idx=0, warp=True), RTraceDomainListField(name='N0', var='N_mtx', idx=0, record_on='update') ]) # Add the time-loop control tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=0.5, max=1.0)) print('---- result ----') print(tloop.eval()) print(ts.F_int) print(ts.rtrace_list[0].trace.ydata) # Put the whole stuff into the simulation-framework to map the # individual pieces of definition into the user interface. # app = IBVPyApp(ibv_resource=tloop) app.main()
def _get_tloop(self): ts = TS(sdomain=self.fe_domain, dof_resultants=True, bcond_list=self.bc_list, rtrace_list=self.rtrace_list) # Add the time-loop control # tloop = TLoop(tstepper=ts, tolerance=1e-4, tline=self.tline) return tloop
def demo1d(): # Geometry # length = 1.0 # Material and FE Formulation # from ibvpy.fets.fets1D import FETS1D2L, FETS1D2L3U from ibvpy.mats.mats1D import MATS1DElastic mats_eval = MATS1DElastic(E=100., initial_strain=TemperatureLinFn(length=length, n_dims=1, offset=0.5)) fets_eval = FETS1D2L3U(mats_eval=mats_eval) fets_eval.vtk_r *= 0.99 # Discretization # domain = FEGrid(coord_max=(length, 0., 0.), n_elems=(10, ), fets_eval=fets_eval) bcond_list = [ BCSlice(var='u', dims=[0], slice=domain[0, 0], value=0), #BCSlice( var = 'u', dims = [0], slice = domain[-1, -1], value = 0 ) ] ts = TS(sdomain=domain, bcond_list=bcond_list, rtrace_list=[sig_trace, eps_trace, eps0_trace, eps1t_trace]) # Time integration # tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=1, max=1.0)) tloop.eval() # Postprocessing # legend = [] plot_sig(eps_trace, 'eps', legend) plot_sig(eps0_trace, 'eps0', legend) plot_sig(eps1t_trace, 'eps1t', legend) p.legend(legend) p.show()
def _get_tloop(self): roof = self.fe_disk_grid # self.bc_roof_deadweight + \ bc_list = self.bc_fixed ts = TS(sdomain=[roof], dof_resultants=True, bcond_list=bc_list, rtrace_list=self.rtrace_list) # Add the time-loop control # tloop = TLoop(tstepper=ts, tolerance=1e-4, tline=self.tline) return tloop
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 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_tloop(self): roof = self.fe_grid_roof # self.bc_roof_deadweight + \ bc_list = self.bc_roof_list + self.bc_outer_boundary + \ self.bc_fix_dofs_in_the_hollow ts = TS(sdomain = [ roof ], dof_resultants = True, bcond_list = bc_list, rtrace_list = self.rtrace_list ) # Add the time-loop control # tloop = TLoop(tstepper = ts, tolerance = 1e-4, tline = self.tline) return tloop
ts = TS( sdomain=domain, # conversion to list (square brackets) is only necessary for slicing of # single dofs, e.g "get_left_dofs()[0,1]" bcond_list=[ BCDofGroup(var='u', value=0., dims=[0], get_dof_method=domain.get_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=[ # 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') ])
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()
ts = TS( sdomain=domain, bcond_list=[ BCDofGroup(var='u', value=0., dims=[0], get_dof_method=domain.get_left_dofs), BCDofGroup(var='u', value=0., dims=[1, 2], get_dof_method=domain.get_bottom_left_dofs), BCDofGroup(var='u', value=0.002, dims=[0], get_dof_method=domain.get_right_dofs) ], rtrace_list=[ # RTraceGraph(name = 'Fi,right over u_right (iteration)' , # var_y = 'F_int', idx_y = right_dof, # var_x = 'U_k', idx_x = right_dof, # record_on = 'update'), # RTraceDomainListField(name = 'Deformation' , # var = 'eps', idx = 0, # record_on = 'update'), RTraceDomainListField(name='Displacement', var='u', idx=0, warp=True), # RTraceDomainListField(name = 'Stress' , # var = 'sig', idx = 0, # record_on = 'update'), # RTraceDomainListField(name = 'N0' , # var = 'N_mtx', idx = 0, # record_on = 'update') ])
def _get_tloop(self): #-------------------------------------------------------------- # ts #-------------------------------------------------------------- mid_zone_spec = self.mid_zone_specmn_fe_grid load_zone_spec = self.load_zone_specmn_fe_grid outer_zone_spec = self.outer_zone_specmn_fe_grid if self.elstmr_flag: # ELSTRMR TOP SURFACE # dofs at elastomer top surface (used to integrate the force) # elastomer = self.elstmr_fe_grid elstmr_top_dofs_z = elastomer[:, :, -1, :, :, -1].dofs[:, :, 2].flatten() load_dofs_z = np.unique(elstmr_top_dofs_z) print 'load_dofs_z', load_dofs_z else: # LINE LOAD TOP OF LOAD ZONE # dofs at center line of the specmn load zone (used to integrate the force) # note slice index in x-direction is only valid for load_zone_shape_x = 2 ! # load_zone_spec_topline_dofs_z = load_zone_spec[ 0, :, -1, -1, :, -1].dofs[:, :, 2].flatten() load_dofs_z = np.unique(load_zone_spec_topline_dofs_z) print 'load_dofs_z', load_dofs_z # SUPPRT LINE # dofs at support line of the specmn (used to integrate the force) # outer_zone_spec_supprtline_dofs_z = outer_zone_spec[ -1, :, 0, -1, :, 0].dofs[:, :, 2].flatten() supprt_dofs_z = np.unique(outer_zone_spec_supprtline_dofs_z) print 'supprt_dofs_z', supprt_dofs_z # CENTER DOF (used for tracing of the displacement) # center_bottom_dof = mid_zone_spec[0, 0, 0, 0, 0, 0].dofs[0, 0, 2] print 'center_bottom_dof', center_bottom_dof # THIRDPOINT DOF (used for tracing of the displacement) # dofs at center middle of the laod zone at the bottom side # # NOTE: slice index in x-direction is only valid for load_zone_shape_x = 2 ! thirdpoint_bottom_dof = load_zone_spec[0, 0, 0, -1, 0, 0].dofs[0, 0, 2] print 'thirdpoint_bottom_dof', thirdpoint_bottom_dof # force-displacement-diagram (CENTER) # self.f_w_diagram_center = RTraceGraph( name='displacement_elasttop (center) - force', var_x='U_k', idx_x=center_bottom_dof, var_y='F_int', idx_y_arr=load_dofs_z, record_on='update', transform_x='-x * 1000', # %g * x' % ( fabs( w_max ),), # due to symmetry the total force sums up from four parts of the beam (2 symmetry axis): # transform_y='-4000. * y') # force-displacement-diagram_supprt (SUPPRT) # self.f_w_diagram_supprt = RTraceGraph( name='displacement_supprtline (center) - force', var_x='U_k', idx_x=center_bottom_dof, var_y='F_int', idx_y_arr=supprt_dofs_z, record_on='update', transform_x='-x * 1000', # %g * x' % ( fabs( w_max ),), # due to symmetry the total force sums up from four parts of the beam (2 symmetry axis): # transform_y='4000. * y') # force-displacement-diagram (THIRDPOINT) # self.f_w_diagram_thirdpoint = RTraceGraph( name='displacement_elasttop (thirdpoint) - force', var_x='U_k', idx_x=thirdpoint_bottom_dof, var_y='F_int', idx_y_arr=load_dofs_z, record_on='update', transform_x='-x * 1000', # %g * x' % ( fabs( w_max ),), # due to symmetry the total force sums up from four parts of the beam (2 symmetry axis): # transform_y='-4000. * y') ts = TS( sdomain=self.fe_domain, bcond_list=self.bc_list, rtrace_list=[ self.f_w_diagram_center, self.f_w_diagram_thirdpoint, self.f_w_diagram_supprt, RTraceDomainListField(name='Displacement', var='u', idx=0, warp=True), # RTraceDomainListField(name = 'Stress' , # var = 'sig_app', idx = 0, warp = True, # record_on = 'update'), # RTraceDomainListField(name = 'Strain' , # var = 'eps_app', idx = 0, warp = True, # record_on = 'update'), # RTraceDomainListField(name = 'Damage' , # var = 'omega_mtx', idx = 0, warp = True, # record_on = 'update'), RTraceDomainListField(name='max_omega_i', warp=True, var='max_omega_i', idx=0, record_on='update'), # RTraceDomainListField(name = 'IStress' , # position = 'int_pnts', # var = 'sig_app', idx = 0, # record_on = 'update'), # RTraceDomainListField(name = 'IStrain' , # position = 'int_pnts', # var = 'eps_app', idx = 0, # record_on = 'update'), ]) # Add the time-loop control tloop = TLoop(tstepper=ts, KMAX=50, tolerance=self.tolerance, RESETMAX=0, tline=TLine(min=0.0, step=self.tstep, max=self.tmax), ord=self.ord) return tloop
def example_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.mats1D.mats1D_elastic.mats1D_elastic import MATS1DElastic from ibvpy.mesh.fe_grid import FEGrid from numpy import array, sqrt from scipy.linalg import norm if __name__ == '__main__': fets_eval = FETS1D2L(mats_eval=MATS1DElastic(E=10.)) # Discretization domain = FEGrid(coord_max=(10., 0., 0.), shape=(1,), fets_eval=fets_eval ) ts = TS(sdomain=domain, dof_resultants=True ) tloop = TLoop(tstepper=ts, tline=TLine(min=0.0, step=1, max=1.0)) '''Clamped bar loaded at the right end with unit displacement [00]-[01]-[02]-[03]-[04]-[05]-[06]-[07]-[08]-[09]-[10] 'u[0] = 0, u[10] = 1''' domain.coord_max = (10, 0, 0) domain.shape = (10,) ts.bcond_list = [BCDof(var='u', dof=0, value=0.), BCDof(var='u', dof=10, value=1.)] ts.rtrace_list = [RTDofGraph(name='Fi,right over u_right (iteration)', var_y='F_int', idx_y=10, var_x='U_k', idx_x=10)]
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_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 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 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()