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 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)
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 get_corr_pred(self, U, d_U, t, F_ext, fixed, F_inter, eps):
# parameters
mats_eval = self.mats_eval
fets_eval = self.fets_eval
domain = self.domain
elem_dof_map = domain.elem_dof_map
n_e = domain.n_active_elems
n_dof_r, n_dim_dof = self.fets_eval.dof_r.shape
n_dim_dof = 2
n_dofs = domain.n_dofs
J_det = np.linalg.det(self.J_mtx)
w_ip = fets_eval.ip_weights
n_el_dofs = n_dof_r * n_dim_dof
n_ip = self.fets_eval.n_gp
# evaluate internal force increment
D = mats_eval.get_D(eps, t, n_e, n_ip)
# element displacement increment
d_u_e = d_U[elem_dof_map]
#[n_e, n_dof_r, n_dim_dof]
d_u_n = d_u_e.reshape(n_e, n_dof_r, n_dim_dof)
#[n_e, n_ip, n_s]
d_eps = np.einsum('einsd,end->eis', self.B, d_u_n)
# stress increment
#[n_e, n_ip, n_s]
d_sig = np.einsum('eist,eit->eis', D, d_eps)
# internal force increment
# [n_e, n_n, n_dim_dof]
d_f_inter_e = np.einsum('eis,einsd,ei->end', d_sig, self.B, J_det)
d_f_inter_e = d_f_inter_e.reshape(n_e, n_dof_r * n_dim_dof)
d_F_inter = np.zeros(n_dofs)
np.add.at(d_F_inter, elem_dof_map, d_f_inter_e)
# fixed dof
d_F_inter[fixed] = 0.
# update internal force
F_inter += d_F_inter
# update strain and D matrix
eps += d_eps
D = mats_eval.get_D(eps, t, n_e, n_ip)
# update stiffness matrix
K = np.einsum('i,einsd,eist,eimtf,ei->endmf', w_ip, self.B, D, self.B,
J_det)
K_mtx = SysMtxAssembly()
K_mtx.add_mtx_array(K.reshape(-1, n_el_dofs, n_el_dofs), elem_dof_map)
K_mtx.register_constraint(a=fixed)
return F_ext - F_inter, K_mtx, F_inter, eps
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 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 setup(self):
# Put the spatial domain into the spatial context
#
self.sctx = sctx = self.sdomain.new_scontext()
self.sctx.sdomain = self.sdomain
# Let the boundary conditions setup themselves within the
# spatial context
#
# TODO - the setup needs the link to the algorithm and to the
# time-steppers as well.!
#
self.bcond_mngr.setup(sctx)
# Let the response variables setup themselves within the
# spatial context
#
self.rtrace_mngr.setup(self.sdomain)
# Set up the system matrix
#
self.K = SysMtxAssembly()
# Register the essential boundary conditions in the system matrix
#
self.bcond_mngr.apply_essential(self.K)
self.tse_integ.apply_constraints(self.K)
# Prepare the global update flag
sctx.update_state_on = False
if self.u_processor:
if self.u_processor.sd == None:
self.u_processor.sd = self.sdomain
# add-on parameters to be passed to every inner loop
# they are provided by u_processors
#
self.kw = {}
self.args = []
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 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 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 _get_stiffness(self, editor, object):
tstepper = editor.object.tstepper
if isinstance(object, TStepper):
U_k = tstepper.U_k
d_U = tstepper.d_U
K, R = tstepper.eval('predictor', U_k, d_U, 0, 0)
print 'constraints'
K.print_constraints()
K.apply_constraints(R)
else:
dots = object.dots
U_k = tstepper.U_k
d_U = tstepper.d_U
sctx = tstepper.sctx
F_int, K_mtx = dots.get_corr_pred(sctx, U_k, d_U, 0, 0)
# put the matrix into the system assembly
#
K = SysMtxAssembly()
if isinstance(K_mtx, ndarray):
K.add_mtx(K_mtx)
elif isinstance(K_mtx, SysMtxArray):
K.sys_mtx_arrays.append(K_mtx)
elif isinstance(K_mtx, list):
K.sys_mtx_arrays = K_mtx
elif isinstance(K_mtx, SysMtxAssembly):
K.sys_mtx_arrays = K_mtx.sys_mtx_arrays
n_dofs = tstepper.sdomain.n_dofs
K.add_mtx(
zeros((1, 1), dtype='float_'), array([n_dofs - 1], dtype='int_'))
return K
def apply_essential_bc(self):
'''Insert initial boundary conditions at the start up of the calculation..
'''
self.K = SysMtxAssembly()
for bc in self.bc_list:
bc.apply_essential(self.K)
def _get_K(self):
K = SysMtxAssembly()
self.bcond_mngr.setup(None)
self.bcond_mngr.register(K)
return K
# [ 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_n_rows, B_N_n_cols, N_idx = [1, 1], [0, 1], [0, 0]
B_dN_n_rows, B_dN_n_cols, dN_idx = [0, 2], [0, 1], [0, 0]
B_factors = np.array([-1, 1], dtype='float_')
B[:, :, :, B_N_n_rows,
B_N_n_cols] = (B_factors[None, None, :] * Nx[:, :, N_idx])
B[:, :, :, B_dN_n_rows, B_dN_n_cols] = dNx[:, :, :, dN_idx]
#=========================================================================
# 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_K(self):
return SysMtxAssembly()
