Utiliser IvyFEM (bibliothèque de méthodes d'éléments finis pour .NET) à partir de Python

1.Tout d'abord

IvyFEM.dll, une bibliothèque de méthodes par éléments finis pour .NET, est en cours de développement. C'est une bibliothèque qui est censée être utilisée en C #, mais j'ai trouvé qu'elle pouvait être utilisée à partir de Python, je vais donc l'écrire sous forme d'article.

2. Comment appeler .NET à partir de Python sous Windows 10 (Python .NET)

J'ai décidé d'utiliser Python.NET. http://pythonnet.github.io/

Ci-dessous, on suppose que Python est déjà installé dans l'environnement Windows.

2.1. Installation de Python .NET

Exécutez ce qui suit à partir de l'invite de commande.

py -m pip install pythonnet

3. Package IvyFEM.dll

Téléchargez le dernier package depuis la page IvyFEM sur Github et extrayez-le dans votre répertoire de travail (voir Comment installer la page IvyFEM, runtime VC ++ requis). IvyFEM: https://github.com/ryujimiya/IvyFEM/

Une fois développé, ce sera comme suit.

4. Appelez IvyFEM depuis Python

J'ai essayé de résoudre l'équation de Poisson en Python.

Il prend une surface carrée et impose une condition aux limites avec un potentiel nul sur les côtés. Une région circulaire est prise à l'intérieur de la région, et la distribution potentielle de la région entière lorsqu'une charge est appliquée à cette région est calculée.

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))

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

eLen = 0.05
mesher = Mesher2D(cad, eLen)

#Voir les coordonnées
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 #scalaire
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:
	#scalaire
    #Notez que c'est une surcharge
	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]))

#Équation de Poisson FEM
FEM = Poisson2DFEM(world)

#Solveur linéaire
'''
solver = LapackEquationSolver()
solver.IsOrderingToBandMatrix = True
solver.Method = LapackEquationSolverMethod.Band
FEM.Solver = solver
'''

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

#résoudre
FEM.Solve()
U = FEM.U

#résultat
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. Exécuter

py -m main2

5. Résumé

J'ai résolu l'équation de Poisson à partir de Python en utilisant IvyFEM.dll.