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))
