Vous êtes sur la page 1sur 6

CCP SI

Proposition de corrig de la partie IPT


Ce corrig ne sintresse qu la partie Python du sujet pos aux CCP lpreuve de SI (MP 2015)

Question 11 :

La mthode dEuler est une mthode de premier ordre, on remplace la drive par laccroissement de la
.
lim
tangente entre deux chantillons successifs :

Lerreur commise est dordre deux, elle nest gure recommande si les phnomnes sont du mme
ordre (cest le cas ici sauf si lamortissement est dominant).
On obtient lquation aux diffrences :

,

Question 12 :
La fonction

est donne par lnonc :

On vitera bien sur limplmentation directe de cette formule , introduisons des paramtres de
rduction. On pose :
2
et
5
On a alors :

cos
2
sin
sin
Les constantes seront passes en paramtres, lautre solution consiste les dclarer en variable globale
(allergie personnelle) ou les dclarer lintrieur de la fonction fi (mais lnonc nen fait pas mention).
Il suffit dimplmenter le code correspondant :
# constantes rduites
w0=np.sqrt(5/7*g/(R-r))
z=5/14*fv/m/w0
a=5/7*F0/m/(R-r)/w0**2
# Tuple de transfert
cTuple=(wbob,w0,z,a)
def fi(t,Y,cT=cTuple):
"""Donnes : t et Y les valeurs discrtes d'indice i
le vecteur Y est un ndarray numpy
cT est un Tuple passant les constantes utilises """
# onrenvoie directement le vecteur F(ti,Y(ti))
wbob,w0,z,a=cT
return np.array([Y[1],a*w0**2*np.sin(wbob*t)*cos(Y[0])-2*z*w0*Y[1]-w0**2*Y[0]])

Question 13 :

On prend soin didentifier les variables dentre et de sortie. On cre ces dernires et on itre sur
lquation aux diffrences. On utilise le slicing pour transfrer, affecter les lments du tableau.
Si SY est la base de travail, on remarque que la forme de fin nest pas optimale en termes de paramtres
dentre.
Pour afficher la variable de retour on utilisera la fonction affichage suivante :
def affichage(SY):
plt.clf() # Efface le graphique prcdent
plt.plot(SY[:,0],SY[:,1],"b") # trace la courbe
plt.title("Rponsetemporelle") # Titre
plt.xlabel("Temps(s)") # lgende de l'abscisse
plt.ylabel("Theta(rad)") # lgende de l'ordonne
plt.show()
C. Caire

2015 CCP MP SI - Infotmatique - Corrig

Ce fichier est issu du site http://sites.google.com/site/concourscpgecorrections/home


Toute copie sur un autre site est illgale et sest faite sans laval de lauteur.

1/6

Le code de la fonction Euler peut avoir lallure suivante :


def Euler(Yini,h,Tmaxi,F):
""" Donnes : Yini conditions initiales ndarray dim 2
h,Tmaxi scalaires
F fonction (ici la fi prcdente)
le retour est cens tre un ndarray 2 dimensions SY"""
# cration d'un ndarray comportant les ti
# utilisation de la fonction ceil pour viter la plaisanterie d'un Tmaxi non multiple de h
t=np.arange(np.ceil(Tmaxi/h))*h
# nombre d'lments du tableau
Nb=len(t)
# Initialisation de SY et premire affectation
SY=np.empty((Nb,3)) # dclaration du tableau
SY[:,0]=t # remplissage de la premire colonne avec t
SY[0,1:]=Yini # Utilisation des conditions initiales
for i in range(1,Nb): # Boucle sur le nombre d'lements moins l'initial
SY[i,1:]=SY[i-1,1:]+h*F(t[i-1],SY[i-1,1:]) # Equation aux diffrences
return SY
Voici deux courbes de rponse obtenues avec les mmes paramtres lexception de h :

On remarque sans peine que si la premire rponse peut paraitre crdible il nen est rien de la seconde
qui diverge joyeusement. La robustesse de la mthode est modeste !
h a t sur la deuxime figure multiplie par 10.

C. Caire

2015 CCP MP SI - Infotmatique - Corrig

Ce fichier est issu du site http://sites.google.com/site/concourscpgecorrections/home


Toute copie sur un autre site est illgale et sest faite sans laval de lauteur.

2/6

Question 14 :

La mthode dEuler sincarne dans lquation aux diffrences :


Elle consiste calculer les N lments du tableau alors que
La dtermination des sera donc en
ou
.


est en

,
1

Si on divise h par 10 on multiplie dautant N, le temps de calcul sera donc dix fois plus important mais
on divisera lerreur de lalgorithme par 100 (en ).

Question 15 :

Hors singularit nous avons :


sin
sin

cos

On fait le quotient et on exploite les variables rduites :


sin
sin

sin
On utilise le slicing qui se fera sur les valeurs indexes de 0 N-2 car on a besoin de calculer les valeurs
aux temps i et i+1.
La recherche du non-respect de la condition se fait en utilisant une technique de masquage.
Le code est le suivant :
def VerifRSG(SY,f,cT=cTuple):
"""Donnes : SY contient temps, angle et vitesse angulaire
f est le coefficient de frottement
cT est un Tuple passant les constantes utilises """
# on rcupre les constantes
Nb=SY.shape[0] #nombre de points
wbob,w0,z,a=cT # constantes rduites du systme
h=SY[1,0] # valeur de h
# On cre le tableau |Ti/Ni| index de 0 Nb-2 et non Nb-1
# car on a besoin d'un terme en i+1
FY=np.abs(2/7*(SY[1:,2]-SY[:-1,2])/h/(a*w0**2*np.sin(wbob*SY[:-1,0])*np.sin(SY[:1,1])+5/7*(SY[:-1,2])**2+w0**2*np.cos(SY[:-1,1])))
# Utilisation d'un masque binaire FY>f
# FY>f n'est vrai que pour les valeurs qui correspondent un glissement
# FY[mask] ne renvoie que les valeurs qui ne respectent pas la condition
FY=FY[FY>f]
# un size non nul renvoie un faux
# car il existe alors au moins une valeur qui glisse
return not(bool(FY.size))

Question 16 :

On exploite les graphes pour notre analyse


Les courbes suivantes apparaissent comme stables (faibles valeurs des angles, caractre born des
fluctuations).

C. Caire

2015 CCP MP SI - Infotmatique - Corrig

Ce fichier est issu du site http://sites.google.com/site/concourscpgecorrections/home


Toute copie sur un autre site est illgale et sest faite sans laval de lauteur.

3/6

A linverse les deux courbes ci-aprs ont une amplitude crte qui ne cesse de croitre, elles sont associes
des phnomnes qui paraissent divergents.

Les 14a et 14c correspondent des courbes qui valident les conditions de linarisation.
Cest dailleurs confirm par les solutions qui sont voisinent de la somme de la rponse libre dun
oscillateur linaire et de sa rponse commande (une simple sinusode la pulsation de contrainte).

Question 17 :

Le tableau de mesures nomm


comporte
lments.
Pour rponde aux besoins de lnonc nous devons construire un estimateur de pertinence, cest la
fonction dtermine sur une sous partie du tableau
et qui ne comportera que
lments avec
.

La valeur efficace dfinie se confond avec la racine de la variance (cart type) si le signal tudi est
alternatif, elle sen distinguera si la moyenne du signal est non nulle.
La complexit est en
.
Il faut multiplications (lvations au carr), additions (la somme), une division par N (une opration)
et une extraction de racine (1 opration mais plus complexe)
On code la fonction en utilisant le slicing classique de numpy et en suppose quil ny a pas de dbordement
dindice possible (ouille !)
def Valeur_efficace(T,a,b):
"""T est le tableau de mesures numpy
a indice de dpart
b nombre d'lements de la porte prendre en compte"""
# simple, on extrait la partition de T utile
# on multiplie avec le produit matriciel => produit scalaire
# on divise par b et on prend la racine
return np.sqrt(T[a:a+b].dot(T[a:a+b])/b)

Question 18 :

Voici le code de lalgorithme propos et cod en Python brutalement


def Temps_coagulation(M,Te,N):
Nmaxi=len(M) # taille du tableau en O(1) en python
Xeff0=Valeur_efficace(M,0,N) # fonction en O(N)
i=0 # temps constant en O(1)
Xeff=Xeff0 # temps constant en O(1)
while Xeff>0.7*Xeff0 and i<Nmaxi-N: # pire des cas en Nmaxi-N
Xeff=Valeur_efficace(M,i,N) # fonction en O(N)
i+=1 # temps constant en O(1)
if i==Nmaxi-N: # temps constant en O(1)
raise NameError("Devinequiaratsamesure?") # temps constant en O(1)
return i*Te/1000 # temps constant en O(1)
C. Caire

2015 CCP MP SI - Infotmatique - Corrig

Ce fichier est issu du site http://sites.google.com/site/concourscpgecorrections/home


Toute copie sur un autre site est illgale et sest faite sans laval de lauteur.

4/6

Les diffrentes oprations sont identifies par leur complexit.


On peut remarquer que certaines de ces complexits dpendent du langage et du type de variable, la
dtermination de la taille dune liste chaine (mauvais choix pour un tableau) est en
et non en
temps constant.
La complexit du code propos est en
Cest en effet la boucle while opre dans le pire des cas
la fonction valeur_efficace.

fois qui va multiplier la complexit de

Si on modifie la ligne 7 la complexit dans la boucle nest plus en


3 ce qui est quivalent
.
La complexit globale est alors en max
,

mais en

Remarque : le code propos est alors faux, le concepteur du sujet a oubli que la valeur efficace est une
moyenne pondre sur N lments, il aurait d proposer :

Question 19 :

Une pile nest pas adquate car le premier lment rentr dans la structure doit tre le premier sorti, il
nous faut du FIFO (file) et non du LIFO (last in first out = stack = pile).

Question 20 :

Le code demand est du type ci-aprs :


def Init_tampon(N,Te):
fifo=creer_file() # creer une file vide fifo
for i in range(N): # Boucler N fois
enfiler(fifo,Mesure(T)) # Insrer N fois les rsultats de mesure dans fifo
return fifo
def Temps_coagulation(Te,N,Nmaxi):
"""Erreur probable de l'nonc qui donne M en paramtre
M ne sert plus rien car on travaille en temps rel
N ne peut tre devin il faut donc l'importer"""
T=Init_tampon(N,Te) # cre et initialise le tampon
Xeff0=Valeur_efficace(T) # fonction en O(N)
i=0 # temps constant en O(1)
Xeff=Xeff0 # temps constant en O(1)
while Xeff>0.7*Xeff0 and i<Nmaxi-N: # pire des cas en Nmaxi-N
a=Mesure(Te) # faire une nouvelle mesure O(1)
enfiler(T,a) # stocker l'lment dans la file O(1)
b=defiler(T) # enlever un lment de la file O(1)
Xeff=np.Sqrt(Xeff**2+(a**2-b**2)/N) # modification de Xeff en O(1)
i+=1 # temps constant en O(1)
if i==Nmaxi-N: # temps constant en O(1)
raise NameError("Devinequiaratsamesure?") # temps constant en O(1)
return i*Te/1000 # temps constant en O(1)
def Valeur_efficace(fifo):
"""fifo est une file
il faut "caster" cette file sur un tableau numpy"""
T=np.array(fifo)
return np.sqrt(T.dot(T)/len(T))
la premire fonction cre une file fifo et la remplit de N mesures issue de Mesure(Te).
C. Caire

2015 CCP MP SI - Infotmatique - Corrig

Ce fichier est issu du site http://sites.google.com/site/concourscpgecorrections/home


Toute copie sur un autre site est illgale et sest faite sans laval de lauteur.

5/6

La deuxime fonction propose dans lnonc est buggue dans son initialisation (erreur Nmaxi , N).
On procde lidentique jusqu la boucle while, point ou on utilisera la structure file propose.
Le calcul de litration suivante de Xeff est fait en modifiant la formule de lnonc qui a oubli de
prendre en compte le poids en 1/N de chaque lment dans la somme.
Enfin valeur_efficace doit tre modifi pour accepter une file et non un ndarray (numpy)
On pourra remarquer quici la file ne sert rien car elle duplique les donnes de M en cours
dutilisation et que loprateur/codeur dispose de tous les lments pour dterminer ces donnes.
Cest donc juste un exercice de style !

Fin

C. Caire

2015 CCP MP SI - Infotmatique - Corrig

Ce fichier est issu du site http://sites.google.com/site/concourscpgecorrections/home


Toute copie sur un autre site est illgale et sest faite sans laval de lauteur.

6/6