def bar2(): print('---------------------------------------------------------------') print('Clamped bar composed of two linked bars loaded at the right end') print('[00]-[01]-[02]-[03]-[04]-[05]-[06]-[07]-[08]-[09]-[10]') print('[11]-[12]-[13]-[14]-[15]-[16]-[17]-[18]-[19]-[20]-[21]') print('u[0] = 0, u[5] = u[16], R[-1] = R[21] = 10') K = SysMtxAssembly() dof_map1, mtx_arr1 = get_bar_mtx_array(shape=10) K.add_mtx_array(dof_map_arr=dof_map1, mtx_arr=mtx_arr1) dof_map2, mtx_arr2 = get_bar_mtx_array(shape=10) # Note the dof map of the second br must be adjusted to start # the DOF enumeration with 3 n_dofs1 = K.n_dofs K.add_mtx_array(dof_map_arr=dof_map2 + n_dofs1, mtx_arr=mtx_arr2) # add constraints K.register_constraint(a=0, u_a=0.) # clamped end K.register_constraint(a=5, alpha=[1], ix_a=[16]) # add load R = zeros(K.n_dofs) R[-1] = 10 print('u =', K.solve(R)) print() print('---------------------------------------------------------------') print('Clamped bar composed of two linked bars control displ at right') print('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 # K.register_constraint(a=21, u_a=1) print('u =', K.solve(R)) print()
def bar2(): print '---------------------------------------------------------------' print 'Clamped bar composed of two linked bars loaded at the right end' print '[00]-[01]-[02]-[03]-[04]-[05]-[06]-[07]-[08]-[09]-[10]' print '[11]-[12]-[13]-[14]-[15]-[16]-[17]-[18]-[19]-[20]-[21]' print 'u[0] = 0, u[5] = u[16], R[-1] = R[21] = 10' K = SysMtxAssembly() dof_map1, mtx_arr1 = get_bar_mtx_array( shape = 10 ) K.add_mtx_array( dof_map_arr = dof_map1, mtx_arr = mtx_arr1 ) dof_map2, mtx_arr2 = get_bar_mtx_array( shape = 10 ) # Note the dof map of the second br must be adjusted to start # the DOF enumeration with 3 n_dofs1 = K.n_dofs K.add_mtx_array( dof_map_arr = dof_map2+n_dofs1, mtx_arr = mtx_arr2 ) # add constraints K.register_constraint( a = 0, u_a = 0. ) # clamped end K.register_constraint( a = 5, alpha = [1], ix_a = [16] ) # add load R = zeros( K.n_dofs ) R[-1] = 10 print 'u =', K.solve( R ) print print '---------------------------------------------------------------' print 'Clamped bar composed of two linked bars control displ at right' print '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 # K.register_constraint( a = 21, u_a = 1 ) print 'u =', K.solve( R ) print
def bar1(): print '---------------------------------------------------------------' print 'Clamped bar loaded at the right end with unit displacement' print '[00]-[01]-[02]-[03]-[04]-[05]-[06]-[07]-[08]-[09]-[10]' print 'u[0] = 0, u[10] = 1' K = SysMtxAssembly() dof_map, mtx_arr = get_bar_mtx_array(shape=10) K.add_mtx_array(dof_map_arr=dof_map, mtx_arr=mtx_arr) K.register_constraint(a=0, u_a=0.) # clamped end K.register_constraint(a=10, u_a=1.) K.register_constraint(a=10, u_a=1.) K_dense = DenseMtx(assemb=K) R = zeros(K.n_dofs) print 'K\n', K_dense print 'R\n', R print 'K_arrays' for i, sys_mtx_array in enumerate(K.sys_mtx_arrays): print 'i\n', sys_mtx_array.mtx_arr K.apply_constraints(R) K_dense = DenseMtx(assemb=K) print 'K\n', K_dense print 'R\n', R print 'K_arrays' for i, sys_mtx_array in enumerate(K.sys_mtx_arrays): print 'i\n', sys_mtx_array.mtx_arr print 'u =', K.solve(R) print
def bar7(): print('---------------------------------------------------------------') print('Two clamped beams link in parallel') print('and loaded by force at right end') print('[5]-[6]-[7]-[8]-[9]') print('[0]-[1]-[2]-[3]-[4]') print('u[5] = u[0], u[0] = 0, u[4] = 0.5 * u[9], R[4] = 1') K = SysMtxAssembly() dof_map1, mtx_arr1 = get_bar_mtx_array(shape=4) K.add_mtx_array(dof_map_arr=dof_map1, mtx_arr=mtx_arr1) dof_map2, mtx_arr2 = get_bar_mtx_array(shape=4) K.add_mtx_array(dof_map_arr=dof_map2 + 5, mtx_arr=mtx_arr2) # add load R = zeros(K.n_dofs) # load at the coupled end nodes is doubled R[9] = 1 R[4] = 1 # add constraints K.register_constraint(a=5, alpha=[1], ix_a=[0]) K.register_constraint(a=0, u_a=0.) # clamped end K.register_constraint(a=4, alpha=[0.5], ix_a=[9]) # add load R = zeros(K.n_dofs) # load at the coupled end nodes is doubled R[9] = 1 R[4] = 1 print('u =', K.solve(R)) print()
def bar7(): print '---------------------------------------------------------------' print 'Two clamped beams link in parallel' print 'and loaded by force at right end' print '[5]-[6]-[7]-[8]-[9]' print '[0]-[1]-[2]-[3]-[4]' print 'u[5] = u[0], u[0] = 0, u[4] = 0.5 * u[9], R[4] = 1' K = SysMtxAssembly() dof_map1, mtx_arr1 = get_bar_mtx_array( shape = 4 ) K.add_mtx_array( dof_map_arr = dof_map1, mtx_arr = mtx_arr1 ) dof_map2, mtx_arr2 = get_bar_mtx_array( shape = 4 ) K.add_mtx_array( dof_map_arr = dof_map2+5, mtx_arr = mtx_arr2 ) # add load R = zeros( K.n_dofs ) # load at the coupled end nodes is doubled R[9] = 1 R[4] = 1 # add constraints K.register_constraint( a = 5, alpha = [1], ix_a = [0] ) K.register_constraint( a = 0, u_a = 0. ) # clamped end K.register_constraint( a = 4, alpha = [0.5], ix_a = [9] ) # add load R = zeros( K.n_dofs ) # load at the coupled end nodes is doubled R[9] = 1 R[4] = 1 print 'u =', K.solve( R ) print
def bar1(): print('---------------------------------------------------------------') print('Clamped bar loaded at the right end with unit displacement') print('[00]-[01]-[02]-[03]-[04]-[05]-[06]-[07]-[08]-[09]-[10]') print('u[0] = 0, u[10] = 1') K = SysMtxAssembly() dof_map, mtx_arr = get_bar_mtx_array(shape=10) K.add_mtx_array(dof_map_arr=dof_map, mtx_arr=mtx_arr) K.register_constraint(a=0, u_a=0.) # clamped end K.register_constraint(a=10, u_a=1.) K.register_constraint(a=10, u_a=1.) K_dense = DenseMtx(assemb=K) R = zeros(K.n_dofs) print('K\n', K_dense) print('R\n', R) print('K_arrays') for i, sys_mtx_array in enumerate(K.sys_mtx_arrays): print('i\n', sys_mtx_array.mtx_arr) K.apply_constraints(R) K_dense = DenseMtx(assemb=K) print('K\n', K_dense) print('R\n', R) print('K_arrays') for i, sys_mtx_array in enumerate(K.sys_mtx_arrays): print('i\n', sys_mtx_array.mtx_arr) print('u =', K.solve(R)) print()
def bar9(): print '---------------------------------------------------------------' print 'Single clamped element with two constraints' print 'within a single element' print '[0]-[1]-[2]-[3]' print 'u[0] = u[1], u[1] = 1' K = SysMtxAssembly() dof_map1, mtx_arr1 = get_bar_mtx_array( shape = 3 ) K.add_mtx_array( dof_map_arr = dof_map1, mtx_arr = mtx_arr1 ) # add constraints K.register_constraint( a = 0 ) K.register_constraint( a = 3, u_a = 1. ) # clamped end # add load R = zeros( K.n_dofs ) print 'u =', K.solve( R ) print K.register_constraint( a = 1, alpha = [1], ix_a = [2] ) print 'u =', K.solve( R ) print
def bar9(): print('---------------------------------------------------------------') print('Single clamped element with two constraints') print('within a single element') print('[0]-[1]-[2]-[3]') print('u[0] = u[1], u[1] = 1') K = SysMtxAssembly() dof_map1, mtx_arr1 = get_bar_mtx_array(shape=3) K.add_mtx_array(dof_map_arr=dof_map1, mtx_arr=mtx_arr1) # add constraints K.register_constraint(a=0) K.register_constraint(a=3, u_a=1.) # clamped end # add load R = zeros(K.n_dofs) print('u =', K.solve(R)) print() K.register_constraint(a=1, alpha=[1], ix_a=[2]) print('u =', K.solve(R)) print()
def bar3(): print('---------------------------------------------------------------') print('Clamped bar with recursive constraints (load at right end)') print('[0]-[1]-[2]-[3]') print('u[1] = 0.5 * u[2], u[2] = 1 * u[3], R[3] = 11') K = SysMtxAssembly() dof_map, mtx_arr = get_bar_mtx_array(shape=3) K.add_mtx_array(dof_map_arr=dof_map, mtx_arr=mtx_arr) K.register_constraint(a=0, u_a=0.) # clamped end K.register_constraint(a=1, alpha=[0.5], ix_a=[2]) K.register_constraint(a=2, alpha=[1.0], ix_a=[3]) R = zeros(K.n_dofs) R[3] = 1 K.apply_constraints(R) print('u =', K.solve()) print() print('---------------------------------------------------------------') print('Clamped bar with recursive constraints (displ at right end)') print('u[1] = 0.5 * u[2], u[2] = 1.0 * u[3], u[3] = 1') K.register_constraint(a=3, u_a=1) print('u =', K.solve(R)) print()
def bar3(): print '---------------------------------------------------------------' print 'Clamped bar with recursive constraints (load at right end)' print '[0]-[1]-[2]-[3]' print 'u[1] = 0.5 * u[2], u[2] = 1 * u[3], R[3] = 11' K = SysMtxAssembly() dof_map, mtx_arr = get_bar_mtx_array( shape = 3 ) K.add_mtx_array( dof_map_arr = dof_map, mtx_arr = mtx_arr ) K.register_constraint( a = 0, u_a = 0. ) # clamped end K.register_constraint( a = 1, alpha = [0.5], ix_a = [2] ) K.register_constraint( a = 2, alpha = [1.0], ix_a = [3] ) R = zeros( K.n_dofs ) R[3] = 1 K.apply_constraints(R) print 'u =', K.solve( ) print print '---------------------------------------------------------------' print 'Clamped bar with recursive constraints (displ at right end)' print 'u[1] = 0.5 * u[2], u[2] = 1.0 * u[3], u[3] = 1' K.register_constraint( a = 3, u_a = 1 ) print 'u =', K.solve( R ) print
def bar1(): print '---------------------------------------------------------------' print 'Clamped bar loaded at the right end with unit displacement' print '[00]-[01]-[02]-[03]-[04]-[05]-[06]-[07]-[08]-[09]-[10]' print 'u[0] = 0, u[10] = 1' K = SysMtxAssembly() dof_map, mtx_arr = get_bar_mtx_array( shape = 10 ) K.add_mtx_array( dof_map_arr = dof_map, mtx_arr = mtx_arr ) K.register_constraint( a = 0, u_a = 0. ) # clamped end K.register_constraint( a = 10, u_a = 1. ) K.register_constraint( a = 10, u_a = 1. ) DenseMtx( assemb = K ).configure_traits() R = zeros( K.n_dofs ) print 'u =', K.solve( R ) print
def bar1(): print '---------------------------------------------------------------' print 'Clamped bar loaded at the right end with unit displacement' print '[00]-[01]-[02]-[03]-[04]-[05]-[06]-[07]-[08]-[09]-[10]' print 'u[0] = 0, u[10] = 1' K = SysMtxAssembly() dof_map, mtx_arr = get_bar_mtx_array(shape=10) K.add_mtx_array(dof_map_arr=dof_map, mtx_arr=mtx_arr) K.register_constraint(a=0, u_a=0.) # clamped end K.register_constraint(a=10, u_a=1.) K.register_constraint(a=10, u_a=1.) DenseMtx(assemb=K).configure_traits() R = zeros(K.n_dofs) print 'u =', K.solve(R) print
def bar8(): print '---------------------------------------------------------------' print 'Single clamped element with two constraints' print 'within a single element' print '[0]-[1]' print 'u[0] = u[1], u[1] = 1' K = SysMtxAssembly() dof_map1, mtx_arr1 = get_bar_mtx_array(shape=1) K.add_mtx_array(dof_map_arr=dof_map1, mtx_arr=mtx_arr1) # add constraints K.register_constraint(a=0, alpha=[1], ix_a=[1]) K.register_constraint(a=1, u_a=1.) # clamped end # add load R = zeros(K.n_dofs) print 'u =', K.solve(R) print
def bar6(): print('---------------------------------------------------------------') print('Clamped bar with 4 elements. Elements 2-4 are reinforced ') print('with another bar with 1 element linked proportianally') print('[0]-[1]-[2]-[3]-[4]') print(' [5]-[6]') print('u[0] = 0, u[1] = u[5], u[3] = u[7], u[4] = 1') K = SysMtxAssembly() dof_map1, mtx_arr1 = get_bar_mtx_array(shape=4) K.add_mtx_array(dof_map_arr=dof_map1, mtx_arr=mtx_arr1) dof_map2, mtx_arr2 = get_bar_mtx_array(shape=1) K.add_mtx_array(dof_map_arr=dof_map2 + 5, mtx_arr=mtx_arr2) # add constraints K.register_constraint(a=0, u_a=0.) # clamped end K.register_constraint(a=5, alpha=[0.5, 0.5], ix_a=[1, 2]) K.register_constraint(a=6, alpha=[0.5, 0.5], ix_a=[2, 3]) K.register_constraint(a=4, u_a=1.) # loaded end # add load R = zeros(K.n_dofs) print('u =', K.solve(R)) print()
def bar4(): print('---------------------------------------------------------------') print('Clamped bar 3 domains, each with 2 elems (displ at right end)') print('[0]-[1]-[2] [3]-[4]-[5] [6]-[7]-[8]') print('u[0] = 0, u[2] = u[3], u[5] = u[6], u[8] = 1') K = SysMtxAssembly() dof_map1, mtx_arr1 = get_bar_mtx_array(shape=2) K.add_mtx_array(dof_map_arr=dof_map1, mtx_arr=mtx_arr1) dof_map2, mtx_arr2 = get_bar_mtx_array(shape=2) K.add_mtx_array(dof_map_arr=dof_map2 + 3, mtx_arr=mtx_arr2) dof_map3, mtx_arr3 = get_bar_mtx_array(shape=2) K.add_mtx_array(dof_map_arr=dof_map3 + 6, mtx_arr=mtx_arr3) # add constraints K.register_constraint(a=0, u_a=0.) # clamped end K.register_constraint(a=2, alpha=[1], ix_a=[3]) K.register_constraint(a=5, alpha=[1], ix_a=[6]) K.register_constraint(a=8, u_a=1.) # loaded end # add load R = zeros(K.n_dofs) print('u =', K.solve(R)) print()
def bar4(): print '---------------------------------------------------------------' print 'Clamped bar 3 domains, each with 2 elems (displ at right end)' print '[0]-[1]-[2] [3]-[4]-[5] [6]-[7]-[8]' print 'u[0] = 0, u[2] = u[3], u[5] = u[6], u[8] = 1' K = SysMtxAssembly() dof_map1, mtx_arr1 = get_bar_mtx_array( shape = 2 ) K.add_mtx_array( dof_map_arr = dof_map1, mtx_arr = mtx_arr1 ) dof_map2, mtx_arr2 = get_bar_mtx_array( shape = 2 ) K.add_mtx_array( dof_map_arr = dof_map2+3, mtx_arr = mtx_arr2 ) dof_map3, mtx_arr3 = get_bar_mtx_array( shape = 2 ) K.add_mtx_array( dof_map_arr = dof_map3+6, mtx_arr = mtx_arr3 ) # add constraints K.register_constraint( a = 0, u_a = 0. ) # clamped end K.register_constraint( a = 2, alpha = [1], ix_a = [3] ) K.register_constraint( a = 5, alpha = [1], ix_a = [6] ) K.register_constraint( a = 8, u_a = 1. ) # loaded end # add load R = zeros( K.n_dofs ) print 'u =', K.solve( R ) print
def bar6(): print '---------------------------------------------------------------' print 'Clamped bar with 4 elements. Elements 2-4 are reinforced ' print 'with another bar with 1 element linked proportianally' print '[0]-[1]-[2]-[3]-[4]' print ' [5]-[6]' print 'u[0] = 0, u[1] = u[5], u[3] = u[7], u[4] = 1' K = SysMtxAssembly() dof_map1, mtx_arr1 = get_bar_mtx_array( shape = 4 ) K.add_mtx_array( dof_map_arr = dof_map1, mtx_arr = mtx_arr1 ) dof_map2, mtx_arr2 = get_bar_mtx_array( shape = 1 ) K.add_mtx_array( dof_map_arr = dof_map2+5, mtx_arr = mtx_arr2 ) # add constraints K.register_constraint( a = 0, u_a = 0. ) # clamped end K.register_constraint( a = 5, alpha = [0.5,0.5], ix_a = [1,2] ) K.register_constraint( a = 6, alpha = [0.5,0.5], ix_a = [2,3] ) K.register_constraint( a = 4, u_a = 1. ) # loaded end # add load R = zeros( K.n_dofs ) print 'u =', K.solve( R ) print
def bar5(): print('---------------------------------------------------------------') print('Clamped bar with 4 elements. Elements 2-4 are reinforced ') print('with another bar with 3 elements') print('[0]-[1]-[2]-[3]-[4]') print(' [5]-[6]-[7]') print('u[0] = 0, u[1] = u[5], u[3] = u[7], u[4] = 1') # assemble the matrix K = SysMtxAssembly() dof_map1, mtx_arr1 = get_bar_mtx_array(shape=4) K.add_mtx_array(dof_map_arr=dof_map1, mtx_arr=mtx_arr1) dof_map2, mtx_arr2 = get_bar_mtx_array(shape=2) K.add_mtx_array(dof_map_arr=dof_map2 + 5, mtx_arr=mtx_arr2) # add constraints K.register_constraint(a=0, u_a=0.) # clamped end K.register_constraint(a=1, alpha=[1], ix_a=[5]) K.register_constraint(a=3, alpha=[1], ix_a=[7]) K.register_constraint(a=4, u_a=1.) # loaded end # add load R = zeros(K.n_dofs) print('u =', K.solve(R)) print()
def bar5(): print '---------------------------------------------------------------' print 'Clamped bar with 4 elements. Elements 2-4 are reinforced ' print 'with another bar with 3 elements' print '[0]-[1]-[2]-[3]-[4]' print ' [5]-[6]-[7]' print 'u[0] = 0, u[1] = u[5], u[3] = u[7], u[4] = 1' # assemble the matrix K = SysMtxAssembly() dof_map1, mtx_arr1 = get_bar_mtx_array( shape = 4 ) K.add_mtx_array( dof_map_arr = dof_map1, mtx_arr = mtx_arr1 ) dof_map2, mtx_arr2 = get_bar_mtx_array( shape = 2 ) K.add_mtx_array( dof_map_arr = dof_map2+5, mtx_arr = mtx_arr2 ) # add constraints K.register_constraint( a = 0, u_a = 0. ) # clamped end K.register_constraint( a = 1, alpha = [1], ix_a = [5] ) K.register_constraint( a = 3, alpha = [1], ix_a = [7] ) K.register_constraint( a = 4, u_a = 1. ) # loaded end # add load R = zeros( K.n_dofs ) print 'u =', K.solve( R ) print
Created on 05.02.2017 @author: Yingxiong ''' from numpy import array, zeros, arange, array_equal, hstack, dot from mathkit.matrix_la.sys_mtx_assembly import SysMtxAssembly shape = 5 el_mtx = array([[10, -10], [-10, 10]], dtype='float_') mtx_arr = array([el_mtx for i in range(shape)], dtype=float) dof_map = array([arange(shape), arange(shape) + 1], dtype=int).transpose() K = SysMtxAssembly() K.add_mtx_array(dof_map_arr=dof_map, mtx_arr=mtx_arr) K.register_constraint(a=0, u_a=0.) # clamped end K.register_constraint(a=4, u_a=2.) K.register_constraint(a=2, u_a=1.) R = zeros(K.n_dofs) R[-1] = 10. print 'u =', K.solve(R) print R print K.sys_mtx_arrays[0].mtx_arr
# shape function for the unknowns are identical with the geomeetric # approximation dNr = dNr_geo # [ n_e, n_ip, n_dof_r, n_dim_dof ] dNx = np.einsum('eidf,inf->eind', J_inv, dNr) B = np.zeros((n_e, n_ip, n_dof_r, n_s, n_dim_dof), dtype='f') B_n_rows, B_n_cols, dNx_d = [0, 1, 2, 2], [0, 1, 0, 1], [0, 1, 1, 0] B[:, :, :, B_n_rows, B_n_cols] = dNx[:, :, :, dNx_d] #========================================================================= # System matrix #========================================================================= K = np.einsum('i,einsd,st,eimtf,ei->endmf', w_ip, B, D_el, B, J_det) K_mtx = SysMtxAssembly() K_mtx.add_mtx_array(K.reshape(-1, n_el_dofs, n_el_dofs), elem_dof_map) #========================================================================= # Load vector #========================================================================= R = np.zeros((n_dofs,), dtype='float_') R[[8, 10]] = 1.0 K_mtx.register_constraint(a=0) K_mtx.register_constraint(a=1) K_mtx.register_constraint(a=2) u = K_mtx.solve(R) print 'u', u
#========================================================================= # System matrix #========================================================================= K = np.einsum('i,einsd,st,eimtf,ei->endmf', w_ip, B, D_el, B, J_det) K_mtx = SysMtxAssembly() K_mtx.add_mtx_array(K.reshape(-1, n_el_dofs, n_el_dofs), elem_dof_map) #========================================================================= # BC and solver #========================================================================= R = np.zeros((n_dofs, ), dtype='float_') R[2 * n_e_x + 1] = 1.0 K_mtx.register_constraint(a=0) # K_mtx.register_constraint(a=2 * n_e_x + 1, u_a=1.0) u = K_mtx.solve(R) # print 'u', u #========================================================================= # internal force #========================================================================= def get_corr_pred(u, fixed): # strain and slip u_e = u[elem_dof_map] #[n_e, n_dof_r, n_dim_dof] u_n = u_e.reshape(n_e, n_dof_r, n_dim_dof) #[n_e, n_ip, n_s] eps = np.einsum('einsd,end->eis', B, u_n)
class TLoop(HasStrictTraits): ts = Instance(MATS3DExplore) tline = Instance(TLine, ()) d_t = Float(0.005) t_max = Float(1.0) k_max = Int(50) tolerance = Float(1e-4) step_tolerance = Float(1e-8) t_record = List U_n = Array(dtype=np.float_) K = Array(dtype=np.float_) state = Array(dtype=np.float_) F_record = List U_record = List state_record = List K = Instance(SysMtxAssembly) paused = Bool(False) restart = Bool(True) def setup(self): n_comps = 6 n_dofs = n_comps self.U_n = np.zeros((n_dofs, )) t_n = self.tline.val self.t_record = [t_n] self.U_record = [np.zeros_like(self.U_n)] self.F_record = [np.copy(self.U_n)] self.state_record = [np.copy(self.state)] # Set up the system matrix # self.K = SysMtxAssembly() self.ts.bcond_mngr.apply_essential(self.K) state_changed = Event state_arrays = Property(Dict(Str, Array), depends_on='state_changed') '''Dictionary of state arrays. The entry names and shapes are defined by the material model. ''' @cached_property def _get_state_arrays(self): sa_shapes = self.ts.state_array_shapes print('state array generated', sa_shapes) return { name: np.zeros(mats_sa_shape, dtype=np.float_)[np.newaxis, ...] for name, mats_sa_shape in list(sa_shapes.items()) } def init(self): if self.paused: self.paused = False if self.restart: self.tline.val = 0 self.state_changed = True self.setup() self.restart = False def eval(self): # Reset the system matrix (constraints are preserved) # self.d_t = self.tline.step F_ext = np.zeros_like(self.U_n) t_n = self.tline.val t_n1 = t_n U_n = self.U_n while (t_n1 - self.tline.max) <= self.step_tolerance and \ not (self.restart or self.paused): k = 0 print('load factor', t_n1, end=' ') step_flag = 'predictor' U_k = np.copy(U_n) d_U_k = np.zeros_like(U_k) while k <= self.k_max and \ not (self.restart or self.paused): self.K.reset_mtx() K_mtx, F_int = self.ts.get_corr_pred(U_k, d_U_k, t_n, t_n1, step_flag, **self.state_arrays) self.K.add_mtx(K_mtx) # Prepare F_ext by zeroing it # F_ext[:] = 0.0 # Assemble boundary conditions in K and self.F_ext # self.ts.bcond_mngr.apply(step_flag, None, self.K, F_ext, t_n, t_n1) # Return the system matrix assembly K and the residuum # R = F_ext - F_int self.K.apply_constraints(R) d_U_k, pos_def = self.K.solve() U_k += d_U_k if np.linalg.norm(R) < self.tolerance: U_n[:] = U_k[:] self.t_record.append(t_n1) self.U_record.append(U_k) self.F_record.append(F_int) self.state_record.append(np.copy(self.state)) break k += 1 step_flag = 'corrector' if k >= self.k_max: print(' ----------> no convergence') break else: print('(', k, ')') if self.restart or self.paused: print('interrupted iteration') break t_n = t_n1 t_n1 = t_n + self.d_t self.tline.val = min(t_n, self.tline.max) return U_k def get_time_idx_arr(self, vot): '''Get the index corresponding to visual time ''' x = self.t_record idx = np.array(np.arange(len(x)), dtype=np.float_) t_idx = np.interp(vot, x, idx) return np.array(t_idx + 0.5, np.int_) def get_time_idx(self, vot): return int(self.get_time_idx_arr(vot))