Banque PT Modélisation PT 2019Sujet et corrigé

Epreuve d'Informatique et Modélisation de Systèmes Physiques

L'usage de calculatrices est interdit.

• La partie modélisation est distribuée au début et à la fin du sujet (I-1, I-2 et I-8). Il est conseillé de ne pas y consacrer plus d'une heure et demie.
• La partie informatique est développée au cœur du sujet (de I-3 à I-7) et sa durée de traitement conseillée est de deux heures et demie.

I Figures de Chladni

Introduction historique

Dispositif et démonstration de Chladni

Dispositif et démonstration de Chladni

Figure 1 - Figures de Chladni

I. 1 Introduction du modèle physique ( ∼ 10% )

Repérage d'un point sur la plaque

I. 2 Modes de vibration ( ∼ 5% )

I. 3 Simulation numérique temporelle ( ∼ 20% )

# Constantes paramétriques
npoints=2**10 # indew maximal des tableaux
tporte=5*2*np.pi # durée d affichage
X0 =[1.,0] # conditions unibiales
# Initialrsation des tableaux
t=np linspace(0,tporte,npoints+1) # temps
tau=t[1]-t[0]
X=np.zeros((2,npoints+1),dtype=float) # h et h'
# Algorithme d'Euler
X[:,0]=X0 #initialisation
M=np array([[1,tau],[-tau,1]]) # matrice de l'equatron
for i in range(npoints): # Calcul iteratif
    X[:,i+1]=M,dot(X[:,i])

Figure 2 - Méthode d'Euler

Figure 3 - Méthode d'Euler - version alternative

Figure 4 - Méthode de Runge-Kutta

\# Constantes parametriques
npoints $=2 * * 10$ \# index maximal des tableaux
tporte $=100 * 2 * \mathrm{np} . \mathrm{pi}$. I durée di af fichage
$\mathrm{XO}=[1,0] \quad$ \# condutions anitiales
\# Initialisation des tableaum
$\mathrm{t}=\mathrm{np} .1$ inspace ( 0, tporte, npoints $\dagger 1$ ). \# temps
tau=t[1]-t[0]
$\mathrm{X}=\mathrm{np}$ zeros $((2$, npoints +1$)$, dtype $=1$ oat $) \quad \#$ et $h^{\prime}$
\# Algorithme XXX
$\mathrm{X}[:, 0]=\mathrm{XO}$ \#anitialisation
A=np.array([[0,1],[-1,-tau]]) \# matrice de couplage
$\mathrm{M}=\mathrm{np} . \mathrm{identity}(2)+\mathrm{tau} * \mathrm{~A}$ \# matrice d'évolution
for i in range (npoints): \# Galcul itératif
    $X[:, i+1]=M \cdot \operatorname{dot}(X[:, i])$

Figure 5 - Méthode "Stable"

I. 4 Discrétisation spatiale du problème ( ∼ 15% )

12^∘ ) Équation adimensionnée

Figure 6 - Discrétisation de la plaque

Figure 7 - Points voisins d'un point commun de coordonnées (i, j)

14 ^∘ ) Discrétisation autour des bords
Les bords de la plaque doivent être considérés différemment selon les conditions aux limites que nous désirons imposer. Il nous faut gérer les configurations types suivantes que nous désignerons respectivement par les termes de côté vertical, côté horizontal et de coins.

Figure 8 - Figuration des effets de bord

def genereM(A):
        """Fonction dont l'objectif est de renvoyer M
            à partir de A""""
        return M # renvoie la matrice M

I. 5 Méthode de la puissance itérée ( ∼ 10% )

def normeM(M):
    ""Fonction dont l'objectlf est de renvoyer
    la norme de M à partir de Mu""
    return r # norme de M

def normevecteur(F):
    return Fn # wecteur norme

def puissanceiter(M,p):
    return Fp # pième vecteur

def iterstabilise(M,er):
    return F vecteur stabolisê

I. 6 Représentation graphique ( ∼ 5% )

• Le tableau des vecteur propres est un tableau 2D où les vecteurs propres sont stockés selon l'indexation des valeurs propres, il est nommé vecteurprope. Le i^(ième) vecteur propre s'obtient par vecteurpropre [i, : ].

#turarries complementarres
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
def graphe(Z):
    n=Z. shape [0]
    X=Y = np.arange(n)
    X, Y = np.meshgrid(X, Y)
    fig = plt.figure(0,figsize=(10,8))
    ax = fig.gca(projection='3d')
    surf = ax.plot_surface(X, Y, Z,rstride=1,cstride=1,
        cmap=cm.spectral_r, linewidth=0, antialiased=False)
    ax.set_zlim(-1, 1)
    fig.colorbar(surf, shrink=0.5, aspect=10)
    plt.tight_layout()
    fig1=plt.figure(1,figsize=(6,6))
    cont=plt.contour(Z,np.arange(21)/10-1,cmap=cm.spectral_r)
    plt.clabel(cont, cont.levels, inline=True,
        fmt= '%1.1f', fontsize=10)
    plt.xlabel('x')
    plt.ylabel('y')
    plt.title('Courbes de niveau')
    plt.tight_layout()
    plt.show()

def transforme(F):
    return Z # matrice des valeurs U

I. 7 Distribution des valeurs propres ( ∼ 15% )

def recherchebrute(valpropre,v,er):
    return r # booléen

def recherchedicho(valpropre,v):
    return r # booldén

Figure 9 - Quelques modes propres

def rechercheplagedicho(valpropre, valmin, valmax):
    return valselect # tableautD

def valsearch(valpropre,valmin,valmax):
    mask=(valpropre>valmin) * (valpropre<valmax)
    return valpropre[mask]

I. 8 Confrontation du modèle aux expériences ( ∼ 20% )

26^∘ ) Dégénérescence des modes.

II Annexe : Rappel Python

II. 1 Librairies utilisées

# - * - coding:Utf-8 -*
##ibrarimes utilisées et alias
import numpy as np
import matplotlib.pyplot as plt
import numpy.random as rd

II. 2 Usage courant de Numpy

## commandes de base
# definir un tableau nul de tarlle nxp
A=np.zeros(shape=(n,p))
# définir un tableau identité de taille nxn
B=np.eye(n)
# défintr un tableau nempli de 1 unvformément nop
C=np.ones(shape=(n,p))
# obtenir les dimensions d'un tableau A = nop
n,p=A.shape # usage de l'attribut shape
# obtenir le nombre d'élements d'un tableau A
nb_elements=A.size # usage de l'attribut size

## Opérations élémentaires sur les tableaux
# Addibron d'un scalarre y a chaque terme du tableau
j=1
D=A+j
# multiplication par un scalaire k
k=2
D=k*D
# additron, soustrotion, prodututerme à terme
AddBC=B+C
SubBC=B-C
ProdBC=B*C

## Opératrons "matricuelles" courantes
# produit matriciel B x C
PmatBC=B.dot(C)
# Tranposée dut tableau C
C.T
# Lecture de la cellule [%,j] du tableau C à 2 dimensions
i,j=1,2
r=C[i,j]

II. 3 Manipulation et copies de tableaux

# Alias
F = C # F et C référencent le même tableau
## Copie d'un tableau
F=C.copy() # F réference une copre du tobleau C

## Rejormage
% un tableau peut être réorganisé par la méthode reshape
E=np.ones(9) 犎 vecteur 1D de neuf 1
print(E)
[ 1. 1. 1. 1. 1. 1. 1. 1. 1.]
F=E.reshape(3,3) # reforme E en tableau 2D 303
print(F)
[[ 1. 1. 1.]
[ 1. 1. 1.]
[ 1, 1, 1,]]
G=F.flatten() % renvore le tableau sous forme 1D
print (G)
[ 1.1.1.1.1.1.1.1.1.]

$\mathrm{a}=\mathrm{np}$. arange (4) .reshape $(2,2)$
    array([[0, 1],
        [2, 3]])
$\mathrm{b}=4+\mathrm{np}$. arange (4) .reshape $(2,2)$
    array([[4, 5],
        [6, 7]])
np.concatenate((a,b))
    array ([[0, 1],
        [2, 3],
        [4, 5] ,
        [6, 7]])
np.concatenate((a,b),axis=0)
    array ([[0, 1],
        $[2,3]$,
        [4, 5] ,
        [6, 7]])
np.concatenate((a,b),axis=1)
    array ( $[[0,1,4,5]$,
        [2, 3, 6, 7]])

II. 4 Utilisation du générateur aléatoire - numpy.random

import numpy.random as rd # Appel de la librarrie
# tableau 1D comportant 10 éléments
print (rd.rand(10))
>>> [0.16653536 0.37216705 0.56565704 0.62948842 0.65555812 0.38543034
    0.1486412 0.52610282 0.4686787 0.81558018]
# tableau 2D comportant 3X2 ézénents
print(rd.rand(3,2))
>>> [[0.98992966 0.58907376]
    [0.6404654}0.53852321
    [0.12416014 0.28279454]}