Example #1
0
    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]))
Example #2
0
# ----- Solve problem

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)
    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]))
    def executeFem(self):
        
        q = self.inputData.q
        B = self.inputData.B
        b = self.inputData.b
        hvec = self.inputData.hvec
        Mvec = self.inputData.Mvec
        kmat = self.inputData.kmat
        rhow = self.inputData.rhow
        hn = self.inputData.hn
        
        coords = self.outputData.coords
        edof = self.outputData.edof
        bdofs = self.outputData.bdofs
        elementmarkers = self.outputData.elementmarkers 
        ex = self.outputData.ex
        ey = self.outputData.ey
        
        ndof=edof.max()
        
        # --- Definera randvillkor
        bc = np.array([],int)
        bcVal = np.array([],int)
        
        bc,bcVal = cfu.applybc(bdofs, bc, bcVal, 3, 0) 
        bc,bcVal = cfu.applybc(bdofs, bc, bcVal, 2, 0)
        
    
        
        if self.inputData.perm == True:
            bc,bcVal = cfu.applybc(bdofs, bc, bcVal, (599+hn), 0)    
        
        # --- Definiera materialmatris       
        ep=[(1)]
        D=np.zeros([2,2]) 
        
        # --- Skapa tom K-matris och f-vektor
        
        K = np.zeros([ndof,ndof])   
        C = np.zeros([ndof,ndof])


        
        for eltopo, elx, ely, elMarker in zip(edof, ex, ey, elementmarkers):
            Dn = elMarker - 100
            D[0,0] = kmat[Dn,0]*60*60*24*365.25
            D[1,1] = kmat[Dn,1]*60*60*24*365.25

            M = Mvec[Dn]
            
            Ke = cfc.flw2te(elx, ely, ep, D)
            Ce = tg.flwtec(elx,ely,rhow,M)
            cfc.assem(eltopo, K, Ke)
            cfc.assem(eltopo,C,Ce)
    
        a0 = tg.strdist(coords, ndof, q, B, b, hvec)
        a0 = np.asmatrix(a0)
        
        self.outputData.K = K
        self.outputData.C = C
        self.outputData.a0 = a0
        self.outputData.bc = bc
        self.outputData.bcVal = bcVal
Example #4
0
for eltopo, elx, ely, elMarker in zip(edof, ex, ey, elementmarkers):

    # Calc element stiffness matrix: Conductivity matrix D is taken
    # from Ddict and depends on which region (which marker) the element is in.

    Ke = flw2i8e(elx, ely, ep, Ddict[elMarker])
    assem(eltopo, K, Ke)

print("Solving equation system...")

f = zeros([nDofs, 1])

bc = array([], "i")
bcVal = array([], "i")

bc, bcVal = cfu.applybc(bdofs, bc, bcVal, 2, 30.0)
bc, bcVal = cfu.applybc(bdofs, bc, bcVal, 3, 0.0)

a, r = solveq(K, f, bc, bcVal)

# ---- Compute element forces -----------------------------------------------

print("Computing element forces...")

ed = extractEldisp(edof, a)

for i in range(shape(ex)[0]):
    es, et, eci = flw2i8s(ex[i, :], ey[i, :], ep, Ddict[elementmarkers[i]], ed[i, :])

    # Do something with es, et, eci here.
Example #5
0
for eltopo, elx, ely, elMarker in zip(edof, ex, ey, elementmarkers):

    # Calc element stiffness matrix: Conductivity matrix D is taken
    # from Ddict and depends on which region (which marker) the element is in.

    Ke = cfc.flw2i8e(elx, ely, ep, Ddict[elMarker])
    cfc.assem(eltopo, K, Ke)

print("Solving equation system...")

f = np.zeros([n_dofs, 1])

bc = np.array([], 'i')
bc_val = np.array([], 'i')

bc, bc_val = cfu.applybc(bdofs, bc, bc_val, 2, 30.0)
bc, bc_val = cfu.applybc(bdofs, bc, bc_val, 3, 0.0)

a, r = cfc.solveq(K, f, bc, bc_val)

# ---- Compute element forces -----------------------------------------------

print("Computing element forces...")

ed = cfc.extractEldisp(edof, a)

for i in range(np.shape(ex)[0]):
    es, et, eci = cfc.flw2i8s(
        ex[i, :], ey[i, :], ep, Ddict[elementmarkers[i]], ed[i, :])

    # Do something with es, et, eci here.
Example #6
0
nDofs = size(dofs)
ex, ey = coordxtr(edof, coords, dofs)
K = zeros([nDofs,nDofs])

for eltopo, elx, ely in zip(edof, ex, ey):
    Ke = planqe(elx, ely, ep, D)
    assem(eltopo, K, Ke)

print("Solving equation system...")

f = zeros([nDofs,1])

bc = array([],'i')
bcVal = array([],'i')

bc, bcVal = cfu.applybc(bdofs, bc, bcVal, 5, 0.0, 0)

cfu.applyforce(bdofs, f, 7, 10e5, 1)

a,r = solveq(K,f,bc,bcVal)

print("Computing element forces...")

ed = extractEldisp(edof,a)
vonMises = []

# For each element:

for i in range(edof.shape[0]): 

    # Determine element stresses and strains in the element.
Example #7
0
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)
    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(bdofs, bc, bcVal, 5, 0.0, 0)

cfu.applyforce(bdofs, f, 7, 10e5, 1)

a, r = cfc.solveq(K, f, bc, bcVal)

cfu.info("Computing element forces...")

ed = cfc.extractEldisp(edof, a)
vonMises = []

# For each element:

for i in range(edof.shape[0]):

    # Determine element stresses and strains in the element.
Example #8
0
nDofs = 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.flw2i4e(elx, ely, ep, D)
	cfc.assem(eltopo, K, Ke)
 
# ------ Forces and boundary conditions ------------

f = np.zeros([nDofs,1])
bc = np.array([], int)
bcVal = np.array([], int)

bc, bcVal = cfu.applybc(bdofs, bc, bcVal, 80, 0.0)
bc, bcVal = cfu.applybc(bdofs, bc, bcVal, 90, 10.0)

# ------ Solve equation system ------------

a,r = cfc.solveq(K,f,bc,bcVal)

# ------ Calculate element forces ------------

ed = cfc.extractEldisp(edof,a)

maxFlow = []
for i in range(edof.shape[0]): 
	es, et, eci = cfc.flw2i4s(ex[i,:], ey[i,:], ep, D, ed[i,:]) 
	maxFlow.append( 
		math.sqrt( math.pow(es[0,0],2) + math.pow(es[0,1],2)) 
Example #9
0
        Ke = cfc.flw2i4e(elx, ely, ep, D)
    elif mesh.el_type == 16:
        Ke = cfc.flw2i8e(elx, ely, ep, D)
    else:
        print("Element type not supported")

    cfc.assem(el_topo, K, Ke)

print("Solving equation system...")

f = np.zeros([n_dofs, 1])

bc = np.array([], 'i')
bc_val = np.array([], 'f')

bc, bc_val = cfu.applybc(bdofs, bc, bc_val, id_outer, 30.0)
bc, bc_val = cfu.applybc(bdofs, bc, bc_val, id_hole1, 300.0)
bc, bc_val = cfu.applybc(bdofs, bc, bc_val, id_hole2, 400.0)

a, r = cfc.solveq(K, f, bc, bc_val)

# ---- Compute element forces -----------------------------------------------

print("Computing element forces...")

ed = cfc.extract_eldisp(edof, a)

for i in range(np.shape(ex)[0]):
    if mesh.el_type == 2:
        es, et = cfc.flw2ts(ex[i, :], ey[i, :], D, ed[i, :])
    elif mesh.el_type == 3:
Example #10
0
for eltopo, elx, ely, elMarker in zip(edof, ex, ey, elementmarkers):

    if elType == 2:
        Ke = cfc.plante(elx, ely, elprop[elMarker][0], elprop[elMarker][1])
    else:
        Ke = cfc.planqe(elx, ely, elprop[elMarker][0], elprop[elMarker][1])
        
    cfc.assem(eltopo, K, Ke)
    
print("Applying bc and loads...")

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 ------------------------------
Example #11
0
    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.")
Example #12
0
for eltopo, elx, ely, elMarker in zip(edof, ex, ey, elementmarkers):

    if el_type == 2:
        Ke = cfc.plante(elx, ely, elprop[elMarker][0], elprop[elMarker][1])
    else:
        Ke = cfc.planqe(elx, ely, elprop[elMarker][0], elprop[elMarker][1])
        
    cfc.assem(eltopo, K, Ke)
    
cfu.info("Applying bc and loads...")

bc = np.array([],'i')
bcVal = np.array([],'i')

bc, bcVal = cfu.applybc(bdofs, bc, bcVal, mark_fixed, 0.0)

f = np.zeros([nDofs,1])

cfu.applyforcetotal(bdofs, f, mark_load, value = -10e5, dimension=2)

cfu.info("Solving system...")

a,r = cfc.spsolveq(K, f, bc, bcVal)

cfu.info("Extracting ed...")

ed = cfc.extractEldisp(edof, a)
von_mises = []

# ---- Calculate elementr stresses and strains ------------------------------
Example #13
0
 def addBC(self, marker, value=0.0, dimension=0):
     self.bc, self.bc_val = cfu.applybc(self.mesh.bdofs, self.bc,
                                        self.bc_val, marker, value,
                                        dimension)
Example #14
0
    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