Contenu | Rechercher | Menus

Annonce

Si vous rencontrez des soucis à rester connecté sur le forum (ou si vous avez perdu votre mot de passe) déconnectez-vous et reconnectez-vous depuis cette page, en cochant la case "Me connecter automatiquement lors de mes prochaines visites".
Test de l'ISO d'Ubuntu francophone : nous avons besoin de testeurs pour la version francophone d'Ubuntu 14.04. Liens et informations ici.

Attention, une faille de sécurité dans bash a récemment été rapportée, il est recommandé de mettre à jour son système (plus de détails)

#76 Le 16/03/2010, à 01:16

Le Farfadet Spatial

Re : Petit guide pour aider au choix d'un langage

Salut à tous !

no_spleen a écrit :

Sur amazon, j'ai trouvé ce livre
"Python - Les Fondamentaux du langage - La Programmation pour les scientifiques. de Matthieu Brucher"

Très bon livre, dans la mesure où tu sais déjà programmer et que tu es intéressé par la partie scientifique, il te conviendra parfaitement. Après, je ne suis pas un grand spécialiste de Python, mais il me semble faire une bonne présentation du langage. Certains trouvent que le niveau y est un peu soutenu. Il semble avoir plutôt bonne presse chez les habitués de Python.

   Quelques réponses pèle-mêle :

   Ce n'est pas tant que je suis habitué à des matrices creuses (même si j'en utilise pas mal), mais à faire des benchmarks sur des machines dédiés au calcul et pour ne pas être trop perturbé par les à-côtés, il vaut mieux faire des calculs un peu long. Oui, j'ai déjà inversé des matrices 100000x100000 -- oui, c'est long. Si j'ai ajouté un affichage, c'est parce que je suis habitué à utiliser des options de compilations agressives et, sur des benchmarks, le risque est que le code ne fasse plus rien. Cela dit, il vaut mieux, en effet, n'afficher qu'une seule case de la matrice.

   Par contre, je pense que Python remplace avantageusement Matlab : on évite d'être dépendant d'un fournisseur, Python est capable de faire tout ce que Matlab peut faire, mais en étant plus généraliste. D'autant qu'il s'interface très bien avec Fortran, C et C++ (utiliser Boost.Python). Par contre, on peut être amené dans certain cas à devoir coder des éléments pour lesquelles il existe déjà une bibliothèque sous Matlab. Cela dit, je suis désolé, mais je ne connais pas assez bien Python pour pouvoir faire une présentation exhaustive de ses bibliothèques dédiés aux scientifiques.

   À bientôt.

   Le Farfadet Spatial


L'antre du farfadet :
http://le.farfadet.spatial.free.fr/
Textes, musiques et peintures

Hors ligne

#77 Le 16/03/2010, à 07:52

no_spleen

Re : Petit guide pour aider au choix d'un langage

J'ai commandé le livre. Après lecture, je posterai un avis (je ne sais pas quel est le meilleur post pour cela). J'envisagerai alors plus sérieusement la possibilité de coder un projet plus complexe en python, pour comparer.

Pour ce qui est de notre benchmark, la différence entre python et le fortran compilé avec les produits INTEL ne semble pas énorme (sur ce cas simple, il est vrai). Je vais même voir s'il n'y a pas moyen de recompiler numpy avec MKL. Je vais aussi essayer de comprendre pourquoi gfortran donne de si mauvais résultats.

Et... je vais aussi un peu travailler !

Hors ligne

#78 Le 16/03/2010, à 12:27

Le Farfadet Spatial

Re : Petit guide pour aider au choix d'un langage

Salut à tous !

no_spleen a écrit :

Je vais aussi essayer de comprendre pourquoi gfortran donne de si mauvais résultats.

Je préfère G95 à GFortran.

   À bientôt.

   Le Farfadet Spatial


L'antre du farfadet :
http://le.farfadet.spatial.free.fr/
Textes, musiques et peintures

Hors ligne

#79 Le 16/03/2010, à 12:58

tshirtman

Re : Petit guide pour aider au choix d'un langage

Après lecture, je posterai un avis (je ne sais pas quel est le meilleur post pour cela)

*
le HS ayant peut être assez duré (mes excuses, ce n'était pas l'intention), le mieux sera sans doute d'ouvrir un nouveau post (sauf si Le Farfadet Spacial pense le contraire, c'est son sujet).

Hors ligne

#80 Le 16/03/2010, à 21:29

Le Farfadet Spatial

Re : Petit guide pour aider au choix d'un langage

Salut à tous !

tshirtman a écrit :

le HS ayant peut être assez duré (mes excuses, ce n'était pas l'intention), le mieux sera sans doute d'ouvrir un nouveau post (sauf si Le Farfadet Spacial pense le contraire, c'est son sujet).

Il n'est sans doute pas nécessaire d'ouvrir un sujet juste pour la critique d'un seul livre et certains scientifiques peuvent venir ici alors qu'ils cherchent un langage adapté à leurs besoins : alors, ce livre pourrait les intéresser, donc il reste sans doute pertinent de donner son avis ici.

   À bientôt.

   Le Farfadet Spatial


L'antre du farfadet :
http://le.farfadet.spatial.free.fr/
Textes, musiques et peintures

Hors ligne

#81 Le 16/03/2010, à 23:31

mydjey

Re : Petit guide pour aider au choix d'un langage

Je reviens dans ce topic demander quelques infos. big_smile

J'ai commencé la prog il y'a quelques temps avec le C. Même si le bouquin que j'utilise est très didactique.... Comment dire ? C'est chaud le C et un peu décourageant. sad
Début de semaine je suis tombé sur un site qui explique les bases du python. Waoou ! En 2 heures on va dire, j'ai fait ce que j'ai mis plus d'une semaine à apprendre en C.

Ma question :
Quelle est pour vous le bouquin le plus sympa pour débuter avec python ?
Sachant que pour le moment je dispose de ses 3 bouquins en pdf :
*  Le Swinnen
*  A byte of Python
*  Plongez au cœur de python (dive into python)

Bien que très connu, j'ai lu que vous trouviez le Swinnen bof, bof.
Des 3 lequel vous parait le mieux ?

J'ai aussi vu que Farfadet Spatial propose :  Python : Petit guide à l'usage du développeur agile
J'ai regardé un peu les commentaires sur Amazon. Et je me demande si il est bien écris pour le débutant en programmation ce bouquin ? Il explique les bases de python ? Les boucles, les conditions, donne des explications sur la programmation OO, comment mettre en place son code dans Linux etc... ?

Merci pour vos avis.


Mon site : http://mydjey.eu/

Hors ligne

#82 Le 17/03/2010, à 00:44

tshirtman

Re : Petit guide pour aider au choix d'un langage

/me a "python - syntaxe, conception et optimisation" de tarek ziadé, qui prends vraiment par la main, depuis les bases jusqu'a un niveau intermédiaire (mais tout à fait solide), mais bon, c'est un bouquin irl, pas un pdf. (mais bon, ça à l'aire de bien correspondre à ta demande).

pour le développement agile, je suppose que le bouquin se focalise plus sur des pratiques de développement en général encouragé dans la communauté python, l'écriture de test unitairs, l'intégration continue, ce genre de choses…

enfin, je pense que les boucle et toute la base du langage, le tuto python en ligne (en anglais mais bon) est tout à fait adapté.

edit: correction du titre.

Dernière modification par tshirtman (Le 17/03/2010, à 00:47)

Hors ligne

#83 Le 19/03/2010, à 12:41

no_spleen

Re : Petit guide pour aider au choix d'un langage

Attention, il y a une erreur dans notre petit benchmark.

Le code python ci-dessus produit des array, et l'opérateur * sur des array réalise la multiplication élément par élément, et non la multiplication matricielle.

Pour obtenir la multiplication matricielle, il faut utiliser le type matrix

from numpy import *

for i in range(10):
        A = matrix(random.rand(1000,1000))
        B = matrix(random.rand(1000,1000))
        C = A * B

ce qui donne

time python test.py

real	0m17.783s
user	0m17.561s
sys	0m0.200s

Hors ligne

#84 Le 19/03/2010, à 23:07

Le Farfadet Spatial

Re : Petit guide pour aider au choix d'un langage

Salut à tous !

no_spleen a écrit :

Attention, il y a une erreur dans notre petit benchmark.

Comme quoi, il fallait se méfier, mais je vous avais prévenus : je n'avais pas testé.

ce qui donne

time python test.py

real	0m17.783s
user	0m17.561s
sys	0m0.200s

Hé bien, je dois dire que je ne m'y attendais pas du tout, je n'étais pas resté là-dessus.

   Peux-tu faire ce test plusieurs fois (par exemple trois fois), faire la moyenne, puis donner la valeur. Cela ne va pas être trop éloigné, mais cela permettra d'avoir un chiffre assez indépendant du système. Ce serait bien de comparer avec la même chose en Fortran sur le même système.

   Après, il faudra voir avec une application plus réaliste, comme un petit code d'éléments finis, mais je suis prêt à réviser mon point de vue s'il s'avère que la concurrence est possible.

   À bientôt.

   Le Farfadet Spatial


L'antre du farfadet :
http://le.farfadet.spatial.free.fr/
Textes, musiques et peintures

Hors ligne

#85 Le 19/03/2010, à 23:26

no_spleen

Re : Petit guide pour aider au choix d'un langage

J'ai réalisé le test 4 fois en python et 4 fois en fortran

Résultats Fortran

REAL : 0.50875
USER : 0.40900
SYS   : 0.01900

Résultats Python

REAL : 17.959
USER : 17.431
SYS   : 0.1680

Il y a quand même une nette différence. J'essaye de compiler numpy avec les librairies MKL mais je n'y suis pas encore arrivé.

Si tu en as le temps, peux-tu écrire le même code en C++ pour comparer ?

J'ai reçu le livre mentionné plus haut hier. Je l'ai déjà pas mal parcouru et pour l'instant mon impression est plutôt négative. Je formulerai un avis plus honnête après une lecture complète.

Hors ligne

#86 Le 20/03/2010, à 11:37

no_spleen

Re : Petit guide pour aider au choix d'un langage

Attention, il semble qu'il y aie encore une erreur, mais cette fois dans mon code FORTRAN, il semble qu'il ne calcule pas du tout le produit, ce qui explique sa grande rapidité !

Si j'utilise la fonction intrinsèque matmul plutot que blas, fortran met 13 secondes. Si je compile numpy avec ATLAS, celui met 7 secondes...

Bref, rien de concluant pour les bench. Tout dépend des librairies utilisées. En effet pour l'instant c'est en python que je vais le plus vite pour faire mon produit !

j'ai commencé un code FEM en python, je vous tiens au courant.

Hors ligne

#87 Le 21/03/2010, à 00:55

Le Farfadet Spatial

Re : Petit guide pour aider au choix d'un langage

Salut à tous !

no_spleen a écrit :

Si tu en as le temps, peux-tu écrire le même code en C++ pour comparer ?

Ma soutenance a lieu lundi, il faudra attendre un peu. N'hésitez pas à me relancer en fin de semaine si je n'ai rien fourni.

Bref, rien de concluant pour les bench.

Ce n'est guère surprenant.

j'ai commencé un code FEM en python, je vous tiens au courant.

Oui, c'est plutôt un tel code qui permet de juger. Pour là où j'en suis resté, le facteur de ralentissement de Python le rend impropre pour faire plus qu'un modèle jouet -- c'est-à-dire, pour ceux qui pensent qu'il s'agit d'un terme péjoratif, d'un modèle exploratoire pour étudier certains points théoriques.

   À bientôt.

   Le Farfadet Spatial


L'antre du farfadet :
http://le.farfadet.spatial.free.fr/
Textes, musiques et peintures

Hors ligne

#88 Le 21/03/2010, à 01:00

tshirtman

Re : Petit guide pour aider au choix d'un langage

c'est-à-dire, pour ceux qui pensent qu'il s'agit d'un terme péjoratif, d'un modèle exploratoire pour étudier certains points théoriques.

la simplicité du language et sa proximité avec les expression mathématique a en effet cet avantage, permettre de comparer simplement plusieurs algos en termes d'efficacité, quitte à réimplémenter dans un language plus rapide si nécessaire, l'algo qui aura été trouvé le plus rapide.

Hors ligne

#89 Le 21/03/2010, à 01:12

Le Farfadet Spatial

Re : Petit guide pour aider au choix d'un langage

Salut à tous !

tshirtman a écrit :

la simplicité du language et sa proximité avec les expression mathématique a en effet cet avantage, permettre de comparer simplement plusieurs algos en termes d'efficacité, quitte à réimplémenter dans un language plus rapide si nécessaire, l'algo qui aura été trouvé le plus rapide.

C'est-à-dire que pour les algorithmes, il y a l'analyse de complexité en temps et en espace, c'est beaucoup plus significatif qu'une implémentation, qui peut être bogué, entre autre.

   Non, un modèle-jouet, c'est surtout utilisé pour étudier un phénomène particulier en entrant autant que possible dans un cas idéal, c'est-à-dire en l'isolant de tout autre phénomène.

   Il existe des choses basées sur Python pour réaliser cela facilement et efficacement, mais je ne retrouve plus le nom.

   À bientôt.

   Le Farfadet Spatial

   Édition : je suis en train de me dire qu'on pourrait penser qu'il y a acharnement, je précise donc que je n'ai aucune dent contre Tshirtman -- ni contre Python, d'ailleurs.

Dernière modification par Le Farfadet Spatial (Le 21/03/2010, à 01:15)


L'antre du farfadet :
http://le.farfadet.spatial.free.fr/
Textes, musiques et peintures

Hors ligne

#90 Le 21/03/2010, à 01:37

tshirtman

Re : Petit guide pour aider au choix d'un langage

je le prends pas comme de l'acharnement, et je pense qu'on pourrait tout à fait penser la même chose de mes interventions ^^, tu as des choses intéressantes à dire sur l'intérêt des langages pour diverses utilisations, on peut être d'accord ou pas, mais il n'y a pas de mal à les dire. smile

en effet, mon interventions sur les algos était réductrice par rapport au concept de modele objet. Pour ce dont tu parles sans retrouver le nom, tu penses peut être au mocking pour simuler l'environnement autour du cas étudié? bien que ce ne soit pas spécifique au python je pense.

Hors ligne

#91 Le 21/03/2010, à 10:12

no_spleen

Re : Petit guide pour aider au choix d'un langage

Bonne chance pour ta soutenance Farfardet !

Hors ligne

#92 Le 21/03/2010, à 10:38

Le Farfadet Spatial

Re : Petit guide pour aider au choix d'un langage

Salut à tous !

tshirtman a écrit :

Pour ce dont tu parles sans retrouver le nom, tu penses peut être au mocking pour simuler l'environnement autour du cas étudié? bien que ce ne soit pas spécifique au python je pense.

Non, ce n'est pas ça. C'est quelque chose de purement éléments-finis. J'essayerais de chercher le nom. En gros, tu écris les équations dirigeant ton modèle et les conditions aux limites sous une forme très proche de la façon naturelle d'écrire des équations, tu donnes ton maillage et tout le reste est automatique. Pour ceux qui connaissent, un équivalent de FreeFEM, mais en Python.

no_spleen a écrit :

Bonne chance pour ta soutenance Farfardet !

Merci.

   À bientôt.

   Le Farfadet Spatial


L'antre du farfadet :
http://le.farfadet.spatial.free.fr/
Textes, musiques et peintures

Hors ligne

#93 Le 21/03/2010, à 10:42

no_spleen

Re : Petit guide pour aider au choix d'un langage

l'interface de getfem++ pour python peut être ?

Hors ligne

#94 Le 21/03/2010, à 23:04

Le Farfadet Spatial

Re : Petit guide pour aider au choix d'un langage

Salut à tous !

no_spleen a écrit :

l'interface de getfem++ pour python peut être ?

Non plus...

   J'essayerais de retrouver.

   À bientôt.

   Le Farfadet Spatial


L'antre du farfadet :
http://le.farfadet.spatial.free.fr/
Textes, musiques et peintures

Hors ligne

#95 Le 26/03/2010, à 12:46

no_spleen

Re : Petit guide pour aider au choix d'un langage

Bonjour,

J'ai avancé dans l'écriture d'un code FEM en python, et pour l'instant un gros problème apparaît.

Les fonctions optimisées de numpy sont très rapides, elles ne posent pas de problème. Par contre, les performances de python se font sentir pour tout ce qui est autour ! Principalement, la vitesse d'accès aux éléments d'un dictionnaire ou la vitesse d'itération sur des listes rend l'entreprise inenvisageable pour des problèmes de taille raisonnable.

Par exemple, pour un maillage de 10 000 tetrahèdres, il faut presque une heure juste pour construire la matrice !

Je vais écrire un exemple minimal pour que tout cela soit plus concret.

Hors ligne

#96 Le 26/03/2010, à 12:58

tshirtman

Re : Petit guide pour aider au choix d'un langage

Si tu as des problèmes de ce coté là, l'utilisation de psyco peut aider beaucoup.

import psyco
psyco.full()

Au début de ton code, rien à faire de plus.
Malheureusement, ça ne marche que sur x86 (ça réalise de la compilation just in time, le projet pypy promet de résoudre ça et d'amener de telles performances sur toutes les plateformes.)

Dernière modification par tshirtman (Le 26/03/2010, à 12:59)

Hors ligne

#97 Le 26/03/2010, à 16:48

no_spleen

Re : Petit guide pour aider au choix d'un langage

Malheureusement, cela n'a pas l'air ce changer quoi que soit chez moi.

Je vais essayer plusieurs choses

1) Pour l'instant j'utilise des dictionnaires qui prennent des objets comme clés. J'ai lu quelque part que les dictionnaires allaient plus vite en prenant des caractères. Je vais essayer de modifier cela

2) Les itérations sur des listes d'objet semblent extrêmement lentes. Est-ce qu'il n'y a pas une astuce pour booster cela, en définissant mieux les __hash__ ou quelque chose du genre ?

3) Je vais installer python 3 pour voir !

Pour en revenir au sujet du post, si je ne résous pas ces problèmes, je ne conseillerai pas Python pour du calcul scientifique de "moyenne performance"

Hors ligne

#98 Le 26/03/2010, à 16:51

Kanor

Re : Petit guide pour aider au choix d'un langage

C'est possible de voir le code ?

Hors ligne

#99 Le 26/03/2010, à 17:02

no_spleen

Re : Petit guide pour aider au choix d'un langage

Pas de problème, mais c'est un peu long et complexe

Voici les classes définissant les objets géométriques

class node:
	"""
		node class
	"""
	def __init__(self,num,x,y,z):
		self._globNum = num
		self._x       = x
		self._y       = y
		self._z       = z
	def getNum(self):
		return self._globNum
	def getXYZ(self):
		return (self._x,self._y,self._z)
	def numberOfNodes(self):
		return 1
	def getInterpolation(self,U,u,v,w):
		return u(1)
########################################################################
class line(node):
	"""
		line class
	"""
	def __init__(self,num,tag,partition,node1,node2):
		self._globNum   = num
		self._tag       = tag
		self._partition = partition
		self._node1     = node1
		self._node2     = node2
	def getNum(self):
		return self._globNum
	def getXYZ(self):
		return (self._x,self._y,self._z)
	def getTag(self):
		return self._tag
	def getPartition(self):
		return self._partition
	def getNodes(self):
		return [self._node1,self._node2]
	def numberOfNodes(self):
		return 2
	def getShapesFunctions(self,u,v,w):
		shf = [ 0.5 * (1-u), 0.5 * (1+u) ]
		return shf
	def getGradShapesFunctions(self,u,v,w):
		gx   = [-0.5 , 0.5]
		gy   = [ 0.0 , 0.0]
		gz   = [ 0.0 , 0.0]
		gdsf = [ gx , gy , gz]
		return gdsf
	def getInterpolation(self,U,u,v,w):
		shf = self.getShapesFunctions(u,v,w)
		value = shf(0) * U(0) + shf(1) * U(1)
		return value
########################################################################
class triangle(node):
	"""
		triangle class
	"""
	def __init__(self,num,tag,partition,node1,node2,node3):
		self._globNum   = num
		self._tag       = tag
		self._partition = partition
		self._node1     = node1
		self._node2     = node2
		self._node3     = node3
	def getNum(self):
		return self._globNum
	def getXYZ(self):
		return (self._x,self._y,self._z)
	def getTag(self):
		return self._tag
	def getPartition(self):
		return self._partition
	def getNodes(self):
		return [self._node1,self._node2,self._node3]
	def numberOfNodes(self):
		return 3
	def getShapesFunctions(self,u,v,w):
		shf = [ (1 - u - v) , u , v ]
		return shf
	def getGradShapesFunctions(self,u,v,w):
		gx   = [ -1.0 ,  1.0 , 0.0]
		gy   = [ -1.0 ,  0.0 , 1.0]
		gz   = [  0.0 ,  0.0 , 0.0]
		gdsf = [ gx , gy , gz]
		return gdsf
	def getInterpolation(self,U,u,v,w):
		shf = self.getShapesFunctions(u,v,w)
		value = shf(0) * U(0) + shf(1) * U(1) + shf(2) * U(2)
		return value
#########################################################################
class tetrahedron(node):
	"""
		tetrahedron class
	"""
	def __init__(self,num,tag,partition,node1,node2,node3,node4):
		self._globNum   = num
		self._tag       = tag
		self._partition = partition
		self._node1     = node1
		self._node2     = node2
		self._node3     = node3
		self._node4     = node4
	def getNum(self):
		return self._globNum
	def getXYZ(self):
		return (self._x,self._y,self._z)
	def getTag(self):
		return self._tag
	def getPartition(self):
		return self._partition
	def getNodes(self):
		return [self._node1,self._node2,self._node3,self._node4]
	def numberOfNodes(self):
		return 4	
	def getShapesFunctions(self,u,v,w):
		shf = [ (1 - u - v - w) , u , v , w]
		return shf
	def getGradShapesFunctions(self,u,v,w):
		gx   = [ -1.0 , 1.0 , 0.0 , 0.0 ]
		gy   = [ -1.0 , 0.0 , 1.0 , 0.0 ]
		gz   = [ -1.0 , 0.0 , 0.0 , 1.0 ]
		gdsf = [ gx , gy , gz]
		return gdsf
	def getInterpolation(self,U,u,v,w):
		shf = self.getShapesFunctions(u,v,w)
		value = shf(0) * U(0) + shf(1) * U(1) + shf(2) * U(2) + shf(3) * U(3)
		return value
########################################################################################

La classe définissant le maillage

from geom import *

class mesh :
	"""
		mesh class
	"""
	def __init__(self,file_name):
		"""
			constructor of the mesh class, from a gmsh file
		"""
		self._NODES        = []
		self._LINES        = []
		self._TRIANGLES    = []
		self._TETRAHEDRONS = []

		#open the file
		f = open(file_name,"r")

		# nodes lecture
		str = "a"
		while str !=  "$Nodes":
			str = f.readline().strip()
		
		self._numNodes = int(f.readline())
		 
		for i in xrange(self._numNodes):
			str = f.readline().strip().split()
			n = node(int(str[0]) , float(str[1]) , float(str[2]) , float(str[3]))
			self._NODES.append(n)
			
		str = f.readline()

		# elements lecture
		str = f.readline()
		self._numElements = int(f.readline())
		for i in xrange(self._numElements):
			str = f.readline().strip().split()
									
			if str[1] ==  "1":
				num       = int(str[0])
				tag       = int(str[3])
				partition = int(str[5])
				numNode1  = int(str[6]) - 1
				numNode2  = int(str[7]) - 1
				node1     = self._NODES[numNode1]
				node2     = self._NODES[numNode2]
				n = line(num,tag,partition,node1,node2)	
				self._LINES.append(n)
			elif str[1] ==  "2":
				num       = int(str[0])
				tag       = int(str[3])
				partition = int(str[5])
				numNode1  = int(str[6]) - 1
				numNode2  = int(str[7]) - 1
				numNode3  = int(str[8]) - 1
				node1     = self._NODES[numNode1]
				node2     = self._NODES[numNode2]
				node3     = self._NODES[numNode3]
				n = triangle(num,tag,partition,node1,node2,node3)
				self._TRIANGLES.append(n)
			elif str[1] ==  "4":
				num       = int(str[0])
				tag       = int(str[3])
				partition = int(str[5])
				numNode1  = int(str[6]) - 1
				numNode2  = int(str[7]) - 1
				numNode3  = int(str[8]) - 1
				numNode4  = int(str[9]) - 1
				node1     = self._NODES[numNode1]
				node2     = self._NODES[numNode2]
				node3     = self._NODES[numNode3]
				node4     = self._NODES[numNode4]
				n = tetrahedron(num,tag,partition,node1,node2,node3,node4)
				self._TETRAHEDRONS.append(n)
			else:
				if str[1] != "15":
					print "There are non implemented type of element in the mesh"	
		print "-Mesh reading"
		print "Mesh file name         :", file_name              
	        print "Number of nodes        :", self._numNodes          		
		print "Number of lines        :", len(self._LINES)        
		print "Number of triangles    :", len(self._TRIANGLES)   
		print "Number of tetrahedrons :", len(self._TETRAHEDRONS)
		print "-End of mesh reading "
		
		# close the file
		f.close()
	def getNumNodes(self):
		return self._numNodes
	def getElementsByTag(self,dim,tag):
		"""
			function returning a list of elements of dimension 'dim' and tag 'tag'
		"""
		elements = []
		if dim == 1:
			for line in self._LINES:
				if line.getTag() == tag:
					elements.append(line)	
		elif dim == 2:
			for triangle in self._TRIANGLES:
				if triangle.getTag() == tag:
					elements.append(triangle)
		elif dim == 3:
			for tetrahedron in self._TETRAHEDRONS:
				if tetrahedron.getTag() == tag:
					elements.append(tetrahedron)
		return elements
	def getVerticesByTag(self,dim,tag):
		"""
			function returning a list a elements if dimension 'dim' and tag 'tag'
		"""
		elements = self.getElementsByTag(dim,tag)
		vertices = set([])
		for elem in elements :
			a = elem.getNodes()
			vertices.update(a)
		return vertices
##############################################################################################

La classe gérant les degrés de libertés

from geom import *
from collections import *
from linear_system import *

class dofkey:
	def __init__(self,node,name):
		self._node = node
		self._name = name
	def __eq__(self,other):
		node = other.getNode()
		name = other.getName()

		if (self._node == node) and (self._name == name):
			return True
		else:
			return False
	def __hash__(self):
        	value = hash(self._name)
		return value
	def getNode(self):
		return self._node
	def getName(self):
		return self._name
		
class dof_manager:
	def __init__(self):
		self._numbering = defaultdict()
		self._fixed     = defaultdict()
	
	def fixVertex(self,node,name,val):
		dof = dofkey(node,name)
		self._fixed[dof]=val		

	def numberVertex(self,node,name):
		dof  = dofkey(node,name)
		if self._fixed.get(dof,"_") == "_":
			self._numbering[dof]=(len(self._numbering))

	def fixVertices(self,nodes,name,val):
		fix = self.fixVertex
		for node in nodes:
			fix(node,name,val)

	def numberVertices(self,nodes,name):
		number = self.numberVertex
		for node in nodes:
			number(node,name)

	def getNumberingSize(self):
		return len(self._numbering)

	def getFixedSize(self):
		return len(self._fixed)
	
	def linkToLinearSystem(self,lsys):
		self._lsys = lsys

	def fixInSolution(self,node,name,val):
		dof = dofkey(node,name)
		num = self._numbering.get(dof,-1)
		if not num == -1:
			self._lsys.fixInSolution(num,val)
	def addToMatrix(self,dofi,dofj,val):

		if (dofi in self._numbering.keys()):
			if (dofj in self._numbering.keys()):
				R = self._numbering[dofi]
				C = self._numbering[dofj]
				self._lsys.addToMatrix(R,C,val)
			else:
				R = self._numbering[dofi]
				F = self._fixed[dofj]
				self._lsys.addToRHS(R,-val*F)
	def addToRHS(self,dofi,val):
		if (dofi in self._numbering.keys()):
			R = self._numbering[dofi]
			self._lsys.addToRHS(R,val)	

	def assembleInMatrix(self,node1,node2,n,local):

		unknows = ["RHO","P","UX","UY","UZ","Y","e","eps","T","k","h","YEQ","DEFF"]
		for i in xrange(n-1):
			f = "X" + str(i+1)
			unknows.append(f)
		unknows.append("XN")
		for i in xrange(n-1):
			f = "T" + str(i+1)
			unknows.append(f)
		unknows.append("TN")

		for i in xrange(13+2*n):
			dofi = dofkey(node1,unknows[i])
			for j in xrange(13+2*n):
				dofj = dofkey(node2,unknows[j])
				self.addToMatrix(dofi,dofj,local[i,j])
	def assembleInVector(self,node1,n,local):
		unknows = ["RHO","P","UX","UY","UZ","Y","e","eps","T","k","h","DEFF"]
		for i in xrange(n-1):
			f = "X" + str(i+1)
			unknows.append(f)
		unknows.append("XN")
		for i in xrange(n-1):
			f = "T" + str(i+1)
			unknows.append(f)
		unknows.append("TN")
		
		for i in xrange(13+2*n):
			dofi = dofkey(node1,unknows[i])
			self.addToRHS(dofi,local[i])

	def getNewDofValue(self,node,name):
		dof = dofkey(node,name)
		if (dof in self._numbering.keys()):
			R   = self._numbering[dof]
			val = self._lsys.getFromNewSolution(R)
		else:
			val = self._fixed[dof]
		return val
	def getOldDofValue(self,node,name):
		dof = dofkey(node,name)
		if (dof in self._numbering.keys()):
			R   = self._numbering[dof]	
			val = self._lsys.getFromOldSolution(R)
		else:
			val = self._fixed[dof]
		return val
	def systemSolve(self):
		self._lsys.solve()
	def getSolution(self):
		return self._lsys.getSolution()

Hors ligne

#100 Le 26/03/2010, à 17:04

no_spleen

Re : Petit guide pour aider au choix d'un langage

le programme principal, qui ne fait que numéroter les variables

# -*- coding: utf8 -*- #
from geom import *
from mesh import *
from dof_manager import *

# Paramètres du problème

# nombre de noeuds dans les grains
n  = 10

# incrément d'espace dans les grains
dr = 0.0008

# incrément de temps 
dT = 10

#Températures de l'air à l'entrée
Ta = [50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50]

#Teneur en eau de l'air a l'entrée
Y  = 0.005

#Vitesse de l'air 
Va = 1.0

# Lecture du maillage
maillage   = mesh("lit.msh")

# Obtention des différents éléments
Entree_1  = maillage.getVerticesByTag(2,40)
Entree_2  = maillage.getVerticesByTag(2,29)
Entree_3  = maillage.getVerticesByTag(2,18)
Entree_4  = maillage.getVerticesByTag(2,95)
Entree_5  = maillage.getVerticesByTag(2,84)
Entree_6  = maillage.getVerticesByTag(2,66)
Entree_7  = maillage.getVerticesByTag(2,55)
Entree_8  = maillage.getVerticesByTag(2,44)
Entree_9  = maillage.getVerticesByTag(2,48)
Entree_10 = maillage.getVerticesByTag(2,36)
Entree_11 = maillage.getVerticesByTag(2,25)
Entree_12 = maillage.getVerticesByTag(2,14)
Entree_13 = maillage.getVerticesByTag(2,91)
Entree_14 = maillage.getVerticesByTag(2,80)
Entree_15 = maillage.getVerticesByTag(2,70)
Entree_16 = maillage.getVerticesByTag(2,59)
Entree_17 = maillage.getVerticesByTag(2,112)
Parois    = maillage.getVerticesByTag(2,601)
Sortie    = maillage.getVerticesByTag(2,602)
Elements  = maillage.getVerticesByTag(3,603)

# Assembleur

print "\n-Begining of assembler building-"
assem = dof_manager()

for i in xrange(17):
	Entree = "Entree_" + str(i+1)
	assem.fixVertices(Entree,"UX",0)
	assem.fixVertices(Entree,"UY",0)
	assem.fixVertices(Entree,"UZ",Va)
	assem.fixVertices(Entree,"T" ,Ta[i])
	assem.fixVertices(Entree,"Y" ,Y)

assem.fixVertices(Parois,"UX",0)
assem.fixVertices(Parois,"UY",0)
assem.fixVertices(Parois,"UZ",0)

assem.fixVertices(Sortie,"P",101325)

assem.numberVertices(Elements,"RHO")
assem.numberVertices(Elements,"P")
assem.numberVertices(Elements,"UX")
assem.numberVertices(Elements,"UY")
assem.numberVertices(Elements,"UZ")
assem.numberVertices(Elements,"Y")
assem.numberVertices(Elements,"e")
assem.numberVertices(Elements,"eps")
assem.numberVertices(Elements,"T")
assem.numberVertices(Elements,"k")
assem.numberVertices(Elements,"h")
assem.numberVertices(Elements,"YEQ")
assem.numberVertices(Elements,"DEFF")
assem.numberVertices(Elements,"X1")
for i in xrange(2,n):
	f = "X" + str(i)
	assem.numberVertices(Elements,f)
assem.numberVertices(Elements,"XN")

assem.numberVertices(Elements,"T1")
for i in xrange(2,n):
	f = "T" + str(i)
	assem.numberVertices(Elements,f)
assem.numberVertices(Elements,"TN")

print "-End of assembler building-\n"

Hors ligne

Haut de page ↑