def solve(self): """Solve problem""" self.updateGeometry() self.updateMesh() self.ep = [self.ptype, self.t] self.D = cfc.hooke(self.ptype, self.E, self.v) cfu.info("Assembling system matrix...") nDofs = np.size(self.dofs) ex, ey = cfc.coordxtr(self.edof, self.coords, self.dofs) K = np.zeros([nDofs, nDofs]) for eltopo, elx, ely in zip(self.edof, ex, ey): Ke = cfc.planqe(elx, ely, self.ep, self.D) cfc.assem(eltopo, K, Ke) cfu.info("Solving equation system...") f = np.zeros([nDofs, 1]) bc = np.array([], 'i') bcVal = np.array([], 'i') bc, bcVal = cfu.applybc(self.bdofs, bc, bcVal, 5, 0.0, 0) cfu.applyforce(self.bdofs, f, 7, 10e5, 1) self.a, self.r = cfc.solveq(K, f, bc, bcVal) cfu.info("Computing element forces...") ed = cfc.extractEldisp(self.edof, self.a) self.vonMises = [] # For each element: for i in range(self.edof.shape[0]): # Determine element stresses and strains in the element. es, et = cfc.planqs(ex[i, :], ey[i, :], self.ep, self.D, ed[i, :]) # Calc and append effective stress to list. self.vonMises.append( sqrt( pow(es[0], 2) - es[0] * es[1] + pow(es[1], 2) + 3 * es[2]))
def execute(self): info("Assembling K... (" + str(self.n_dofs) + ")") self.assem() info("Solving system...") self.results.a, self.results.r = cfc.spsolveq(self.K, self.f, self.bc, self.bc_val) info("Extracting ed...") self.results.ed = cfc.extractEldisp(self.mesh.edof, self.results.a) info("Element forces... ") self.calc_element_forces() return self.results
Ke = cfc.planqe(elx, ely, ep, D) cfc.assem(eltopo, K, Ke) bc = np.array([], 'i') bcVal = np.array([], 'f') bc, bcVal = cfu.applybc(bdofs, bc, bcVal, left_support, 0.0, 0) bc, bcVal = cfu.applybc(bdofs, bc, bcVal, right_support, 0.0, 2) f = np.zeros([nDofs, 1]) cfu.applyforcetotal(bdofs, f, top_line, -10e5, 2) a, r = cfc.solveq(K, f, bc, bcVal) ed = cfc.extractEldisp(edof, a) vonMises = [] for i in range(edof.shape[0]): es, et = cfc.planqs(ex[i, :], ey[i, :], ep, D, ed[i, :]) vonMises.append( sqrt(pow(es[0], 2) - es[0] * es[1] + pow(es[1], 2) + 3 * es[2])) # ----- Draw geometry cfv.drawGeometry(g) # ----- Draw the mesh. cfv.figure() cfv.drawMesh(coords=coords,
for elx, ely, eltopo in zip(ex, ey, Edof): Ke = cfc.bar2e(elx, ely, ep) cfc.assem(eltopo, K, Ke) print("Stiffness matrix K:") print(K) # ----- Solve the system of equations ---------------------------- bc = np.array([1, 2, 3, 4]) a, r = cfc.solveq(K, f, bc) print("Displacements a:") print(a) print("Reaction forces r:") print(r) # ----- Element forces ------------------------------------------- ed = cfc.extractEldisp(Edof, a) N = np.zeros([Edof.shape[0]]) print("Element forces:") i = 0 for elx, ely, eld in zip(ex, ey, ed): N[i] = cfc.bar2s(elx, ely, ep, eld) print("N%d = %g" % (i + 1, N[i])) i += 1
def solve(self): """Löser ett system av kontinuerliga balkar""" # Kontrollera att vi har materialegenskaper E = 2.1e9 A = 0.1 * 0.1 I = 0.1 * (0.1**3) / 12 if self.properties == None: self.properties = [] for i in enumerate(self.segments): self.properties.append([E, A, I]) # Beräkna antal element och frihetsgrader self.n_dofs = 0 self.n_elements = 0 for n in self.segments: self.n_dofs += n * 3 self.n_elements += n self.n_dofs += 3 # Global styvhetsmatris och lastvektor K = np.zeros((self.n_dofs, self.n_dofs), float) f = np.zeros((self.n_dofs, 1), float) # Elementtopologimatris. Varje rad representerar # ett element och dess frihetsgradskopplingar. edof = np.zeros((self.n_elements, 6), int) # Elementkoordinatsmatriser. Varje rad # anger koordinaterna för varje element ex = np.zeros((self.n_elements, 2), float) ey = np.zeros((self.n_elements, 2), float) # Elementegenskapsmatris. Anger elementegenskaperna # för varje element. ep = np.zeros((self.n_elements, 3), float) # Elementlastvektor. Anger elementlasten för varje # element. eq = np.zeros((self.n_elements, 2), float) # X-koordinat för varje beräkningspunkt. self.x = np.zeros((self.n_elements + 1), float) # Assemblera styvhetsmatrisen dof = 1 # Räknare för frihetsgrader el = 0 # Elementräknare self.support_dofs = [] # Randvillkor för varje upplag x = 0.0 # Aktuell x-koordinat för element for l, n, q, p in zip(self.lengths, self.segments, self.loads, self.properties): l_n = l / n self.support_dofs.append([dof, dof + 1, dof + 2]) for i in range(n): # Tilldela elementkoordinater ex[el, :] = [x, x + l_n] ey[el, :] = [0.0, 0.0] ep[el, :] = p eq[el, :] = [0.0, q] x += l_n # Beräkna element styvhet Ke, fe = cfc.beam2e(ex[el, :], ey[el, :], ep[el, :], eq[el, :]) # Tilldela elementtopologi etopo = np.array( [dof, dof + 1, dof + 2, dof + 3, dof + 4, dof + 5]) dof += 3 # Assemblera in element i global styvhetsmatris cfc.assem(etopo, K, Ke, f, fe) edof[el, :] = etopo el += 1 # Lägg till randvillkor för sista upplaget self.support_dofs.append([dof, dof + 1, dof + 2]) # Tillämpa randvillkor bc_prescr = [] bc_val = [] for dofs, support in zip(self.support_dofs, self.supports): if support == BeamModel.FIXED_Y: bc_prescr.append(dofs[1]) bc_val.append(0.0) elif support == BeamModel.FIXED_XY: bc_prescr.append(dofs[0]) bc_val.append(0.0) bc_prescr.append(dofs[1]) bc_val.append(0.0) elif support == BeamModel.FIXED_XYR: bc_prescr.append(dofs[0]) bc_val.append(0.0) bc_prescr.append(dofs[1]) bc_val.append(0.0) bc_prescr.append(dofs[2]) bc_val.append(0.0) # Lösning av ekvationssystem a, _ = cfc.solveq(K, f, np.asarray(bc_prescr), np.asarray(bc_val)) # Tilldela resultatvariabler self.y_displ = a[1::3] self.x_displ = a[0::3] self.rot = a[2::3] # Beräkna inre krafter och förskjutningar ed = cfc.extractEldisp(edof, a) # Skapa matris för de inre krafterna self.NVM = np.zeros((self.y_displ.shape[0], 3), float) # Beräkna elementkrafter i = 0 for el_displ, el_x, el_y, el_ep, el_eq in zip(ed, ex, ey, ep, eq): es = cfc.beam2s(el_x, el_y, el_ep, el_displ, el_eq) self.NVM[i, :] = es[0][0] self.x[i] = el_x[0] i += 1 # Sista positionen måste också tilldelas self.NVM[i, :] = es[0][1] self.x[i] = el_x[1]
print("Stiffness matrix K:") print(K) # f[1] corresponds to edof 2 f[1] = 100 # Solve the system of equations bc = np.array([1, 3]) a, r = cfc.solveq(K, f, bc) print("Displacements a:") print(a) print("Reaction forces Q:") print(r) # Caculate element forces ed1 = cfc.extractEldisp(Edof[0, :], a) ed2 = cfc.extractEldisp(Edof[1, :], a) ed3 = cfc.extractEldisp(Edof[2, :], a) es1 = cfc.spring1s(ep2, ed1) es2 = cfc.spring1s(ep1, ed2) es3 = cfc.spring1s(ep2, ed3) print("Element forces N:") print("N1 = " + str(es1)) print("N2 = " + str(es2)) print("N3 = " + str(es3))
bc = np.array([],'i') bcVal = np.array([],'i') bc, bcVal = cfu.applybc(bdofs, bc, bcVal, markFixed, 0.0) f = np.zeros([nDofs,1]) cfu.applyforcetotal(bdofs, f, markLoad, value = -10e5, dimension=2) print("Solving system...") a,r = cfc.spsolveq(K, f, bc, bcVal) print("Extracting ed...") ed = cfc.extractEldisp(edof, a) vonMises = [] # ---- Calculate elementr stresses and strains ------------------------------ print("Element forces... ") for i in range(edof.shape[0]): # Handle triangle elements if elType == 2: es, et = cfc.plants(ex[i,:], ey[i,:], elprop[elementmarkers[i]][0], elprop[elementmarkers[i]][1], ed[i,:])
# ----- Solve the system of equations ---------------------------- bc = np.array([1, 6]) bcVal = np.array([-17.0, 20.0]) a, r = cfc.solveq(K, f, bc, bcVal) print("Displacements a:") print(a) print("Reaction forces r:") print(r) # ----- Element flows ------------------------------------------- ed1 = cfc.extractEldisp(Edof[0, :], a) ed2 = cfc.extractEldisp(Edof[1, :], a) ed3 = cfc.extractEldisp(Edof[2, :], a) ed4 = cfc.extractEldisp(Edof[3, :], a) ed5 = cfc.extractEldisp(Edof[4, :], a) q1 = cfc.spring1s(ep1, ed1) q2 = cfc.spring1s(ep2, ed2) q3 = cfc.spring1s(ep3, ed3) q4 = cfc.spring1s(ep4, ed4) q5 = cfc.spring1s(ep5, ed5) print("q1 = " + str(q1)) print("q2 = " + str(q2)) print("q3 = " + str(q3)) print("q4 = " + str(q4))
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