def executeMesh(self):
""" Utför FE-beräkningen."""
# --- Överför modellvariabler till lokala referenser
geometry = self.inputData.geometry()
elSize = self.inputData.elSize
# --- Skapa mesh
dofsPerNode = 1
elType = 2 # <-- Trenodselement
meshGen = cfm.GmshMeshGenerator(geometry)
meshGen.elSizeFactor = elSize
meshGen.elType = elType
meshGen.dofsPerNode = dofsPerNode
coords, edof, dofs, bdofs, elementmarkers = meshGen.create()
# --- Bestäm ex, ey
ex, ey = cfc.coordxtr(edof, coords, dofs)
#Returnera framtagen data
self.outputData.coords = coords
self.outputData.edof = edof
self.outputData.dofs = dofs
self.outputData.bdofs = bdofs
self.outputData.elType = elType
self.outputData.dofsPerNode = dofsPerNode
self.outputData.elementmarkers = elementmarkers
self.outputData.ex = ex
self.outputData.ey = ey
def create(self):
meshGen = cfm.GmshMeshGenerator(self.shape.geometry())
meshGen.elType = self.shape.elementType
meshGen.elSizeFactor = self.shape.maxArea
meshGen.dofsPerNode = self.shape.dofsPerNode
self.coords, self.edof, self.dofs, self.bdofs, self.markers = meshGen.create()
# --- Beräkna element koordinater
self.ex, self.ey = cfc.coordxtr(self.edof, self.coords, self.dofs)
self.pointDofs = self.dofs[list(self.shape.g.points.keys()),:]
def updateMesh(self):
"""Update mesh"""
cfu.info("Meshing geometry...")
# 3 Quads
self.elType = 3
self.dofsPerNode = 2
# Create mesh
self.mesh = cfm.GmshMeshGenerator(geometry=self.g)
self.mesh.elType = self.elType
self.mesh.dofsPerNode = self.dofsPerNode
self.coords, self.edof, self.dofs, self.bdofs, self.elementmarkers = self.mesh.create(
)
def solveProblem(self):
g = cfg.Geometry() #Create a GeoData object that holds the geometry.
g.point([0, 0])
g.point([2, 0])
g.point([2, 1])
g.point([0, 1])
g.point([0.5, 0.3])
g.point([0.3, 0.7])
g.point([0.7, 0.7])
g.point([0.8, 0.5])
g.point([1.7, 0.5])
g.point([1.5, 0.5])
g.point([1.7, 0.7])
g.ellipse([7, 8, 9, 10],
marker=50) # 0 - An ellipse arc. Read the function
g.spline([0, 1], marker=80) # 1 - A spline. Splines pass through the
g.spline([2, 1]) # 2
g.spline([3, 2]) # 3
g.spline([0, 3]) # 4
g.spline([7, 9], marker=50) # 5
g.spline([10, 9]) # 6
g.spline([4, 5, 6, 4]) # 7 - This is a closed spline.
g.surface([4, 3, 2, 1], [[7], [5, 6, 0]])
meshGen = cfm.GmshMeshGenerator(g)
meshGen.elType = 3 # Degrees of freedom per node.
meshGen.dofsPerNode = 1 # Factor that changes element sizes.
meshGen.elSizeFactor = 0.05
self.coords, self.edof, self.dofs, self.bdofs, self.elementmarkers = meshGen.create(
)
self.meshGen = meshGen
self.g = g
# Element type 16 is 8-node-quad. (See gmsh manual for more element types)
el_type = 16
# Degrees of freedom per node.
dofs_per_node = 1
# ---- Generate mesh --------------------------------------------------------
# gmshExecPath = Path to gmsh.exe.
# If None then the system PATH variable is queried.
# Relative and absolute paths work.
mesh = cfm.GmshMeshGenerator(g, el_type, dofs_per_node)
coords, edof, dofs, bdofs, elementmarkers = mesh.create()
# ---- Solve problem --------------------------------------------------------
print("Assembling system matrix...")
n_dofs = np.size(dofs)
ex, ey = cfc.coordxtr(edof, coords, dofs)
K = np.zeros([n_dofs, n_dofs])
for eltopo, elx, ely, elMarker in zip(edof, ex, ey, elementmarkers):
# Calc element stiffness matrix: Conductivity matrix D is taken
g.structuredSurface([20, 6, 5, 21])
g.structuredSurface([25, 20, 7, 33])
g.structuredSurface([32, 17, 18, 25]) #11
# ---- Create mesh ----------------------------------------------------------
cfu.info("Meshing geometry...")
# 3 Quads
elType = 3
dofsPerNode = 2
# Create mesh
meshGen = cfm.GmshMeshGenerator(geometry=g)
meshGen.elType = elType
meshGen.dofsPerNode = dofsPerNode
coords, edof, dofs, bdofs, elementmarkers = meshGen.create()
# ---- Solve problem --------------------------------------------------------
cfu.info("Assembling system matrix...")
nDofs = np.size(dofs)
ex, ey = cfc.coordxtr(edof, coords, dofs)
K = np.zeros([nDofs, nDofs])
for eltopo, elx, ely in zip(edof, ex, ey):
Ke = cfc.planqe(elx, ely, ep, D)
# The start and end points are the same # Add a surface: # Surfaces are defined by its curve boundaries. # The first parameter is a list of curve IDs that specify the outer boundary # of the surface. The second parameter is a list of lists of curve IDs that # specify holes in the surface. In this example there are two holes. The # boundaries and holes must be closed paths. We can see that [7] is closed # because curve 7 is a closed spline. addSurface creates a flat surface, so # all curves must lie on the same plane. g.surface([4, 3, 2, 1], [[7], [5, 6, 0]]) # ---- Generate mesh -------------------------------------------------------- meshGen = cfm.GmshMeshGenerator(g) # Element type 3 is quad. # (2 is triangle. See user manual for more element types) meshGen.elType = 2 meshGen.dofsPerNode = 1 # Degrees of freedom per node. meshGen.elSizeFactor = 0.10 # Factor that changes element sizes. # Mesh the geometry: # # The first four return values are the same as those that trimesh2d() returns. # coords is as list of node coordinates. edof is the element topology # (element degrees of freedom). dofs is a lists of all degrees of freedom # bdofs is a dictionary of boundary dofs (dofs of geometric entities with # markers). elementmarkers is a list of markers, and is used for finding the
# Element type 16 is 8-node-quad. (See gmsh manual for more element types)
elType = 16
#Degrees of freedom per node.
dofsPerNode = 1
# ---- Generate mesh --------------------------------------------------------
# gmshExecPath = Path to gmsh.exe.
# If None then the system PATH variable is queried.
# Relative and absolute paths work.
meshGen = cfm.GmshMeshGenerator(g, elType, dofsPerNode)
coords, edof, dofs, bdofs, elementmarkers = meshGen.create()
# ---- Solve problem --------------------------------------------------------
print("Assembling system matrix...")
nDofs = np.size(dofs)
ex, ey = cfc.coordxtr(edof, coords, dofs)
K = np.zeros([nDofs, nDofs])
for eltopo, elx, ely, elMarker in zip(edof, ex, ey, elementmarkers):
# Calc element stiffness matrix: Conductivity matrix D is taken
def execute(self):
# ------ Transfer model variables to local variables
self.inputData.updateparams()
version = self.inputData.version
units = self.inputData.units
v = self.inputData.v
ep = self.inputData.ep
E = self.inputData.E
mp = self.inputData.mp
fp = self.inputData.fp
bp = self.inputData.bp
ep[1] = ep[1] * U2SI[units][0]
E = E * U2SI[units][2]
for i in range(len(fp[0])):
fp[1][i] = fp[1][i] * U2SI[units][1]
for i in range(len(bp[0])):
bp[1][i] = bp[1][i] * U2SI[units][0]
# Get most updated dxf dimensions and import model geometry to calfem format
self.inputData.dxf.readDXF(self.inputData.dxf_filename)
for dim in self.inputData.d:
("Adjusting Dimension {0} with val {1}".format(
dim[0], dim[1] * U2SI[units][0]))
self.inputData.dxf.adjustDimension(dim[0], dim[1] * U2SI[units][0])
self.inputData.dxf.adjustDimension(
self.inputData.c['aName'], self.inputData.c['a'] * U2SI[units][0])
self.inputData.dxf.adjustDimension(
self.inputData.c['bName'], self.inputData.c['b'] * U2SI[units][0])
dxf = self.inputData.dxf
if self.inputData.refineMesh:
geometry, curve_dict = dxf.convertToGeometry(max_el_size=mp[2])
else:
geometry, curve_dict = dxf.convertToGeometry()
# Generate the mesh
meshGen = cfm.GmshMeshGenerator(geometry)
meshGen.elSizeFactor = mp[2] # Max Area for elements
meshGen.elType = mp[0]
meshGen.dofsPerNode = mp[1]
meshGen.returnBoundaryElements = True
coords, edof, dofs, bdofs, elementmarkers, boundaryElements = meshGen.create(
)
# Add the force loads and boundary conditions
bc = np.array([], int)
bcVal = np.array([], int)
nDofs = np.size(dofs)
f = np.zeros([nDofs, 1])
for i in range(len(bp[0])):
bc, bcVal = cfu.applybc(bdofs, bc, bcVal, dxf.markers[bp[0][i]],
bp[1][i])
for i in range(len(fp[0])):
xforce = fp[1][i] * np.cos(np.radians(fp[2][i]))
yforce = fp[1][i] * np.sin(np.radians(fp[2][i]))
cfu.applyforce(bdofs,
f,
dxf.markers[fp[0][i]],
xforce,
dimension=1)
cfu.applyforce(bdofs,
f,
dxf.markers[fp[0][i]],
yforce,
dimension=2)
# ------ Calculate the solution
print("")
print("Solving the equation system...")
# Define the elements coordinates
ex, ey = cfc.coordxtr(edof, coords, dofs)
# Define the D and K matrices
D = (E / (1 - v**2)) * np.matrix([[1, v, 0], [v, 1, 0],
[0, 0, (1 - v) / 2]])
K = np.zeros([nDofs, nDofs])
# Extract element coordinates and topology for each element
for eltopo, elx, ely in zip(edof, ex, ey):
Ke = cfc.plante(elx, ely, ep, D)
cfc.assem(eltopo, K, Ke)
# Solve the system
a, r = cfc.solveq(K, f, bc, bcVal)
# ------ Determine stresses and displacements
print("Computing the element forces")
# Extract element displacements
ed = cfc.extractEldisp(edof, a)
# Determine max displacement
max_disp = [[0, 0], 0] # [node idx, value]
for idx, node in zip(range(len(ed)), ed):
for i in range(3):
disp = math.sqrt(node[2 * i]**2 + node[2 * i + 1]**2)
if disp > max_disp[1]:
max_disp = [[idx, 2 * i], disp]
# Determine Von Mises stresses
vonMises = []
max_vm = [0, 0] # [node idx, value]
for i in range(edof.shape[0]):
es, et = cfc.plants(ex[i, :], ey[i, :], ep, D, ed[i, :])
try:
vonMises.append(
math.sqrt(
pow(es[0, 0], 2) - es[0, 0] * es[0, 1] +
pow(es[0, 1], 2) + 3 * es[0, 2]))
if vonMises[-1] > max_vm[1]:
max_vm = [i, vonMises[-1]]
except ValueError:
vonMises.append(0)
print("CAUGHT MATH EXCEPTION with es = {0}".format(es))
# Note: es = [sigx sigy tauxy]
# ------ Store the solution in the output model variables
self.outputData.disp = ed
self.outputData.stress = vonMises
self.outputData.geometry = geometry
self.outputData.a = a
self.outputData.coords = coords
self.outputData.edof = edof
self.outputData.mp = mp
self.outputData.meshGen = meshGen
self.outputData.statistics = [
max_vm, max_disp, curve_dict, self.inputData.dxf.anchor,
self.inputData.dxf.wh
]
if self.inputData.paramFilename is None:
print("Solution completed.")
def execute(self):
# --- Överför modell variabler till lokala referenser
ep = self.inputData.ep
E = self.inputData.E
v = self.inputData.v
Elementsize = self.inputData.Elementsize
# --- Anropa InputData för en geomtetribeskrivning
geometry = self.inputData.geometry()
# --- Nätgenerering
elType = 3 # <-- Fyrnodselement flw2i4e
dofsPerNode = 2
meshGen = cfm.GmshMeshGenerator(geometry)
meshGen.elSizeFactor = Elementsize # <-- Anger max area för element
meshGen.elType = elType
meshGen.dofsPerNode = dofsPerNode
meshGen.returnBoundaryElements = True
coords, edof, dof, bdofs, elementmarkers, boundaryElements = meshGen.create(
)
self.outputData.topo = meshGen.topo
#Solver
bc = np.array([], 'i')
bcVal = np.array([], 'i')
D = cfc.hooke(1, E, v)
nDofs = np.size(dof)
ex, ey = cfc.coordxtr(edof, coords, dof) #Coordinates
K = np.zeros([nDofs, nDofs])
#Append Boundary Conds
f = np.zeros([nDofs, 1])
bc, bcVal = cfu.applybc(bdofs, bc, bcVal, 30, 0.0, 0)
cfu.applyforce(bdofs, f, 20, 100e3, 1)
qs_array = []
qt_array = []
for x, y, z in zip(ex, ey, edof):
Ke = cfc.planqe(x, y, ep, D)
cfc.assem(z, K, Ke)
asolve, r = cfc.solveq(K, f, bc, bcVal)
ed = cfc.extractEldisp(edof, asolve)
for x, y, z in zip(ex, ey, ed):
qs, qt = cfc.planqs(x, y, ep, D, z)
qs_array.append(qs)
qt_array.append(qt)
vonMises = []
stresses1 = []
stresses2 = []
# For each element:
for i in range(edof.shape[0]):
# Determine element stresses and strains in the element.
es, et = cfc.planqs(ex[i, :], ey[i, :], ep, D, ed[i, :])
# Calc and append effective stress to list.
vonMises.append(
np.sqrt(
pow(es[0], 2) - es[0] * es[1] + pow(es[1], 2) + 3 * es[2]))
## es: [sigx sigy tauxy]
# sigmaij = np.array([[es(i,1),es(i,3),0],[es(i,3),es(i,2),0],[0,0,0]])
sigmaij = np.array([[es[0], es[2], 0], [es[2], es[1], 0],
[0, 0, 0]])
[v, w] = np.linalg.eig(sigmaij)
stresses1.append(v[0] * w[0])
stresses2.append(v[1] * w[1])
# --- Överför modell variabler till lokala referenser
self.outputData.vonMises = vonMises
self.outputData.edof = edof
self.outputData.coords = coords
self.outputData.stresses1 = stresses1
self.outputData.stresses2 = stresses2
self.outputData.geometry = geometry
self.outputData.asolve = asolve
self.outputData.r = r
self.outputData.ed = ed
self.outputData.qs = qs_array
self.outputData.qt = qt_array
self.outputData.dofsPerNode = dofsPerNode
self.outputData.elType = elType
self.outputData.calcDone = True
