Programmation
-
Analyse Numérique
- Analyse Numérique 1, Cours de I.Terrasse 1er semestre PDF-partie1 (Résultats Fondamentaux, v1.2) (Fait par Dimitri Nicolas (MACS 2009); année: 2007-2008) (le .TeX)
- TD 1 (auteur: C. Japhet ; année: 2007-2008)
- TD 2 (auteur: C. Japhet ; année: 2007-2008)
- TD 5 v2 / Correction TD 5 v4 (auteur: F. Cuvelier ; année: 2007-2008)
Analyse Appliquée
- Optique Géométrique, de J. Rauch 2eme semestre: Outline, Chapter1 (auteur: J. Rauch ; année: 2007)
- Fonctions holomorphes : PDF , TD1 (auteur : Dos Santos)
Calcul Parallèle
- Génie Logiciel , 1er semestre, PDF ( auteur: D'Afrany ; année: 2006-2007)
- Parallélisation des applications numériques, 1er semestre, PDF (auteur: d'Anfray ; année: 2004-2005)
- Computing with grids, PDF (auteur: d'Anfray ; année: 2007-2008)
- Calculateurs MIMD à mémoire distribuée : PDF (auteur : d'Anfray ; 2007-2008)
- Presentation MPI, 1er semestre (auteur: Juvigny ; année: 2007-2008)
- TD 1 parallélisme, 1er semestre TD1 (auteur: Anfray ; anée: 2007-2008)
- TD 2 parallélisme, 1er semestre TD2 & Sources (auteur: Anfray ; anée: 2007-2008)
- Projet parallélisme, 1er semestre Sources (auteur: Juvigny ; anée: 2007-2008)
- Transparents de parallélisation des applications numériques (d'Anfray) : PDF1 PDF2 PDF3 Support
Langage C++
- Langage objet, 1er semestre Objets C++ (auteur: d'Anfray ; année: 2006-2007)
- TD 1 C++, 1er semestre TD1 (auteur: Juvigny ; année: 2007-2008)
- TD 2 C++, 1er semestre PDF & Solution.tgz (auteur: Juvigny ; année: 2007-2008)
Architecture des calculateur
- Une introduction à l'architecture des calculateurs, P. d'Anfray : PDF
Langage C
- Cours d'introduction du professeur F. Cuvelier sur le compilateur gcc, les librairies, la commande make et le debuggeur GDB : OutilsProgrammation
- Cours sur les prioriétés en C du professeur F. Cuvelier : PDF
- Feuille de TP en C : TP-3 (F. Cuvelier)
- Cours de C du professeur d'Anfray Ph. sur le langage C : Polycopié de C
- Exercices sur le site du professeur D'Anfray.
Python
Cours de X. Juvigny sur le python : PDF
Ressources des TP de Juvigny et d'Anfray :Mécanique des fluides
- Formulaire de mécanique des fluides, 1er semestre, Formulaire (auteur: ?? ; année: 2007-2008)
- Cours de mécanique des fluides de M. Abdelmoula, 1er semestre, Mecanique des fluides (Fait par Dimitri Nicolas (MACS 2009) ; année: 2007-2008 ; v1.1) (Le .Tex)
Mécanique de rupture
- TD1 de mécanique de la rupture, 2ème semestre, TD1 (auteurs: I. Ionescu ; année: 2007-2008)
- Programmes FreeFem++ : ELASTICITE.tar.gz & PLASTICITE.tar.gz & ONDES.tar.gz(auteur: I. Ionescu ; année: 2007-2008)
- Cours de Mécanique : "Rupture et Platicité", PDF (auteurs: Pierre Suquet)
Optimisation
- Optimisation, 1er semestre, PDF (auteur: O. Lafitte ; année: 2007-2010)
- Recapitulation des notions du partiel 2007-2008 : PDF (Le .TeX) (année: 2007-2008)
Projets Numériques
- EDO1D: projet de résolution EDO en 1D , avec interfacage Matlab (auteur: F. Cuvelier)
- EDO1D-RK2: Correction de l'exercice: correction du bug, ajout de la méthode RK2 et multi-affichage pour comparer (Fait par Boillot Lionel, MACS 2009)
- Projet FEM1D : PDF & Source: projet de résolution EDP en 1D avec les éléments finis, en petsc avec interfacage Matlab ou Scilab (auteur: F. Cuvelier)
Systèmes Hyperboliques
- Introduction aux systèmes hyperboliques, F. Dubois 2eme semestre: PDF-v1.0, (Fait par Dimitri Nicolas (MACS 2009) ; année: 2007-2008 ; version 1.0) (Le .TeX)
- Introduction aux systèmes hyperboliques non linéaires , F. Dubois 2eme semestre: lien
Volumes finis
- Volumes Finis, J. Ryan 2eme semestre: PDF, (auteur: J. Ryan ; année: 2007-2008)
- Codes projet VF2D, J. Ryan 2eme semestre: TAR.GZ, (année: 2007-2008)
Distributions
- Introduction à la théorie des distributions, 2eme semestre, PDF (auteur: S. Kokh ; année 2006-2007)
- Cours de distributions : PDF (auteur : O. Lafitte)
- Distributions et applications, 2ème semestre, PDF (auteur: Lafitte ; année 2004-2005)
- Feuilles de Td de distributions : Feuille 0, Feuille 1, Feuille 2, Feuille 3, Feuille 4, (auteur: M. Zerzeri ; année 2006-2007)
Probabilités/Statistiques
- Processus stochastiques à temps discret, 1er semestre, PDF (auteurs: Bronner, Nualart ; année: 2007-2008)
Méthodes appliquées à l'ingénieur
- Presentation powerpoint : Partie1.2 ( auteur: Duceau , année: 2007-2008)
Management
- Management : Partie 1.2.ppt
Gestion
- Programmation Sous Matlab , C/C++,freefem++
- Méthode Numériques :
- Eléments finis
- volume finis
- différence finis
- A C++ finite element environment for solving partial differential equations
http://www-ljk.imag.fr/membres/Pierre.Saramito/rheolef/- programmation sous Freefem++ :
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
-
Documentation FreeFem++ (en anglais)
-
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++.
-
Exemple FreeFem++ écrit par le professeur C. Japhet
Installation
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 installL'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, …
Utilisation
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 <<exterieurs>>
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 <<trous>>
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;Visualisation 3D : Medit
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
Rheolef
(Pierre Saramito, Nicolas Roquet and Jocelyn Etienne ) 
Tous droits réservés