Programmation d'un graphique 3D

Fermé
xyxy12 Messages postés 17 Date d'inscription vendredi 29 juillet 2011 Statut Membre Dernière intervention 23 octobre 2015 - Modifié par Whismeril le 22/10/2015 à 22:42
xyxy12 Messages postés 17 Date d'inscription vendredi 29 juillet 2011 Statut Membre Dernière intervention 23 octobre 2015 - 23 oct. 2015 à 10:12
Bonjour !
Voilà, je dois programmer une affichage graphique 3D d'une fonction à partir des coordonnées d'un vecteur en gros. Tout va bien sur tous les calculs qui précèdent, mais ça coince sur la création du graphique.. Le fait est que j'essaie de traduire un programme Scilab en Python, et je bloque sur cette partie.. Voilà le programme initial : 

valeurPropreSelection=valeursPropres(valeurPropreAffichee); vecteurPropreSelection=vecteursPropres(:,valeurPropreAffichee) 
k=1;
X=[];
for i=1:n 
     X(i)=(i-1)*a 
     for j=1:n
       Deform(i,j)=vecteurPropreSelection(k);
       k=k+1; end
     end
clf 
surf(X,X,abs(Deform))


Si quelqu'un sait comment faire de ça un programme viable sur Python, merci d'avance !

EDIT : Ajout des balises de code (la coloration syntaxique).
Explications disponibles ICI

Merci d'y penser dans tes prochains messages.
A voir également:

2 réponses

Réponse 1 / 2
dsy73 Messages postés 9252 Date d'inscription dimanche 22 août 2010 Statut Contributeur Dernière intervention 23 octobre 2020 2 485
23 oct. 2015 à 07:19
Salut
Tu devrais expliquer le code et montrer ce que tu as fait en Python (coloration syntaxique obligatoire !)
0
Réponse 2 / 2
xyxy12 Messages postés 17 Date d'inscription vendredi 29 juillet 2011 Statut Membre Dernière intervention 23 octobre 2015
Modifié par xyxy12 le 23/10/2015 à 10:10
C'est compliqué et pas forcément utile.. En gros j'étudie les figures de Chladni, donc les modes de vibration d'une plaque carrée (si on l'excite à certaines fréquences propres, et qu'on met du sel ou du sable dessus, des formes géométriques se créent du fait de la présence de ventres et de noeuds de vibration). Pour étudier ces vibrations, on divise les côtés de la plaque en n, et pour chaque portion, on se rend compte que le mouvement est régi par une certaine matrice. Et les fréquences propres correspondent aux vecteurs propres de cette matrice.
Du coup, je crée la matrice, je trouve le vecteur propre que je veux, et ensuite il faut que je fasse le graphique de ce mouvement..
Voilà le programme initial complet : 

clear stacksize('max');

//Nombre de points sur la plaque = n*n
n=25;
//Côté d'une plaque en mètres 
L=0.50;
//Pas entre mailles spatiales 
a=L/(n-1);
//Numéro de la valeur propre que l'on veut afficher
valeurPropreAffichee=3; //Ici on affichera donc le 3ème mode propre associé à la 3ème valeur propre

//Matrice symétrique de dimension n
S=diag(ones(n,1)*-4)+diag(ones(n-1,1),1)+diag(ones(n-1,1),-1); 
//Matrice identité de dimension n
Id=diag(ones(n,1));
//Matrice nulle de dimension n
O=zeros(n,n);

//Génération de la matrice à diagonaliser, cette matrice refète la manière dont vibrent les
points verticalement
A=[];
for i=1:n
     Vect=[]; 
     for j=1:n
          if j==i-1 then 
               Vect=[Vect Id] 
               elseif j==i then
                    Vect=[Vect S] 
               elseif j==i+1 
                    Vect=[Vect Id]
               else
                    Vect=[Vect O] 
          end
     end
     A=[A;Vect] 
end

//Vecteurs propres et valeurs propres de A
[vecteursPropres,matDiagonale] =spec(A); valeursPropres=diag(matDiagonale)/a^2;

//Affichage de la plaque et visualisation du mode propre
valeurPropreSelection=valeursPropres(valeurPropreAffichee); vecteurPropreSelection=vecteursPropres(:,valeurPropreAffichee) 
k=1;
X=[];
for i=1:n 
     X(i)=(i-1)*a 
     for j=1:n
       Deform(i,j)=vecteurPropreSelection(k);
       k=k+1; end
     end
clf 
surf(X,X,abs(Deform))
0
xyxy12 Messages postés 17 Date d'inscription vendredi 29 juillet 2011 Statut Membre Dernière intervention 23 octobre 2015
23 oct. 2015 à 10:12
Et voilà mon programme pour l'instant (il n'est pas très bien écrit mais l'important pour le moment est qu'il tourne): 

from numpy import *
from scipy import *
from matplotlib import *
from pylab import *
from mpl_toolkits.mplot3d import Axes3D

#______Mise en place des données du problème____#

N = input("Nombre de points sur la plaque : n = ")
L = input("Dimension de la plaque : L = ")
n = int(N)
l = float(L)
m = input("Mode propre à observer : M = ")
M = int(m)
E = input("Module d'Young du matériau : E = ")
E = eval(E)
rho = input("Masse volumique du matériau : rho = ")
rho = float(rho)

a = l/(n-1)

#_____Création des matrices de base_______#

v = ones(n-1)
I = eye(n)
O = zeros((n,n))
S = -4*eye(n) + diag(v,1) + diag(v,-1)


#_______Génération de la matrice à diagonaliser____#

#Le problème est que nous cherchons à obtenir une matrice n**2 à partir de matrices de taille n. Il faut donc les compléter avec des 0 de manière à ce que le schéma final de la matrice A soit respecté#


A = zeros((n*n,n*n))
for i in range(n):
    Vect = array([])
    B = array([])
    for j in range(n):
        if j == i+1:
            Vect = I
            if j != 1 and j != n-1:
                B = append(zeros((n,j*n)),Vect,axis=1) #On complète à gauche#
                B = append(zeros((i*n,(j+1)*n)),B,axis=0) #On complète au-dessus#
                B = append(B,zeros(((i+1)*n,(n-j-1)*n)),axis=1) #On complète à droite#
                B = append(B,zeros(((n-i-1)*n,n*n)),axis=0)
            elif j ==1:
                B = append(zeros((n,n)),Vect,axis=1)
                B = append(B,zeros((n,(n-2)*n)),axis=1)
                B = append(B,zeros(((n-1)*n,n*n)),axis=0)
            else :
                B = append(zeros((n,j*n)),Vect,axis=1)
                B = append(zeros((i*n,n*n)),B,axis=0)
                B = append(B,zeros((n,n*n)),axis=0)      #On complète en bas#
        elif j==i:
            Vect = S
            if i > 0  and i < n-1 :
                B = append(zeros((n,i*n)),Vect,axis=1) #On complète à gauche#
                B = append(zeros((i*n,(i+1)*n)),B,axis=0) #On complète au dessus#
                B = append(B,zeros(((i+1)*n,(n-i-1)*n)),axis=1) #On complète à droite#
                B = append(B,zeros(((n-i-1)*n,n*n)),axis=0) #On complète en bas#
            else:
                if i == 0 :
                    B = append(Vect,zeros((n,(n-1)*n)),axis=1)
                    B = append(B,zeros(((n-1)*n,n*n)),axis=0)
                else :
                    B = append(zeros((n,(n-1)*n)),Vect,axis=1)
                    B = append(zeros(((n-1)*n,n*n)),B,axis=0)               
        elif j == i-1:
            Vect = I
            B = append(zeros((i*n,n)),Vect,axis=0) #On complète au-dessus#
            if j > 0 and i < n-1 :
                B = append(zeros(((i+1)*n,j*n)),B,axis=1) #On complète à gauche#
                B = append(B,zeros(((n-i-1)*n,(j+1)*n)),axis=0) #On complète en bas#
                B = append(B,zeros((n*n,(n-j-1)*n)),axis=1)
            else :
                if j == 0 :
                    B = append(B,zeros(((n-2)*n,n)),axis=0)
                    B = append(B,zeros((n*n,(n-1)*n)),axis=1)
                else :
                    B = append(zeros((n*n,(n-2)*n)),B,axis=1)               
                    B = append(B,zeros((n*n,n)),axis=1) #On complète à droite#           
        else :
            Vect = O
            B = zeros((n*n,n*n))
        A=A+B   
                               
#_____Calcul des valeurs propres et obtention de la fréquence propre associée au mode propre entré____#

Valp = (linalg.eig(A))[0][M]
Valp = Valp/(a**2)
Vectp = (linalg.eig(A))[1][M-1]
c = (E/rho)**(1/2)
Fp = (abs(Valp)**(1/2))*(c/(2*3.14))

print("La fréquence propre associée au ",M,"-ième mode propre est ",Fp," Hz")

#______Affichage graphique 3D de la vibration de la plaque selon ce mode propre____#
0