mise a jour python

TP-FEMM/src/accueil.md

 
 ## Modélisation & Simulation par EF des dispositifs magnétiques (BC7-EC2a ) : Travaux Pratiques sur le logiciel FEMM
 
-***Julien Fontchastagner - v 0.3 / mars 2021***
+***Julien Fontchastagner - v 0.4 / mars 2022***
  
 ---
 

TP-FEMM/src/bobine.md

@@ -16,7 +16,8 @@ Le but est de calculer le champ qu'elle produit, l'énergie correspondante, ains
 
 ## Définition du problème
 
-Pour commencer, on crée (au bon endroit) un fichier `bobine.m` par exemple, et on y rentre le préambule « classique » :
+Pour commencer, on crée (au bon endroit) un fichier `bobine.m` par exemple, et on y rentre le préambule « classique » :   
+* *MATLAB :*
 ```Matlab
 % Fichier bobine.m simulant la bobine du premier tuto avec FEMM
 close all 
@@ -25,8 +26,17 @@ clc
 
 addpath('C:\femm42\mfiles')
 ```
+* *Python :* 
+```Python
+# Fichier bobine.py simulant la bobine du premier tuto avec FEMM
 
+import numpy as np
+import femm
+```
+   
+   
 On ajoute les valeurs des paramètres :
+* *MATLAB :*
 ```Matlab
 % Donnes probleme
 R = 10; % mm
@@ -39,23 +49,49 @@ Ic = 5; % A
 Rdom = 5*sqrt((R+a)^2+(b/2)^2);  % Rayon du domaine
 ```
 
+* *Python :*
+```Python
+# Donnees du probleme
+R = 10.0 # mm
+a = 10.0 # mm
+b = 20.0 # mm
+N = 100
+Ic = 5.0 # A
+
+# Grandeurs annexes
+Rdom = 5*np.sqrt((R+a)**2+(b/2)**2)  # Rayon du domaine
+```
+
 On peut alors ouvrir FEMM :
 ```Matlab
 openfemm()
 ```
+ou
+```Python
+femm.openfemm()
+```
+
 
 > Remarque : Parfois, il peut être utile de démarrer FEMM en mode "minimisé" (pendant des procédés itératifs où on effectue plusieurs calculs de suite). On peut le faire directement par : `openfemm(1)` 
 
 
 Débutons un nouveau problème magnétique et spécifions ces propriétés :
+* *MATLAB :*
 ```Matlab
 newdocument(0)  % nouveau pbm magnetique
 mi_probdef(0,'millimeters','axi'); % frequence = 0, en mm, axisymetrique
 ```
+* *Python :*
+```Python
+femm.newdocument(0)  # nouveau pbm magnetique
+femm.mi_probdef(0,'millimeters','axi') # frequence = 0, en mm, axisymetrique
+```
+
 
 ### Géométrie 
 
 On peut ensuite passer à la création de la géométrie. C'est un simple rectangle : on crée les quatre sommets et les quatre côtés par :
+* *MATLAB :*
 ```Matlab
 % Definition de la geometrie
 %-------------------------------
@@ -71,21 +107,48 @@ mi_addsegment(R+a,b/2,R+a,-b/2);
 mi_addsegment(R+a,-b/2,R,-b/2);
 mi_addsegment(R,-b/2,R,b/2);
 ```
+* *Python :*
+```Python
+# Definition de la geometrie
+#-------------------------------
+# Creation des points (noeuds) :
+femm.mi_addnode(R,b/2)
+femm.mi_addnode(R+a,b/2)
+femm.mi_addnode(R+a,-b/2)
+femm.mi_addnode(R,-b/2)
+
+# Creation des segments :
+femm.mi_addsegment(R,b/2,R+a,b/2)
+femm.mi_addsegment(R+a,b/2,R+a,-b/2)
+femm.mi_addsegment(R+a,-b/2,R,-b/2)
+femm.mi_addsegment(R,-b/2,R,b/2)
+```
+
+
 
 > **Remarque :** Ceci est la façon la plus basique de procéder, on aurait pu utiliser des fonctions plus évoluées comme `mi_drawpolyline`, `mi_drawpolygon` ou, encore mieux dans notre cas, `mi_drawrectangle`. Pour notre rectangle, on aurait donc pu faire :
-> 1. `mi_drawpolyline([R,b/2;R+a,b/2;R+a,-b/2;R,-b/2;R,b/2]);`
-> 2. `mi_drawpolygon([R,b/2;R+a,b/2;R+a,-b/2;R,-b/2]);`
-> 3. `mi_drawrectangle(R,b/2,R+a,-b/2);`   
+> 1. `mi_drawpolyline([R,b/2;R+a,b/2;R+a,-b/2;R,-b/2;R,b/2])`
+> 2. `mi_drawpolygon([R,b/2;R+a,b/2;R+a,-b/2;R,-b/2])`
+> 3. `mi_drawrectangle(R,b/2,R+a,-b/2)`   
 > 
 > Ce qui est évidemment beaucoup plus compact...
 
 Pour le domaine d'air environnant, nous allons définir un demi-disque de rayon `Rdom` :
+* *MATLAB :*
 ```Matlab
 mi_drawline(0,-Rdom,0,Rdom);
 mi_addarc(0,-Rdom,0,Rdom,180,5);  % arc de 180°, ligne brisee avec 5° de
-									% largeur angulaire pour chaque segment
+								  % largeur angulaire pour chaque segment
 mi_zoomnatural;  % recentrer l'affichage
 ```
+* *Python :*
+```Python
+femm.mi_drawline(0,-Rdom,0,Rdom)
+femm.mi_addarc(0,-Rdom,0,Rdom,180,5)  # arc de 180°, ligne brisee avec 5° de
+                                      # largeur angulaire pour chaque segment
+femm.mi_zoomnatural()  # recentrer l'affichage
+```
+
 
 ### Physique et maillage
 
@@ -96,6 +159,7 @@ Pour définir les matériaux, nous avons 2 façons de procéder :
 2. Soit utiliser ceux de la bibliothèque intégrée à FEMM et les importer avec `mi_getmaterial`.
 
 Nous allons utiliser les deux :
+* *MATLAB :*
 ```Matlab
 % Definition de la physique
 %-------------------------------
@@ -106,14 +170,34 @@ mi_getmaterial('Copper');   % recuperation du cuivre
 mi_modifymaterial('Copper',0,'Cuivre') % renommage 
 ```
 
+* *Python :* 
+```Python
+# Definition de la physique
+#-------------------------------
+
+# Materiaux
+femm.mi_addmaterial('Air',1,1)   # creation de l'air (murx = mury = 1)
+femm.mi_getmaterial('Copper')    # recuperation du cuivre
+femm.mi_modifymaterial('Copper',0,'Cuivre')   # renommage 
+```
+
+
+
 > `mi_addmaterial` permet de définir toutes les caractéristiques physiques du matériau (perméabilité relative, champ coercitif, conductivité électrique, etc...). Je vous encourage à regarder dans le fichier d'aide toutes les possibilités.
 
 Il nous faut également définir le courant source circulant dans la bobine :
+* *MATLAB :*
 ```Matlab
 mi_addcircprop('I',Ic,1); % creation d'un circuit 'I' portant Ic ampères en série
 ```
+* *Python :*
+```Python
+femm.mi_addcircprop('I',Ic,1)   # creation d'un circuit 'I' portant Ic ampères en série
+```
+
 
 Il nous reste à affecter chaque matériau à sa région :
+* *MATLAB :*
 ```Matlab
 % taille d'elements dans regions
 taille_elt_cuivre = a/5;  % taille d'element globale dans bobine
@@ -128,10 +212,28 @@ mi_selectlabel(Rdom/2,0);
 mi_setblockprop('Air',0,taille_elt_air,0,0,1,0);
 mi_clearselected;
 ```
+* *Python :*
+```Python
+# taille d'elements dans regions
+taille_elt_cuivre = a/5  # taille d'element globale dans bobine
+taille_elt_air = Rdom/10 #   -------------------  dans le domaine
+
+femm.mi_addblocklabel(R+a/2,0)
+femm.mi_selectlabel(R+a/2,0)
+femm.mi_setblockprop('Cuivre',0,taille_elt_cuivre,'I',0,2,N) # le 2 est le n° du groupe
+femm.mi_clearselected()
+femm.mi_addblocklabel(Rdom/2,0)
+femm.mi_selectlabel(Rdom/2,0)
+femm.mi_setblockprop('Air',0,taille_elt_air,0,0,1,0)
+femm.mi_clearselected()
+```
+
+
 
 > **Remarque :** En procédant de cette manière, FEMM imposera ainsi une densité de courant équivalente \\(j_\theta = \frac{N\\,I_c}{a\\\,b}\\) dans la bobine. 
 
 Nous avons également défini ici une taille globale d'éléments dans les deux régions. Nous aurions pu laisser le logiciel choisir tout seul une discrétisation, mais je préfère le contrôler moi-même. Nous allons donc également en profiter pour choisir une discrétisation des lignes de la bobine et de celle sur l'axe :
+* *MATLAB :*
 ```Matlab
 mi_selectsegment(R,0);
 mi_selectsegment(R+a,0);
@@ -143,6 +245,18 @@ mi_selectsegment(0,0);
 mi_setsegmentprop(0,taille_elt_air,0,0,2); % le 2 est le n° du groupe
 mi_clearselected;
 ```
+* *Python :*
+```Python
+femm.mi_selectsegment(R,0)
+femm.mi_selectsegment(R+a,0)
+femm.mi_selectsegment(R+a/2,b/2)
+femm.mi_selectsegment(R+a/2,-b/2)
+femm.mi_setsegmentprop('',taille_elt_cuivre,0,0,2)  # le 2 est le n° du groupe
+femm.mi_clearselected()
+femm.mi_selectsegment(0,0)
+femm.mi_setsegmentprop('',taille_elt_air,0,0,2)  # le 2 est le n° du groupe
+femm.mi_clearselected()
+```
 
 
 #### Condition à la frontière
@@ -151,6 +265,7 @@ Comme dit précédemment la condition par défaut est un champ normal à la fron
 
 Puisque la frontière est choisie suffisamment loin pour considérer qu'il n'y a plus d'influence des sources, on imposera : \\(a_\theta = 0\\).
 
+* *MATLAB :*
 ```Matlab
 mi_addboundprop('a=0',0,0,0,0); % creation d'une CL de type Dirichlet homogene
 mi_selectarcsegment(Rdom,0);         % selection du bord
@@ -158,23 +273,43 @@ mi_setarcsegmentprop(5,'a=0',0,1);  % affectation
 		% (le 5 est la largeur angulaire des segments de la ligne brisee
 		% representant l'arc)
 ```
+* *Python :*
+```Python
+emm.mi_addboundprop('a=0',0,0,0,0)  # creation d'une CL de type Dirichlet homogene
+femm.mi_selectarcsegment(Rdom,0)         # selection du bord
+femm.mi_setarcsegmentprop(5,'a=0',0,1)   # affectation 
+        # (le 5 est la largeur angulaire des segments de la ligne brisee
+        # representant l'arc)
+```
+
 
 
 ### Résolution
 
 Une fois que tout est bien défini, il ne reste plus qu'à enregistrer notre fichier `*.FEM`, mailler et résoudre :
 
+* *MATLAB :*
 ```Matlab
 mi_saveas('bobine.FEM');
 mi_analyze();
 ```
+* *Python :*
+```Python
+femm.mi_saveas('bobine.FEM')
+femm.mi_analyze()
+```
 
 ### Post-traitement
 
 Pour visualiser la solution, on charge le fichier résultat par :
+* *MATLAB :*
 ```Matlab
 mi_loadsolution;
 ```
+* *Python :*
+```Python
+femm.mi_loadsolution()
+```
 
 On entre alors dans le post-processeur et toutes les commandes commenceront désormais par le préfixe `mo_`.
 
@@ -211,6 +346,7 @@ On obtient alors le flux total embrassé par la bobine \\(\phi\\) en multipliant
 \\[\phi = \frac{2\\,\pi\\,N}{S_{bob}} \iint_{S_{bob}} r\\,a_\theta(r,z)\\,\text{d}r\\,\\text{d}z\\]
 
 Appliquons cela dès maintenant :
+* *MATLAB :*
 ```Matlab
 mo_selectblock(R+a/2,0);  % selection du bloc "bobine"
 S_bob = mo_blockintegral(5); % calcul de la section (alternative à a*b)
@@ -219,8 +355,18 @@ Integ = mo_blockintegral(1);  % valeur de 2*pi*terme integral du flux moyen
 phi = N*Integ/S_bob;
 mo_clearblock;  % deselection du block
 ```
+* *Python :*
+```Python
+femm.mo_selectblock(R+a/2,0)  # selection du bloc "bobine"
+S_bob = femm.mo_blockintegral(5) # calcul de la section (alternative à a*b)
+                            # utile si sections complexes
+Integ = femm.mo_blockintegral(1) # valeur de 2*pi*terme integral du flux moyen
+phi = N*Integ/S_bob
+femm.mo_clearblock() # deselection du block
+```
 
 On en déduit directement l'inductance par \\(\phi = L\\,I_c\\) :
+* *MATLAB :*
 ```Matlab
 L = phi/Ic;
 disp(' Resultats');
@@ -228,6 +374,14 @@ disp('-----------------');
 disp('');
 disp(['Inductance de la bobine (flux) : ',num2str(L*1e6),' µH']);
 ```
+* *Python :*
+```Python
+L = phi/Ic
+print("")
+print(" Resultats")
+print("-----------------")
+print(" Inductance de la bobine via le flux %.3f µH" %(L*1e6) )
+```
 
 #### Calcul de l'énergie et la coénergie magnétiques
 
@@ -235,6 +389,7 @@ On peut également calculer l'énergie magnétique \\(W_\text{mag}\\) ou la coé
 
 \\[ w_{\text{mag}} = \frac{1}{2\\,\mu_0} |\\!|{\bf b}|\\!|^2 , ~ ~\text{et}~ ~ \widetilde{w}_{\text{mag}} = \frac{1}{2}\\,\mu_0\\, |\\!|{\bf h}|\\!|^2 \\]
 
+* *MATLAB :*
 ```Matlab
 mo_groupselectblock();   % astuce pour selectionner tous les blocs :
 						% on utilise une selection par groupe sans numero
@@ -244,19 +399,36 @@ mo_clearblock;
 disp(['Energie : ',num2str(Wmag*1e3),' mJ']);
 disp(['Coenergie : ',num2str(coWmag*1e3),' mJ']);
 ```
+* *Python :*
+```Python
+femm.mo_groupselectblock()   # astuce pour selectionner tous les blocs :
+                        # on utilise une selection par groupe sans numero
+Wmag = femm.mo_blockintegral(2)
+coWmag = femm.mo_blockintegral(17)
+femm.mo_clearblock()
+print(" Energie : %.3f mJ" %(Wmag*1e3) )
+print(" Coenergie : %.3f mJ" %(coWmag*1e3) )
+```
 
 Puisque nous sommes en **régime linéaire**, on peut également calculer l'inductance par l'énergie : \\[W_\text{mag} = \frac{1}{2} L\\,I_c^2\\]
 
+* *MATLAB :*
 ```Matlab
 Lbis = 2*Wmag/Ic^2;
 disp(['Inductance via l''energie : ',num2str(Lbis*1e6),' µH']);
 ```
+* *Python :*
+```Python
+Lbis = 2*Wmag/Ic**2
+print(" Inductance via l'energie : %.3f µH" %(Lbis*1e6) )
+```
 
 En linéaire, nous avons également : 
 
 \\[\displaystyle W_{\text{mag}} = \iiint\limits_{\text{domaine}} \frac{1}{2}\\,{\bf b}\cdot{\bf h}\\,\text{d} V = \frac{1}{2} \iiint\limits_{\text{sources}} {\bf a}\cdot{\bf j}\\,\text{d}V  \\]
 
 On peut donc également utiliser cette formule :
+* *MATLAB :*
 ```Matlab
 mo_selectblock(R+a/2,0); 
 Wmagbis = 0.5*mo_blockintegral(0); 
@@ -265,6 +437,18 @@ Lbisbis = 2*Wmagbis/Ic^2;
 disp(['Energie bis : ',num2str(Wmagbis*1e3),' mJ']);
 disp(['Inductance via l''energie bis: ',num2str(Lbisbis*1e6),' µH']);
 ```
+* *Python :*
+```Python
+Lbis = 2*Wmag/Ic**2
+print(" Inductance via l'energie : %.3f µH" %(Lbis*1e6) )
+femm.mo_selectblock(R+a/2,0) 
+Wmagbis = 0.5*femm.mo_blockintegral(0)
+femm.mo_clearblock()
+Lbisbis = 2*Wmagbis/Ic**2
+print(" Energie bis : %.3f mJ" %(Wmagbis*1e3) )
+print(" Inductance via l'energie bis: %.3f µH" %(Lbisbis*1e6) )
+```
+
 
 Au final, on obtient les résultats suivants :
 ```

TP-FEMM/src/bonnes_pratiques.md

@@ -5,18 +5,18 @@
 
 1. Pensez à créer dans votre compte un **dossier de travail** (du genre `TP_FEMM`) et différents sous-dossiers pour chaque sujet. Depuis les salles infos, le mieux est d'utiliser un répertoire local dans `C:\Temp\` et de **penser à récupérer ce qu'il contient à la fin de la séance**.   
 
-2. Pensez à commencer votre programme principal par un bon nettoyage : 
+2. **Pensez à indenter et commenter vos programmes.**
+
+3. Avec MATLAB, pensez à commencer votre programme principal par un bon nettoyage : 
 	```Matlab
 	close all 	% fermeture de toutes les fenetres ouvertes
 	clear 		% suppression de toutes les variables
 	clc 		% purge du terminal de commande
 	```
 
-3. **Pensez à indenter et commenter vos programmes.**
-
-
+ 
 
-## FEMM
+## FEMM + MATLAB
 
 1. **Passerelle avec MATLAB :**   
 	Dans MATLAB, ajoutez (en début de programme) le chemin vers le dossier contenant les fonctions permettant de piloter FEMM :   
@@ -28,12 +28,25 @@
 	% l'interface graphique ou la commande :
 	% savepath(...)
 	```
-	
-
+		
 2. Toutes les commandes dont vous allez avoir besoin se trouvent dans un document PDF très pratique : **`octavefemm.pdf`**. **Vous devez absolument l'avoir avec vous pendant les séances de TP :** 
 	* Vous le trouverez dans le dossier `C:\femm42`. 
 	* Ou vous pouvez le télécharger directement depuis le [site web](https://www.femm.info/wiki/Files/files.xml?action=download&file=octavefemm.pdf).
 
+## FEMM + Python
+
+1. **Passerelle avec Python :**    
+	Importez le module [PyFEMM](https://www.femm.info/wiki/pyFEMM/) (ainsi que NumPy et de quoi tracer des courbes) :
+	```Python
+	import femm
+	import numpy as np
+	import matplotlib.pyplot as plt
+	```
+	
+2. Toutes les commandes dont vous allez avoir besoin se trouvent dans un document PDF très pratique : **`pyfemm-manual.pdf`**. **Vous devez absolument l'avoir avec vous pendant les séances de TP :** 
+	* Vous le trouverez dans le dossier `C:\femm42`. 
+	* Ou vous pouvez le télécharger directement depuis le [site web](https://www.femm.info/wiki/pyFEMM/manual.pdf).
+
 <br/>
 
 

TP-FEMM/src/intro.md

@@ -15,7 +15,9 @@ Il peut résoudre des problèmes en :
 Pour nous, ses principaux points forts seront :
 * sa facilité d'utilisation ;
 * le fait qu'il soit dédié aux problématiques du Génie Électrique ;
-* sa très bonne intégration avec des logiciels de calcul scientifique : GNU Octave / MATLAB, Scilab ou encore Mathematica.
+* sa très bonne intégration avec : 
+	* des logiciels de calcul scientifique : **GNU Octave / MATLAB**, Scilab ou encore Mathematica.
+	* des langages de programmation : **Python** ou Lua.
 
 Ses principaux inconvénients sont :
 * l'absence de résolution magnétique en transitoire et donc de couplage circuit ;
@@ -25,7 +27,7 @@ Ses principaux inconvénients sont :
 
 ## But des Travaux Pratiques 
 
-L'objectif des séances de TP est de vous apprendre à définir proprement des problèmes de **magnétostatique** et **magnétoharmonique** dans FEMM et les résoudre. Nous privilégierons l'utilisation des fonctionnalités de scriptage via MATLAB, compte-tenu que vous connaissez déjà ce logiciel de calcul numérique. 
+L'objectif des séances de TP est de vous apprendre à définir proprement des problèmes de **magnétostatique** et **magnétoharmonique** dans FEMM et les résoudre. Nous privilégierons l'utilisation des fonctionnalités de **scriptage via MATLAB** (compte-tenu que vous êtes sensés déjà connaître ce logiciel de calcul numérique), **ou Python** pour ceux qui préfèrent. 
 
 À l'issue des séances, vous devriez connaître les bases et certaines particularités de FEMM, et être capables de l'utiliser par la suite pour résoudre des problèmes plus compliqués ou relevant d'autres physiques. 
 
@@ -34,18 +36,49 @@ L'objectif des séances de TP est de vous apprendre à définir proprement des p
 
 Les sujets ne sont pas calibrés pour correspondre à une séance particulière. **Il faut voir l'ensemble des 12 heures prévues comme un unique micro-projet** dans lequel seront traités les différents énoncés. 
 
-Les séances se dérouleront en salle informatique à l'ENSEM  où les deux logiciels (FEMM et MATLAB) sont installés par défaut sur tous les postes.
+Les séances se dérouleront en salle informatique à l'ENSEM  où tout ce qui faut est installé par défaut sur les postes de travail (FEMM, MATLAB, Python).
 
 **Si, malheureusement, nous étions obligés d'effectuer les séances en mode « distanciel » via visioconférence : FEMM et MATLAB sont accessibles depuis le portail [Virt'UL](https://virtul.univ-lorraine.fr)**. 
 
 > **Remarque :** Vous pouvez également installer sur votre PC personnel :
 > * MATLAB avec la license campus de l'UL en suivant les [instructions du WikiDocs](https://wikidocs.univ-lorraine.fr/display/dnsudocoffsoft/La+licence+Matlab+pour+les+Etudiants)
 > * FEMM à partir de son site web [https://www.femm.info](https://www.femm.info/wiki/Download)
-> 
-> **Note pour les éventuels linuxiens :** vous devrez installer FEMM avec [Wine](https://www.winehq.org/), utiliser [GNU Octave](https://www.gnu.org/software/octave/index) au lieu de MATLAB, et modifier les fichiers `openfemm.m` et `callfemm.m`. [**Voir ici**](https://www.femm.info/wiki/LinuxSupport).    
-	Je vous donne une version des deux fichiers à utiliser (et à copier dans `~/.wine/drive_c/femm42/mfiles/`) :[`openfemm.m`](./fichiers/openfemm.m) et [`callfemm.m`](./fichiers/callfemm.m).  Demandez-moi comment faire si besoin (c'est mon mode d'utilisation par défaut).
-> 
-> **Note (bis) pour les maceux :** il vous faudra procéder comme les linuxiens : [Wine](https://wiki.winehq.org/MacOS)+FEMM combiné avec [GNU/Octave](https://wiki.octave.org/Octave_for_macOS).  
+> * Python à partir de son site web [https://www.python.org](https://www.python.org/downloads/), puis le module [PyFEMM](https://www.femm.info/wiki/pyFEMM/) via pip :
+> `pip3 install pyfemm` 
+> * GNU Octave (en remplacement de MATLAB) à partir de son [site web](https://www.gnu.org/software/octave/index)
+
+> **Note pour les éventuels linuxiens :** 
+> 1. Vous devrez installer FEMM avec [Wine](https://www.winehq.org/), la dernière version stable (avril 2019) fonctionne parfaitement (y compris en 64-bits), testée sans problème sous [Debian](https://www.debian.org/) ou [Void](https://voidlinux.org/). Demandez-moi comment faire si besoin.
+> 2. Il vous faudra utiliser [GNU Octave](https://www.gnu.org/software/octave/index) au lieu de MATLAB, et modifier les fichiers `openfemm.m` et `callfemm.m`. [**Voir ici**](https://www.femm.info/wiki/LinuxSupport).    
+	Je vous donne une version des deux fichiers à utiliser (et à copier dans `~/.wine/drive_c/femm42/mfiles/`) :[`openfemm.m`](./fichiers/openfemm.m) et [`callfemm.m`](./fichiers/callfemm.m). Demandez-moi comment faire si besoin (c'est mon mode d'utilisation par défaut).
+> 3. Pour ceux qui préfère Python, le module [PyFEMM](https://www.femm.info/wiki/pyFEMM/) fonctionne parfaitement *out of the box*, testé sans problème sous [Debian](https://www.debian.org/) ou [Void](https://voidlinux.org/). 
+>  
+> **Note (bis) pour les maceux :** il vous faudra procéder comme les linuxiens : [Wine](https://wiki.winehq.org/MacOS)+FEMM combiné avec [GNU/Octave](https://wiki.octave.org/Octave_for_macOS) ou Python. Si vous rencontrez des problèmes, utilisez une machine virtuelle Linux.  
+
+
+> **Pour résumé, voici les différents modes d'utilisation disponibles et possibles :**
+> 1. **FEMM + MATLAB :** 
+> 	* [x] Salles infos 
+> 	* [x] Virt'UL
+> 	* [x] PC personnel sous : 
+> 		* [x] Windows
+> 		- [ ] Linux
+> 		- [ ] MacOS
+> 2. **FEMM + Python (PyFEMM) :**		
+> 	* [x] Salles infos 
+> 	* [ ] Virt'UL
+> 	* [x] PC personnel sous : 
+> 		* [x] Windows
+> 		* [x] Linux
+> 		* [x] MacOS
+> 3. **FEMM + GNU/Octave :**
+> 	* [x] Salles infos 
+> 	* [ ] Virt'UL
+> 	* [x] PC personnel sous : 
+> 		* [x] Windows
+> 		* [x] Linux
+> 		* [x] MacOS
+
 
 
 ## Modalités d'évaluation

TP-FEMM/src/tuto.md

@@ -62,10 +62,9 @@ Le fonctionnement du logiciel suit donc les étapes classiques d'un logiciel de
 	* Pertes Joule ;
 	* Flux ;
 	* Forces et couple. 
+ 
 
-> **Remarque 1 :** Dans FEMM, l'étape de maillage et de résolution sont regroupées dans une même instruction, on est donc toujours obligé de remailler pour résoudre. 
-
-> **Remarque 2 :** Les étapes de preprocessing et postprocessing sont très clairement dissociées dans FEMM et apparaissent chacune dans deux onglets différents : 
+> **Remarque :** Les étapes de preprocessing et postprocessing sont très clairement dissociées dans FEMM et apparaissent chacune dans deux onglets différents : 
 > 	* le premier lié au fichier de description du problème en **.FEM*.   
 En mode "script", toutes les instructions s'y rapportant commenceront par le préfixe **`mi_`**.   
 >

TP-FEMM/src/ventouse.md

@@ -24,7 +24,7 @@ Une représentation schématique du dispositif est alors :
 
 ## Premières simulations en régime linéaire 
 
-**➤ Créez le script MATLAB permettant de résoudre ce problème en linéaire.** 
+**➤ Créez le script MATLAB ou Python permettant de résoudre ce problème en linéaire.** 
 
 Les valeurs des paramètres sont données par la table suivante :
 
@@ -39,10 +39,16 @@ Les valeurs des paramètres sont données par la table suivante :
 | Ic | A | 0,5 |
 | N | - | 250 |
 
-> **Remarque :** Pensez à définir votre problème comme 2D cartésien de profondeur Lz :
+> **Remarque :** Pensez à définir votre problème comme 2D cartésien de profondeur Lz.   
+>     
+> En MATLAB :
 > ```Matlab
 > mi_probdef(0,'millimeters','planar',1e-8,Lz);  % 1e-8 = precision du solveur
 > ```
+> En Python :
+> ```Python
+> femm.mi_probdef(0,'millimeters','planar',1e-8,Lz) # 1e-8 = precision du solveur
+> ```
 
 Et les matériaux magnétiques sont définis par celle-ci :