def assemble_penality_dirichlet(data):
test_shape_function = common_tools.shape_func_to_whole_vector(
data['testShapeFunction'], data['assemblyIndes'], all_nodes_size)
trial_shape_function = common_tools.shape_func_to_whole_vector(
data['trialShapeFunction'], data['assemblyIndes'], all_nodes_size)
value_dimension = data['valueDimension']
load_validity = data['loadValidity']
load = data['load']
weight = data['weight']
penalty = data['penalty']
left = np.zeros(
(value_dimension, test_shape_function.shape[1] * value_dimension),
dtype=np.double)
right = np.zeros(
(value_dimension, trial_shape_function.shape[1] * value_dimension),
dtype=np.double)
for n, v in zip((left, right),
(test_shape_function, trial_shape_function)):
for i in range(value_dimension):
n[i, i::value_dimension] = v[0] if load_validity[i] else 0
mat = left.transpose().dot(right) * weight * penalty
vec = left.transpose().dot(load) * weight * penalty
return (mat, vec.reshape((vec.shape[0], 1)))
def assemble_lagrangle_dirichlet(data):
test_shape_function = common_tools.shape_func_to_whole_vector(
data['testShapeFunction'], data['assemblyIndes'],
all_nodes_size + all_lagrangle_nodes_size)
trial_shape_function = common_tools.shape_func_to_whole_vector(
data['trialShapeFunction'], data['assemblyIndes'],
all_nodes_size + all_lagrangle_nodes_size)
lagrangle_shape_function = common_tools.shape_func_to_whole_vector(
data['lagrangleShapeFunction'], data['lagrangleAssemblyIndes'],
all_nodes_size + all_lagrangle_nodes_size)
value_dimension = data['valueDimension']
load_validity = data['loadValidity']
left = np.zeros(
(value_dimension, lagrangle_shape_function.shape[1] * value_dimension),
np.double)
right = np.zeros(
(value_dimension, lagrangle_shape_function.shape[1] * value_dimension),
np.double)
lag = np.zeros(
(value_dimension, lagrangle_shape_function.shape[1] * value_dimension),
np.double)
for n, v in zip(
(left, right, lag),
(test_shape_function, trial_shape_function, lagrangle_shape_function)):
for i in range(value_dimension):
n[i, i::value_dimension] = v[0] if load_validity[i] else 0
mat = lag.transpose().dot(right) + left.transpose().dot(lag)
mat *= data['weight']
vec = lag.transpose().dot(data['load']) * data['weight']
applyDiagConvention(data, mat)
return (mat, vec.reshape((vec.shape[0], 1)))
def assemble_mechanical_volume(data):
test_shape_function = common_tools.shape_func_to_whole_vector(data['testShapeFunction'], data['assemblyIndes'], all_nodes_size)
trial_shape_function = common_tools.shape_func_to_whole_vector(data['trialShapeFunction'], data['assemblyIndes'], all_nodes_size)
value_dimension = data['valueDimension']
load = data['load']
weight = data['weight']
c_law = data['constitutiveLaw']
mat = assemble_volume_mat(value_dimension,weight, test_shape_function, c_law, trial_shape_function)
import neumann_assembler
vec = neumann_assembler.assemble_general_force(weight, load, test_shape_function)
return (mat, vec.reshape((vec.shape[0],1)))
def assemble_mechanical_volume(data):
test_shape_function = common_tools.shape_func_to_whole_vector(
data['testShapeFunction'], data['assemblyIndes'], all_nodes_size)
trial_shape_function = common_tools.shape_func_to_whole_vector(
data['trialShapeFunction'], data['assemblyIndes'], all_nodes_size)
value_dimension = data['valueDimension']
load = data['load']
weight = data['weight']
c_law = data['constitutiveLaw']
mat = assemble_volume_mat(value_dimension, weight, test_shape_function,
c_law, trial_shape_function)
import neumann_assembler
vec = neumann_assembler.assemble_general_force(weight, load,
test_shape_function)
return (mat, vec.reshape((vec.shape[0], 1)))
def assemble_poisson_volume(data):
spatical_dimension = data['spatialDimension']
test_shape_function = common_tools.shape_func_to_whole_vector(data['testShapeFunction'], data['assemblyIndes'], all_nodes_size)
trial_shape_function = common_tools.shape_func_to_whole_vector(data['trialShapeFunction'], data['assemblyIndes'], all_nodes_size)
main_matrix_size = data['allNodesSize'];
mat = np.zeros((main_matrix_size, main_matrix_size), dtype=np.double)
vec = np.zeros((main_matrix_size,), dtype=np.double)
weight = data['weight']
for dim in range(spatical_dimension):
test_vec = test_shape_function[dim + 1]
trial_vec = trial_shape_function[dim + 1]
mat += test_vec.reshape((-1, 1)).dot(trial_vec.reshape((1, -1))) * weight
vec += data['load'][0] * weight * test_shape_function[0]
return (mat, vec.reshape((vec.shape[0],1)))
def assemble_lagrangle_dirichlet(data):
test_shape_function = common_tools.shape_func_to_whole_vector(data['testShapeFunction'], data['assemblyIndes'], all_nodes_size + all_lagrangle_nodes_size)
trial_shape_function = common_tools.shape_func_to_whole_vector(data['trialShapeFunction'], data['assemblyIndes'], all_nodes_size + all_lagrangle_nodes_size)
lagrangle_shape_function = common_tools.shape_func_to_whole_vector(data['lagrangleShapeFunction'], data['lagrangleAssemblyIndes'], all_nodes_size + all_lagrangle_nodes_size)
value_dimension = data['valueDimension']
load_validity = data['loadValidity']
left = np.zeros((value_dimension, lagrangle_shape_function.shape[1] * value_dimension), np.double)
right = np.zeros((value_dimension, lagrangle_shape_function.shape[1] * value_dimension), np.double)
lag = np.zeros((value_dimension, lagrangle_shape_function.shape[1] * value_dimension), np.double)
for n, v in zip((left, right, lag), (test_shape_function, trial_shape_function, lagrangle_shape_function)):
for i in range(value_dimension):
n[i, i::value_dimension] = v[0] if load_validity[i] else 0
mat = lag.transpose().dot(right) + left.transpose().dot(lag)
mat *= data['weight']
vec = lag.transpose().dot(data['load']) * data['weight']
applyDiagConvention(data, mat)
return (mat, vec.reshape((vec.shape[0], 1)))
def assemble_penality_dirichlet(data):
test_shape_function = common_tools.shape_func_to_whole_vector(data['testShapeFunction'], data['assemblyIndes'], all_nodes_size)
trial_shape_function = common_tools.shape_func_to_whole_vector(data['trialShapeFunction'], data['assemblyIndes'], all_nodes_size)
value_dimension = data['valueDimension']
load_validity = data['loadValidity']
load=data['load']
weight=data['weight']
penalty=data['penalty']
left = np.zeros((value_dimension, test_shape_function.shape[1] * value_dimension), dtype=np.double)
right = np.zeros((value_dimension, trial_shape_function.shape[1] * value_dimension), dtype=np.double)
for n, v in zip((left, right), (test_shape_function, trial_shape_function)):
for i in range(value_dimension):
n[i, i::value_dimension] = v[0] if load_validity[i] else 0
mat = left.transpose().dot(right) * weight * penalty
vec = left.transpose().dot(load) * weight * penalty
return (mat, vec.reshape((vec.shape[0],1)))
def gen_test_data(value_dimension):
data = {}
data['allNodesSize'] = all_nodes_size
data['valueDimension'] = value_dimension
data['weight'] = rand.random()
data['load'] = common_tools.gen_vector(value_dimension, rand)
shape_func_nodes_num = rand.randint(1, all_nodes_size // 2)
test_shape_function = common_tools.gen_matrix((1, shape_func_nodes_num), rand)
nodes_assemble_indes = common_tools.gen_nodes_indes(shape_func_nodes_num, 0, all_nodes_size, rand)
data['testShapeFunction'] = test_shape_function
data['assemblyIndes'] = nodes_assemble_indes
whole_test_shape_function_vector = common_tools.shape_func_to_whole_vector(test_shape_function, nodes_assemble_indes, all_nodes_size)
data['mainVectorDifference'] = assemble_general_force(data['weight'], data['load'], whole_test_shape_function_vector)
return data
def gen_test_data(value_dimension):
data = {}
data['allNodesSize'] = all_nodes_size
data['valueDimension'] = value_dimension
data['weight'] = rand.random()
data['load'] = common_tools.gen_vector(value_dimension, rand)
shape_func_nodes_num = rand.randint(1, all_nodes_size // 2)
test_shape_function = common_tools.gen_matrix((1, shape_func_nodes_num),
rand)
nodes_assemble_indes = common_tools.gen_nodes_indes(
shape_func_nodes_num, 0, all_nodes_size, rand)
data['testShapeFunction'] = test_shape_function
data['assemblyIndes'] = nodes_assemble_indes
whole_test_shape_function_vector = common_tools.shape_func_to_whole_vector(
test_shape_function, nodes_assemble_indes, all_nodes_size)
data['mainVectorDifference'] = assemble_general_force(
data['weight'], data['load'], whole_test_shape_function_vector)
return data
def to_whole_shape_function(shape_function, nodes_assemble_indes):
return common_tools.shape_func_to_whole_vector(
shape_function, nodes_assemble_indes,
all_nodes_size + all_lagrangle_nodes_size)
def to_whole_shape_function(shape_function, nodes_assemble_indes):
return common_tools.shape_func_to_whole_vector(shape_function, nodes_assemble_indes, all_nodes_size + all_lagrangle_nodes_size)