Intro FreeFem++

Envoyer Imprimer PDF

FreeFem ++

FreeFem++ est un logiciel libre écrit en C++. Il s'exécute en ligne de commande ou en mode graphique. Il permet de créer des maillages ainsi que de résoudre des EDP par différentes méthodes d'éléments finis.

Les sites officiels:

Freefem++ sera surtout utilisé pour la création de maillage 2D lors de la résolution d'EDP. Voici un exemple d'un maillage + résolution avec FreeFem++ sur le condensateur:
documents.lamacs.fr_programmation_freefemm_condensateur.jpg

  • PDF du professeur F.Cuvelier présentant la résolution d'EDP en 2D ainsi qu'une parti sur comment se fait et lit le maillage ".msh" de FreeFem++.

Pour l'installer il suffit de compiler les sources à partir du site officiel FreeFem++. (lire le README et/ou INSTALL concernant votre système d'exploitation avant).

./configure --without-fltk
make
sudo make install

L'option –without-fltk permet de ne pas installer l'EDI inclus dans ce paquet. C'est une ancienne version qui n'est plus mise à jour (contient des bugs).

Si vous avez des problèmes de librairies, surtout pour X11, vous pouvez installer une version sans affichage des graphes (il suffira de les ouvrir à la souris après les avoir enregistrés dans votre répertoire de travail) : FreeFem++-nw. Pour cela, ajoutez l'option –without-x.

Pour installer l'EDI (Environnement de Développement intégré), il faut télécharger le paquet du site officiel FreeFem++-cs (EDI). Pour ceux qui ont des problèmes de librairies il existe même une version avec les sources précompilées (ou quasiment) en linux-32bits. L'avantage c'est que les graphes s'affichent directement à côté du code, les fautes de frappes sont surlignées en rouge, …

documents.lamacs.fr_programmation_freefem_freefem-cs.jpg

Pour utiliser FreeFem++ il faut soit ouvrir l'EDI, soit créer un fichier texte "equation.edp" (par exemple) qui contient les commandes FreeFem++, il suffit ensuite d'exécuter ce fichier avec FreeFem++ en ligne de commande :

  FreeFem++ -f equation.edp

ou

  FreeFem++-nw equation.edp

Le langage utilisé dans le fichier texte par FreeFem++ est proche du C++. Le plus simple pour comprendre est de regarder l'exemple FreeFem++ écrit par le professeur C. Japhet.

Commandes

Pour définir une fonction :

// Fonction 'phi' qui prend en argument un réel et qui retourne un réel
func real phi(real t)
{
return cos(t)+9*t;
}

Mots clefs : func, real et return.

ou directement en utilisant les mots réservés 'x' et 'y' :

func f = sin(x)*cos(y):
func g = (x^2+3*y^2)*exp(1-x^2-y^2);
func h = max(-0.5,0.1*log(f^2+g^2));

Les maillages

Pour définir un maillage :

// on suppose que l'on a défini les deux fonctions 'phix' et 'phiy' comme ci-dessus
 
//on définit le bord de nom 'C' par une équation paramétrique :
border C(t=0,2*Pi){ x= phix(t) ; y=phiy(t) ; label = 1}
// t varie de 0 à 2*Pi --> 'x' et 'y' prennent alors le valeures correspondantes.
//le 'label' permet de numéroter le bord construit : ici 'C' est le bord numero 1.
 
//on construit le maillage à l'aide de 'buildmesh'
//le maillage sera de nom 'Th' et construit avec 50 points de discrétisation du bord.
mesh Th = buildmesh ( C(50) );

Mots clefs : border, mesh et buildmesh.

Pour sauvegarder le maillage :

//sauvegarde du maillage sous le nom souhaité dans le repertoire courant.
savemesh(Th,"nom_maillage.msh");

Pour lire un maillage :

//lecture du maillage du repertoire courant.
mesh Th2 = readmesh("nom_maillage.msh");

Mots clefs : mesh et readmesh.

Résolution d'EDP

Utilisation des EF :

//on definit le type d'EF que l'on utilise sur le maillage Th :
fespace Vh(Th,P1);
 
//on projete la fonction f sur le maillage EF. La projection est 'fh' :
Vh fh = f;
 
//on trace les isovaleurs de la projection 'fh' sur le maillage et o sauvegarde le resultat en .eps :
plot(fh,wait=1,ps="nom.eps");

Résolution d'EDP :

Pour résoudre une EDP il faut connaître la formulation variationnelle faible du problème que l'on veut résoudre. Par exemple pour résoudre le laplacien=0 avec comme condition au bord un dirichlet homogène : la formulation variationnelle faible est : int grad(u)*grad(v) = 0 , + CL . Avec freefem cela donne :

mesh Th2=readmesh("nom_maillage.msh");
fespace Vh2(Th2,P1);
//Vh2 est la mathode des EF P1.
Vh2 u,v;
 
//on resout le probleme sur le maillage :
solve pb(u,v) = int2d(Th2)(dx(u)*dx(v)+dy(u)*dy(v))+int2d(Th2)(0)+on(1,u=0);
// --> int2d : donne a freefem les informations 2 dimensions de la formulation faible pour le membre de gauche
// --> int2d : pareil mais pour le second membre
// --> on : ajout des conditions aux limites sur le bord concerné
 
//tracé de la solution sur le maillage :
plot(Th2,u);

Exemple Resolution

Voici un exemple de fichier ".edp" qui resoud une EDP. (Réalisé par le professeur C. Japhet )(Le fichier : Exemple FreeFem++)

// MAILLAGE
// Donnees pour generer le maillage
real R=1.0;
real Ri=0.2;
real theta=3*pi/4;

// Centres des deux trous
real C1x=0.5*cos(theta),C1y=0.5*sin(theta);
real C2x=0.5*cos(pi+theta),C2y=0.5*sin(pi+theta);

// Definition des bords <>
border cercle1(t=0,pi/2)
{x=R*cos(t);y=R*sin(t);label=1;};
border cercle2(t=pi/2,pi)
{x=R*cos(t);y=R*sin(t);label=2;};
border cercle3(t=pi,3*pi/2)
{x=R*cos(t);y=R*sin(t);label=3;};
border cercle4(t=3*pi/2,2*pi)
{x=R*cos(t);y=R*sin(t);label=4;};

// Definition des deux <>
border trou1(t=0,2*pi)
{x=C1x+Ri*cos(t);y=C1y+Ri*sin(t);label=5;};
border trou2(t=0,2*pi)
{x=C2x+Ri*cos(t);y=C2y+Ri*sin(t);label=6;};

// Nombre de discretisation de chaque bord
int N=3;
cout << "N=";
cin >> N;

// Generation du maillage
mesh Th = buildmesh (cercle1(N)+cercle2(N)+cercle3(N)+cercle4(N)+trou1(-N)+trou2(-N));
// FIN MAILLAGE

// DESCRIPTION EDP
// Elements finis utilises
fespace Vh(Th,P1);
// Donnees de l'EDP
func px=x+y;
func py=x-y;
func a0=exp(-(x*x+y*y));
func a1=3+(x-y)*(x+y);
func f=cos(x+y);
func gD=x*y;
func gN=x+y;
func gR=sin(x-y);

// Description du probleme sous forme variationnelle
Vh uh,vh;
problem FV(uh,vh,solver=GMRES,tgv=1e5) =
int2d(Th)( a0*uh*vh+ dx(uh)*dx(vh) + dy(uh)*dy(vh) )
+ int2d(Th)( dx(px*uh)*vh+ dy(py*uh)*vh )
+ int1d(Th,2,4)( a1*uh*vh )

- int2d(Th)( f*vh )
- int1d(Th,1,3)( gN*vh )
- int1d(Th,2,4)( gR*vh )
+ on(5,6,uh=gD) ;

// Resolution du probleme
FV;

// Representation du maillage
plot(Th,ps="ExempleFreeFEM_"+N+"_mesh.eps",value=true,wait=true);
// Representation de la solution approchee
plot(uh,ps="ExempleFreeFEM_"+N+"_sol.eps",value=true,wait=true);

// Sauvegarde du maillage
savemesh(Th,"ExempleFreeFEM_"+N+".msh");

// Sauvegarde de la solution approchee
ofstream file("ExempleFreeFEM_"+N+".txt");
file << uh[] << endl;

FreeFem++ permet de visualiser ses résultats en 2d avec des isovaleurs et/ou des couleurs. Pour visualiser en 3d on peut utiliser par exemple medit.

Voici un lien pour télécharger medit : Medit. Sur ce même lien il y a une documentation en anglais.

Utilisation sous linux

Il n'est pas nécessaire d'installer à proprement parler "medit". Après avoir téléchargé "Medit for linux" sur la page il faut le décompresser. On extrait alors un executable "medit-2.3-linux". Renommons le "medit" pour plus de commodité. On lui permet ensuite de s'executer : bouton droit–> propriétés–> permission –> autoriser l'execution du fichier comme un programme ou bien en ligne de commande :

chmod a+x medit

Ensuite il y a deux manières de procéder :

Première maniere :

Mettre l'executable "medit" dans le dossier "/usr/bin" là ou se trouve les executables. La commande pour ce faire est :

sudo cp medit /usr/bin

Medit est donc "installé".

Deuxieme maniere :

Placer l'executable "medit" dans son dossier de travail, et lorsqu'on appelera medit depuis un fichier freefem il faudra taper le chemin complet de l'emplacement de l'executable "medit" pour pouvoir l'utiliser.

Voici un exemple d'utilisation de base trouvé dans la documentation freefem :

mesh Th=square(10,10,[2*x-1,2*y-1]);
fespace Vh(Th,P1);
Vh u=2-x*x-y*y;
savemesh(Th,"mm",[x,y,u*.5]); // save mm.points and mm.faces file
// for medit
// build a mm.bb file
{ ofstream file("mm.bb");
file << "2 1 1 "<< u[].n << " 2 \n";
for (int j=0;j> file << u[][j] << endl;
}

exec("medit mm");// call medit command
exec("rm mm.bb mm.faces mm.points");// clean files on unix OS
Mise à jour le Samedi, 30 Janvier 2010 18:34