def test_first_example(self):
import math
import numpy
from numpy import array
from spyfe.materials.mat_heatdiff import MatHeatDiff
from spyfe.fesets.surfacelike import FESetT3
from spyfe.femms.femm_heatdiff import FEMMHeatDiff
from spyfe.fields.nodal_field import NodalField
from spyfe.integ_rules import TriRule
from spyfe.fenode_set import FENodeSet
# These are the constants in the problem, k is kappa
a = 2.5 # radius on the columnthe
dy = a / 2 * math.sin(15. / 180 * math.pi)
dx = a / 2 * math.cos(15. / 180 * math.pi)
Q = 4.5 # internal heat generation rate
k = 1.8 # thermal conductivity
m = MatHeatDiff(thermal_conductivity=array([[k, 0.0], [0.0, k]]))
Dz = 1.0 # thickness of the slice
xall = array([[0, 0], [dx, -dy], [dx, dy], [2 * dx, -2 * dy],
[2 * dx, 2 * dy]])
fes = FESetT3(array([[1, 2, 3], [2, 4, 5], [2, 5, 3]]) - 1)
femm = FEMMHeatDiff(material=m,
fes=fes,
integration_rule=TriRule(npts=1))
fens = FENodeSet(xyz=xall)
geom = NodalField(fens=fens)
temp = NodalField(nfens=xall.shape[0], dim=1)
temp.set_ebc([3, 4])
temp.apply_ebc()
temp.numberdofs(node_perm=[1, 2, 0, 4, 3])
print(temp.dofnums)
K = femm.conductivity(geom, temp)
print(K)
def test_Poisson_t3(self):
from context import spyfe
from spyfe.meshing.generators.triangles import t3_ablock
from spyfe.meshing.modification import mesh_boundary
from spyfe.meshing.selection import connected_nodes
from numpy import array
from spyfe.materials.mat_heatdiff import MatHeatDiff
from spyfe.femms.femm_heatdiff import FEMMHeatDiff
from spyfe.fields.nodal_field import NodalField
from spyfe.integ_rules import TriRule
from spyfe.force_intensity import ForceIntensity
from scipy.sparse.linalg import spsolve
import time
from spyfe.meshing.exporters.vtkexporter import vtkexport
start0 = time.time()
# These are the constants in the problem, k is kappa
boundaryf = lambda x, y: 1.0 + x**2 + 2 * y**2
Q = -6 # internal heat generation rate
k = 1.0 # thermal conductivity
m = MatHeatDiff(thermal_conductivity=array([[k, 0.0], [0.0, k]]))
Dz = 1.0 # thickness of the slice
start = time.time()
N = 5
Length, Width, nL, nW = 1.0, 1.0, N, N
fens, fes = t3_ablock(Length, Width, nL, nW)
print('Mesh generation', time.time() - start)
bfes = mesh_boundary(fes)
cn = connected_nodes(bfes)
geom = NodalField(fens=fens)
temp = NodalField(nfens=fens.count(), dim=1)
for index in cn:
temp.set_ebc([index],
val=boundaryf(fens.xyz[index, 0], fens.xyz[index, 1]))
temp.apply_ebc()
temp.numberdofs()
femm = FEMMHeatDiff(material=m,
fes=fes,
integration_rule=TriRule(npts=1))
start = time.time()
fi = ForceIntensity(magn=lambda x, J: Q)
F = femm.distrib_loads(geom, temp, fi, 3)
print('Heat generation load', time.time() - start)
start = time.time()
F += femm.nz_ebc_loads_conductivity(geom, temp)
print('NZ EBC load', time.time() - start)
start = time.time()
K = femm.conductivity(geom, temp)
print('Matrix assembly', time.time() - start)
start = time.time()
temp.scatter_sysvec(spsolve(K, F))
print('Solution', time.time() - start)
print(temp.values)
print('Done', time.time() - start0)
from numpy.testing import assert_array_almost_equal
assert_array_almost_equal(temp.values[-4:-1],
array([[3.16], [3.36], [3.64]]))
b = a
h = 0.05
htol = h / 1000
na, nb, nh = 6,6,4
m = MatDeforTriaxLinearIso(rho=rho, e=E, nu=nu)
start = time.time()
fens, fes = h8_block(a, b, h, na, nb, nh)
fens, fes = h8_to_h20(fens, fes)
print('Mesh generation', time.time() - start)
geom = NodalField(fens=fens)
u = NodalField(nfens=fens.count(), dim=3)
cn = fenode_select(fens, box=numpy.array([0, 0, 0, b, 0, h]), inflate=htol)
for j in cn:
u.set_ebc([j], comp=0, val=0.0)
u.set_ebc([j], comp=1, val=0.0)
u.set_ebc([j], comp=2, val=0.0)
u.apply_ebc()
femmk = FEMMDeforLinear(material=m, fes=fes, integration_rule=GaussRule(dim=3, order=2))
femmk.associate_geometry(geom)
u.numberdofs()
print('Number of degrees of freedom', u.nfreedofs)
start = time.time()
K = femmk.stiffness(geom, u)
K = (K.T + K)/2.0
print('Stiffness assembly', time.time() - start)
start = time.time()
femmm = FEMMDeforLinear(material=m, fes=fes, integration_rule=GaussRule(dim=3, order=3))
M = femmm.lumped_mass(geom, u)
M = (M.T + M)/2.
xs = numpy.linspace(0.0, 1.0, N + 1)
ys = numpy.linspace(0.0, 1.0, N + 1)
zs = numpy.linspace(0.0, 1.0, N + 1)
fens, fes = h8_blockx(xs, ys, zs)
fens, fes = h8_to_h20(fens, fes)
fes.gradbfunpar(numpy.array([0, 0, 0]))
geom = NodalField(fens=fens)
vtkexport("Poisson_fe_H20_mesh", fes, geom)
print('Mesh generation', time.time() - start)
bfes = mesh_boundary(fes)
cn = connected_nodes(bfes)
temp = NodalField(nfens=fens.count(), dim=1)
for j in cn:
temp.set_ebc([j],
val=boundaryf(fens.xyz[j, 0], fens.xyz[j, 1], fens.xyz[j, 2]))
temp.apply_ebc()
femm = FEMMHeatDiff(material=m,
fes=fes,
integration_rule=GaussRule(dim=3, order=3))
S = femm.connection_matrix(geom)
perm = reverse_cuthill_mckee(S, symmetric_mode=True)
temp.numberdofs(node_perm=perm)
# temp.numberdofs()
start = time.time()
fi = ForceIntensity(magn=lambda x, J: Q)
F = femm.distrib_loads(geom, temp, fi, 3)
print('Heat generation load', time.time() - start)
start = time.time()
F += femm.nz_ebc_loads_conductivity(geom, temp)
print('NZ EBC load', time.time() - start)
k = 1.0 # thermal conductivity
m = MatHeatDiff(thermal_conductivity=array([[k, 0.0], [0.0, k]]))
Dz = 1.0 # thickness of the slice
start = time.time()
N = 4
xs = numpy.linspace(0.0, 1.0, N + 1)
ys = numpy.linspace(0.0, 1.0, N + 1)
fens, fes = q4_blockx(xs, ys)
fens, fes = q4_to_q8(fens, fes)
print('Mesh generation', time.time() - start)
bfes = mesh_boundary(fes)
cn = connected_nodes(bfes)
geom = NodalField(fens=fens)
temp = NodalField(nfens=fens.count(), dim=1)
for index in cn:
temp.set_ebc([index],
val=boundaryf(fens.xyz[index, 0], fens.xyz[index, 1]))
temp.apply_ebc()
femm = FEMMHeatDiff(material=m,
fes=fes,
integration_rule=GaussRule(dim=2, order=3))
# S = femm.connection_matrix(geom)
# perm = reverse_cuthill_mckee(S,symmetric_mode=True)
# temp.numberdofs(node_perm=perm)
temp.numberdofs()
start = time.time()
fi = ForceIntensity(magn=lambda x, J: Q)
F = femm.distrib_loads(geom, temp, fi, 3)
print('Heat generation load', time.time() - start)
start = time.time()
F += femm.nz_ebc_loads_conductivity(geom, temp)
print('NZ EBC load', time.time() - start)
def statics(model_data):
"""Algorithm for static linear deformation (stress) analysis.
:param model_data: Model data dictionary.
model_data['fens'] = finite element node set (mandatory)
For each region (connected piece of the domain made of a particular material), mandatory:
model_data['regions']= list of dictionaries, one for each region
Each region:
region['femm'] = finite element set that covers the region (mandatory)
For essential boundary conditions (optional):
model_data['boundary_conditions']['essential']=list of dictionaries, one for each
application of an essential boundary condition.
For each EBC dictionary ebc:
ebc['node_list'] = node list,
ebc['comp'] = displacement component (zero-based),
ebc['value'] = function to supply the prescribed value, default is lambda x: 0.0
:return: Success? True or false. The model_data object is modified.
model_data['geom'] =the nodal field that is the geometry
model_data['temp'] =the nodal field that is the computed temperature
model_data['timings'] = timing of the individual operations
"""
# To be done
# For essential boundary conditions (optional):
# cell array of struct,
# each piece of surface with essential boundary condition gets one
# element of the array with a struct with the attributes
# essential.temperature=fixed (prescribed) temperature (scalar), or
# handle to a function with signature
# function T =f(x)
# essential.fes = finite element set on the boundary to which
# the condition applies
# or alternatively
# essential.node_list = list of nodes on the boundary to which
# the condition applies
# Only one of essential.fes and essential.node_list needs a given.
#
# For convection boundary conditions (optional):
# model_data.boundary_conditions.convection = cell array of struct,
# each piece of surface with convection boundary condition gets one
# element of the array with a struct with the attributes
# convection.ambient_temperature=ambient temperature (scalar)
# convection.surface_transfer_coefficient = surface heat transfer coefficient
# convection.fes = finite element set on the boundary to which
# the condition applies
# convection.integration_rule= integration rule
#
# For flux boundary conditions (optional):
# model_data.boundary_conditions.flux = cell array of struct,
# each piece of surface with flux boundary condition gets one
# element of the array with a struct with the attributes
# flux.normal_flux= normal flux component, positive when outward-bound (scalar)
# flux.fes = finite element set on the boundary to which
# the condition applies
# flux.integration_rule= integration rule
#
# Control parameters:
# model_data.renumber = true or false flag (default is true)
# model_data.renumbering_method = optionally choose the renumbering
# method (symrcm or symamd)
# renumber = ~true; # Should we renumber?
# if (isfield(model_data,'renumber'))
# renumber =model_data.renumber;
# end
# Renumbering_options =struct( [] );
#
# # Should we renumber the nodes to minimize the cost of the solution of
# # the coupled linear algebraic equations?
# if (renumber)
# renumbering_method = 'symamd'; # default choice
# if ( isfield(model_data,'renumbering_method'))
# renumbering_method =model_data.renumbering_method;;
# end
# # Run the renumbering algorithm
# model_data =renumber_mesh(model_data, renumbering_method);;
# # Save the renumbering (permutation of the nodes)
# clear Renumbering_options; Renumbering_options.node_perm =model_data.node_perm;
# end
timings = []
task = 'Preliminaries'
start = time.time()
# Extract the nodes
fens = model_data['fens']
# Construct the geometry field
geom = NodalField(fens=fens)
# Construct the displacement field
u = NodalField(dim=geom.dim, nfens=geom.nfens)
# Apply the essential boundary conditions on the temperature field
if 'boundary_conditions' in model_data:
if 'essential' in model_data['boundary_conditions']:
ebcs = model_data['boundary_conditions']['essential']
for ebc in ebcs:
fenids = ebc['node_list']
value = ebc['value'] if 'value' in ebc \
else lambda xyz: 0.0
comp = ebc['comp']
for index in fenids:
u.set_ebc([index],
comp=comp,
val=value(fens.xyz[index, :]))
u.apply_ebc()
# Number the equations
u.numberdofs()
timings.append((task, time.time() - start))
# Initialize the loads vector
F = numpy.zeros((u.nfreedofs, ))
# # Flux boundary condition:
# if (isfield(model_data.boundary_conditions, 'flux' ))
# for j=1:length(model_data.boundary_conditions.flux)
# flux =model_data.boundary_conditions.flux{j};
# flux.femm = femm_heat_diffusion (struct (...
# 'fes',flux.fes,...
# 'integration_rule',flux.integration_rule));
# model_data.boundary_conditions.flux{j}=flux;
# end
# clear flux fi femm
# end
#
task = 'Stiffness matrix'
start = time.time()
# Make sure the model machines are given a chance to perform
# some geometry-related preparations
for region in model_data['regions']:
region['femm'].associate_geometry(geom)
# Construct the system stiffness matrix
K = csr_matrix((u.nfreedofs, u.nfreedofs)) # (all zeros, for the moment)
for region in model_data['regions']:
# Add up all the stiffness matrices for all the regions
K += region['femm'].stiffness(geom, u)
timings.append((task, time.time() - start))
# Apply the traction boundary conditions
if 'boundary_conditions' in model_data:
if 'traction' in model_data['boundary_conditions']:
tbcs = model_data['boundary_conditions']['traction']
for tbc in tbcs:
femm = tbc['femm']
fi = tbc['force_intensity']
F += femm.distrib_loads(geom, u, fi, 2)
# task = 'Body loads'
# start = time.time()
#
# for region in model_data['regions']:
# Q = None # default is no internal heat generation rate
# if 'heat_generation' in region: # Was it defined?
# Q = region['heat_generation']
# if Q is not None: # If it was supplied, and it is nonzero, compute its contribution.
# F = F + region['femm'].distrib_loads(geom, temp, Q, 3)
#
# timings.append((task, time.time() - start))
task = 'NZEBC loads'
start = time.time()
if 'boundary_conditions' in model_data:
if 'essential' in model_data['boundary_conditions']:
for region in model_data['regions']:
# Loads due to the essential boundary conditions on the temperature field
F += region['femm'].nz_ebc_loads(geom, u)
timings.append((task, time.time() - start))
# # Process the flux boundary condition
# if (isfield(model_data.boundary_conditions, 'flux' ))
# for j=1:length(model_data.boundary_conditions.flux)
# flux =model_data.boundary_conditions.flux{j};
# fi= force_intensity(struct('magn',flux.normal_flux));
# # Note the sign which reflects the formula (negative sign
# # in front of the integral)
# F = F - distrib_loads(flux.femm, sysvec_assembler, geom, temp, fi, 2);
# end
# clear flux fi
# end
task = 'System solution'
start = time.time()
# Solve for the displacement
u.scatter_sysvec(spsolve(K, F))
timings.append((task, time.time() - start))
# Update the model data
model_data['geom'] = geom
model_data['u'] = u
model_data['timings'] = timings
return True