Verwenden Sie IvyFEM (Finite-Elemente-Methodenbibliothek für .NET) aus Python

1. Zuallererst

IvyFEM.dll, eine Finite-Elemente-Methodenbibliothek für .NET, befindet sich in der Entwicklung. Es ist eine Bibliothek, die in C # verwendet werden soll, aber ich habe festgestellt, dass sie von Python aus verwendet werden kann, also werde ich sie als Artikel schreiben.

2. So rufen Sie .NET von Python unter Windows 10 aus auf (Python .NET)

Ich habe mich für Python.NET entschieden. http://pythonnet.github.io/

Im Folgenden wird davon ausgegangen, dass Python bereits in der Windows-Umgebung installiert ist.

2.1. Installieren von Python .NET

Führen Sie an der Eingabeaufforderung Folgendes aus.

py -m pip install pythonnet

3. IvyFEM.dll-Paket

Laden Sie das neueste Paket von der IvyFEM-Seite auf Github herunter und extrahieren Sie es in Ihr Arbeitsverzeichnis (siehe Installieren der IvyFEM-Seite, VC ++ - Laufzeit erforderlich). IvyFEM: https://github.com/ryujimiya/IvyFEM/

Wenn erweitert, wird es wie folgt sein.

4. Rufen Sie IvyFEM von Python aus auf

Ich habe versucht, Poissons Gleichung in Python zu lösen.

Es nimmt eine quadratische Fläche ein und legt an den Seiten eine Randbedingung mit Nullpotential fest. Innerhalb des Bereichs wird ein kreisförmiger Bereich genommen, und die Potentialverteilung des gesamten Bereichs, wenn eine Ladung auf diesen Bereich angewendet wird, wird berechnet.

main2.py

import clr

clr.AddReference("System")
from System import UInt32

clr.AddReference("System.Collections")
from System.Collections.Generic import List, IList

clr.AddReference('IvyFEM')
from IvyFEM \
import \
Cad2D, Mesher2D, FEWorld, \
FiniteElementType, \
PoissonMaterial, \
CadElementType, FieldValueType, FieldFixedCad, \
Poisson2DFEM

clr.AddReference('IvyFEM')
from IvyFEM.Linear \
import \
LapackEquationSolver, LapackEquationSolverMethod, \
IvyFEMEquationSolver, IvyFEMEquationSolverMethod

clr.AddReference('OpenTK')
from OpenTK import Vector2d

cad = Cad2D()

pts = List[Vector2d]()
pts.Add(Vector2d(0.0, 0.0))
pts.Add(Vector2d(1.0, 0.0))
pts.Add(Vector2d(1.0, 1.0))
pts.Add(Vector2d(0.0, 1.0))
lId1 = cad.AddPolygon(pts).AddLId
print("lId1 = " + str(lId1))

#Quelle
lId2 = cad.AddCircle(Vector2d(0.5, 0.5), 0.1, lId1).AddLId
print("lId2 = " + str(lId2))

eLen = 0.05
mesher = Mesher2D(cad, eLen)

#Siehe Koordinaten
vecs = mesher.GetVectors()
cnt = len(vecs)
print("len(vecs) = " + str(cnt))
coId = 0
for vec in vecs:
	print("vec[" + str(coId) + "] " + str(vec.X) + ", " + str(vec.Y))
	coId += 1

world = FEWorld()
world.Mesh = mesher

dof = 1 #Skalar
feOrder = 1
quantityId = world.AddQuantity(dof, feOrder, FiniteElementType.ScalarLagrange)

world.ClearMaterial()
ma1 = PoissonMaterial()
ma1.Alpha = 1.0
ma1.F = 0.0
ma2 = PoissonMaterial()
ma2.Alpha = 1.0
ma2.F = 100.0
maId1 = world.AddMaterial(ma1)
maId2 = world.AddMaterial(ma2)

lId1 = 1
world.SetCadLoopMaterial(lId1, maId1)

lId2 = 2
world.SetCadLoopMaterial(lId2, maId2)

zeroEIds = [1, 2, 3, 4]
zeroFixedCads = List[FieldFixedCad]()
for eId in zeroEIds:
	#Skalar
    #Beachten Sie, dass es sich um eine Überlastung handelt
	fixedCad = FieldFixedCad.Overloads[UInt32, CadElementType, FieldValueType](eId,CadElementType.Edge,FieldValueType.Scalar)
	zeroFixedCads.Add(fixedCad)
world.SetZeroFieldFixedCads(quantityId, zeroFixedCads)

#DEBUG
zeroFixedCads = world.GetZeroFieldFixedCads(quantityId)
print("len(zeroFixedCads) = " + str(len(zeroFixedCads)))

world.MakeElements()

feIds = world.GetTriangleFEIds(quantityId)
feCnt = len(feIds)
print("feCnt = " + str(feCnt))
for feId in feIds:
	print("--------------")
	print("feId = " + str(feId))
	triFE = world.GetTriangleFE(quantityId, feId)
	nodeCoIds = triFE.NodeCoordIds
	elemNodeCnt = nodeCoIds.Length
	for iNode in range(elemNodeCnt):
		print("coId[" + str(iNode) + "] = " + str(nodeCoIds[iNode]))

#Poisson-Gleichung FEM
FEM = Poisson2DFEM(world)

#Linearer Löser
'''
solver = LapackEquationSolver()
solver.IsOrderingToBandMatrix = True
solver.Method = LapackEquationSolverMethod.Band
FEM.Solver = solver
'''

solver = IvyFEMEquationSolver()
solver.Method = IvyFEMEquationSolverMethod.NoPreconCG
FEM.Solver = solver

#lösen
FEM.Solve()
U = FEM.U

#Ergebnis
nodeCnt = len(U)
for nodeId in range(nodeCnt):
    print("-------------")
    coId = world.Node2Coord(quantityId, nodeId)
    value = U[nodeId]
    print(str(nodeId) + " " + str(coId) + " " + "{0:e}".format(value))

5. Führen Sie aus

py -m main2

5. Zusammenfassung

Ich habe die Poisson-Gleichung aus Python mit IvyFEM.dll gelöst.