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