Cinématique d'un système de solides

2.a. Répérage des solides

On utilise un repère fixe OXY lié au bâti, le repère global. La position d'un solide dans le plan est déterminée par trois variables : les deux coordonnées d'un point lié au solide (par exemple son centre de masse) et un angle définissant son orientation. Ces trois variables seront désignées comme les coordonnées du solide. Il a donc a priori trois degrés de liberté. Nous associons à chaque solide un repère qui lui est lié, appelé le repère propre du solide. Pour le solide numéro i, soit O_i l'origine de ce repère et (x_i,y_i) les deux axes. La figure suivante montre un choix possible pour chacun des quatre solides du système pris en exemple :

Figure pleine page

Soit $\overrightarrow{R_i}=\overrightarrow{O{O}_i}$ le vecteur définissant la position du point O_i lié au solide i. Dans le repère global OXY, les coordonnées du point O_i sont notées (R_ix,R_iy). L'orientation du solide est définie par l'angle θ_i=(OX,O_ix_i). La position du solide est donc définie par les trois variables (R_ix,R_iy,θ_i).

Soit P_i un point lié au solide i : ses coordonnées (x_Pi,y_Pi) dans le repère (O_i,x_i,y_i) sont constantes. Ses coordonnées dans le repère OXY sont données par :

$$\begin{array}{ccc}\hfill & X_{Pi}=R_{ix}+x_{Pi}cos\left({\theta }_i\right)-y_{Pi}sin\left({\theta }_i\right)\hfill & \hfill \text{(1)}\\ \hfill & Y_{Pi}=R_{iy}+x_{Pi}sin\left({\theta }_i\right)+y_{Pi}cos\left({\theta }_i\right)\hfill & \hfill \text{(2)}\end{array}$$

Il s'agit d'une transformation affine, que l'on peut aussi mettre sous la forme matricielle suivante :

$$\left(\begin{array}{c}\hfill X_{pi}\hfill \\ \hfill Y_{pi}\hfill \end{array}\right)=\left(\begin{array}{c}\hfill R_{ix}\hfill \\ \hfill R_{iy}\hfill \end{array}\right)+\left(\begin{array}{cc}\hfill cos\left({\theta }_i\right)\hfill & \hfill -sin\left({\theta }_i\right)\hfill \\ \hfill sin\left({\theta }_i\right)\hfill & \hfill cos\left({\theta }_i\right)\hfill \end{array}\right)\left(\begin{array}{c}\hfill x_{pi}\hfill \\ \hfill y_{pi}\hfill \end{array}\right)\text{(3)}$$

2.b. Contraintes cinématiques

Sans la prise en compte des contraintes cinématiques, un système de N solides comporte 3N degrés de liberté. Les liaisons présentes dans le système réduisent le nombre de degrés de liberté. Dans l'exemple considéré, la liaison du solide (1) avec le bâti fixe ses trois degrés de liberté. Une liaison pivot enlève deux degrés de liberté au système. La liaison glissière entre le solide (4) et le support enlève deux degrés de liberté. Finalement, il reste pour cet exemple 12-3-2-2-2-2=1 degré de liberté. Supposons qu'un moteur impose la valeur de θ₂, il ne reste plus aucun degré de liberté. En imposant la valeur de θ₂ (ou de toute autre variable), on impose la configuration du système. Il s'agit de déterminer cette configuration, c'est-à-dire les valeurs des 3N variables suivantes :

$$q=(R_{1x},R_{1y},{\theta }_1,R_{2x},R_{2y},{\theta }_2,\dots ,R_{Nx},R_{Ny},{\theta }_N)\text{(4)}$$

Une contrainte cinématique est une équation reliant des variables du système, c'est-à-dire des variables de la matrice q. Chaque contrainte enlève un degré de liberté au système. Nous allons voir comment s'expriment ces équations pour quelques liaisons.

2.c. Liaison encastrement

Deux solides reliés par un encastrement forment un seul système indéformable. Dans l'exemple, le solide 1 est en liaison encastrement avec le bâti. Ses trois coordonnées (R_1x,R_1y,θ₁) sont donc fixées (par exemple à des valeurs nulles). En pratique, deux solides encastrés peuvent être définis par un seul solide. On s'intéresse donc uniquement à l'encastrement d'un solide avec le bâti lié au référentiel (OXY), qui s'exprime par les trois équations suivantes :

$$\begin{array}{ccc}\hfill & R_{1x}-R_{1x}^0=0\hfill & \hfill \text{(5)}\\ \hfill & R_{1y}-R_{1y}^0=0\hfill & \hfill \text{(6)}\\ \hfill & {\theta }_1-{\theta }_1^0=0\hfill & \hfill \text{(7)}\end{array}$$

Les trois constantes sont notées avec un exposant 0. Nous avons donc trois contraintes, définies par trois équations que l'on écrira sous la forme (C₁(q)=0,C₂(q)=0,C₃(q)=0). Ces trois équations enlèvent trois degrés de liberté au système. Nous appellerons fonctions de contraintes les fonctions C_k.

Nous aurons aussi besoin des dérivées partielles de ces fonctions par rapport aux variables qu'elles contiennent :

$$\begin{array}{ccc}\hfill & \frac{\partial C_1}{\partial R_{1x}}=1\hfill & \hfill \text{(8)}\\ \hfill & \frac{\partial C_2}{\partial R_{1y}}=1\hfill & \hfill \text{(9)}\\ \hfill & \frac{\partial C_3}{\partial {\theta }_1}=1\hfill & \hfill \text{(10)}\end{array}$$

2.d. Liaison pivot

Dans le cas d'un mouvement plan, la liaison pivot entre deux solides (i et j) impose un point fixe commun aux deux solides. Il existe donc un point (et un seul) lié au solide i, noté P_i, qui coïncide à tout instant avec un point lié au solide j, noté P_j.

Figure pleine page

Dans le repère OXY, la liaison pivot s'exprime donc par les deux équations :

$$\begin{array}{ccc}\hfill & X_{Pi}-X_{Pj}=0\hfill & \hfill \text{(11)}\\ \hfill & Y_{Pi}-Y_{Pj}=0\hfill & \hfill \text{(12)}\end{array}$$

Écrivons ces deux équations explicitement en fonction des coordonnées des deux solides et des coordonnées des deux points dans les repères de chaque solide :

$$\begin{array}{ccc}\hfill & R_{ix}+x_{Pi}cos\left({\theta }_i\right)-y_{Pi}sin\left({\theta }_i\right)-R_{jx}-x_{Pj}cos\left({\theta }_j\right)+y_{Pj}sin\left({\theta }_j\right)=0\hfill & \hfill \text{(13)}\\ \hfill & R_{iy}+x_{Pi}sin\left({\theta }_i\right)+y_{Pi}cos\left({\theta }_i\right)-R_{jy}-x_{Pj}sin\left({\theta }_j\right)-y_{Pj}cos\left({\theta }_j\right)=0\hfill & \hfill \text{(14)}\end{array}$$

Les coordonnées $(x_{Pi},y_{Pi},x_{Pj},y_{Pj})$ sont des constantes puisque les points P_i et P_j sont liés respectivement au solide i et au solide j; elles définissent la position de la liaison pivot dans le repère propre de chacun des deux solides. Nous obtenons donc deux équations que l'on écrira sous la forme (C₁(q)=0,C₂(q)=0), qui enlèvent deux degrés de liberté au système.

Les dérivées partielles de ces fonctions sont :

$$\begin{array}{ccc}\hfill & \frac{\partial C_1}{\partial R_{ix}}=1\hfill & \hfill \text{(15)}\\ \hfill & \frac{\partial C_1}{\partial R_{jx}}=-1\hfill & \hfill \text{(16)}\\ \hfill & \frac{\partial C_1}{\partial {\theta }_i}=-x_{Pi}sin\left({\theta }_i\right)-y_{Pi}cos\left({\theta }_i\right)\hfill & \hfill \text{(17)}\\ \hfill & \frac{\partial C_1}{\partial {\theta }_j}=x_{Pj}sin\left({\theta }_j\right)+y_{Pj}cos\left({\theta }_j\right)\hfill & \hfill \text{(18)}\\ \hfill & \frac{\partial C_2}{\partial R_{iy}}=1\hfill & \hfill \text{(19)}\\ \hfill & \frac{\partial C_2}{\partial R_{jy}}=-1\hfill & \hfill \text{(20)}\\ \hfill & \frac{\partial C_2}{\partial {\theta }_i}=x_{Pi}cos\left({\theta }_i\right)-y_{Pi}sin\left({\theta }_i\right)\hfill & \hfill \text{(21)}\\ \hfill & \frac{\partial C_2}{\partial {\theta }_j}=-x{p}_{Pj}cos\left({\theta }_j\right)+y_{Pj}sin\left({\theta }_j\right)\hfill & \hfill \text{(22)}\end{array}$$

2.e. Glissière horizontale

Dans l'exemple considéré, le solide (4) est contraint de se déplacer en translation dans la direction X. Il s'agit d'un cas particulier de liaison glissière. La liaison glissière en général étant beaucoup plus complexe à mettre en équation, nous traitons à part ce cas simple, que l'on peut qualifier de glissière horizontale. Cette liaison s'exprime par les deux équations suivantes :

$$\begin{array}{ccc}\hfill & R_{iy}-R_{iy}^0=0\hfill & \hfill \text{(23)}\\ \hfill & {\theta }_i-{\theta }_i^0=0\hfill & \hfill \text{(24)}\end{array}$$

2.f. Liaison glissière

Dans la liaison glissière, le mouvement du solide j par rapport au solide i se limite à une translation de long d'un axe. Soient P_i un point lié au solide i et P_j un point lié au solide j tels que la droite (P_iP_j) soit l'axe de translation. On a aussi besoin d'un point Q_i lié au solide i tel que les vecteurs $\overrightarrow{Q_i{P}_i}$ et $\overrightarrow{P_i{P}_j}$ soient orthogonaux.

Figure pleine page

La liaison glissière s'exprime par les deux contraintes suivantes (θ₀ est une constante) :

$$\begin{array}{ccc}\hfill & {\theta }_i-{\theta }_j-{\theta }_0=0\hfill & \hfill \text{(25)}\\ \hfill & \overrightarrow{P_i{P}_j}\cdot \overrightarrow{Q_i{P}_i}=0\hfill & \hfill \text{(26)}\end{array}$$

Pour exprimer la seconde condition à l'aide des coordonnées des deux solides, écrivons tout d'abord les composantes des deux vecteurs :

$$\begin{array}{ccc}\hfill & u=R_{ix}+x_{Pi}cos\left({\theta }_i\right)-y_{Pi}sin\left({\theta }_i\right)-R_{jx}-x_{Pj}cos\left({\theta }_j\right)+y_{Pj}sin\left({\theta }_j\right)\hfill & \hfill \text{(27)}\\ \hfill & v=R_{iy}+x_{Pi}sin\left({\theta }_i\right)+y_{Pi}cos\left({\theta }_i\right)-R_{jy}-x_{Pj}sin\left({\theta }_j\right)-y_{Pj}cos\left({\theta }_j\right)\hfill & \hfill \text{(28)}\\ \hfill & a=(x_{Pi}-x_{Qi})cos\left({\theta }_i\right)-(y_{Pi}-y_{Qi})sin\left({\theta }_i\right)\hfill & \hfill \text{(29)}\\ \hfill & b=(x_{Pi}-x_{Qi})sin\left({\theta }_i\right)+(y_{Pi}-y_{Qi})cos\left({\theta }_i\right)\hfill & \hfill \text{(30)}\end{array}$$

La seconde contrainte s'écrit alors :

$$ua+vb=0\text{(31)}$$

Notons C₂(q)=0 cette dernière équation. Les dérivées partielles de C₂(q)=ua+vb se calculent aisément.

2.g. Variable imposée

Pour qu'un système soit cinématiquement contraint, il faut enlever les degrés de liberté restant après prise en compte des liaisons, en imposant les valeurs d'un nombre de variables égal au nombre de degrés de liberté restant. Dans l'exemple considéré, il reste un degré de liberté après la prise en compte des liaisons, que l'on élimine en imposant la valeur de θ₂, ce qui correspond en pratique à un contrôle effectué par un moteur. L'équation exprimant cette condition s'écrit :

$${\theta }_2-f\left(t\right)=0\text{(32)}$$

où f(t) est une fonction du temps qui exprime la position angulaire imposée par le moteur, par exemple f(t)=ωt pour une vitesse angulaire constante.

3.a. Principe

Pour un système comportant N solides, donc n=3N degrés de liberté, notons $q=(q_1,q_2,\dots q_n)$ les 3N variables $R_{1x},R_{1y},{\theta }_1,R_{2x},R_{2y},{\theta }_2,\dots ,R_{Nx},R_{Ny},{\theta }_N$. Si le système est cinématiquement contraint, il y a n équations $(C_1\left(q\right)=0,C_2\left(q\right)=0,\dots C_n\left(q\right)=0)$ qui expriment les 3N contraintes. Par exemple, deux équations sont associées à chaque liaison pivot. Il faut résoudre ce système d'équations afin de déterminer q. Il s'agit d'un système d'équations non linéaires, car certaines contraintes s'expriment par une relation non linéaire entre les variables (c'est le cas des liaisons pivot et glissière).

Si le problème est bien posé, le système admet au moins une solution, mais il peut en admettre plusieurs. Par exemple, le système bielle-manivelle admet plusieurs solutions : la bielle peut être orientée vers la droite ou vers la gauche et il y a deux orientations possibles pour le solide 4, ce qui fait en tout quatre solutions. En pratique, on s'intéresse à une seule de ces solutions car on suppose que le mouvement se fait continûment à partir d'une condition initiale donnée. Par exemple, la bielle (solide 3) ne peut pas se retourner d'un seul coup.

3.b. Méthode de Newton-Raphson

La méthode de Newton-Raphson permet d'obtenir une solution du système d'équations suivant :

$$C_k(q_2,q_2,\dots q_n)=0(k=1,2,\dots n)\text{(33)}$$

Il s'agit d'une méthode itérative reposant sur le développement de Taylor suivant :

$$C_k(q_1+\delta q_1,q_2+\delta q_2,\dots q_n+\delta q_n)=C_k(q_1,q_2,\dots q_n)+\sum _{i=1}^n\frac{\partial C_k}{\partial q_i}\delta q_i+O\left(\delta q^2\right)\text{(34)}$$

Supposons que l'on dispose de valeurs $(q_1,q_2,\dots q_n)$ proches de la solution cherchée. On recherche les incréments $(\delta q_1,\delta q_2,\dots ,\delta q_n)$ permettant de réaliser $C_k(q_1+\delta q_1,q_2+\delta q_2,\dots q_n+\delta q_n)=0$. En limitant le développement de Taylor à l'ordre 1, cette condition s'écrit :

$$C_k(q_1,q_2,\dots q_n)+\sum _{i=1}^n\frac{\partial C_k}{\partial q_i}\delta q_i=0\text{(35)}$$

Il s'agit d'un système d'équations linéaires pour $(\delta q_1,\delta q_2,\dots ,\delta q_n)$. Afin de l'écrire sous forme matricielle, on introduit la matrice jacobienne définie par :

$$J=\left(\begin{array}{cccc}\hfill \frac{\partial C_1}{\partial q_1}\hfill & \hfill \frac{\partial C_1}{\partial q_2}\hfill & \hfill \cdots \hfill & \hfill \frac{\partial C_1}{\partial q_n}\hfill \\ \hfill \frac{\partial C_2}{\partial q_1}\hfill & \hfill \frac{\partial C_2}{\partial q_2}\hfill & \hfill \cdots \hfill & \hfill \frac{\partial C_2}{\partial q_n}\hfill \\ \hfill \cdots \hfill & \hfill \cdots \hfill & \hfill \cdots \hfill & \hfill \cdots \hfill \\ \hfill \frac{\partial C_n}{\partial q_1}\hfill & \hfill \frac{\partial C_n}{\partial q_2}\hfill & \hfill \cdots \hfill & \hfill \frac{\partial C_n}{\partial q_n}\hfill \end{array}\right)\text{(36)}$$

Les éléments de cette matrice carrée sont $J_{ki}=\frac{\partial C_k}{\partial q_i}$. La k-ième ligne contient donc les dérivées partielles de la k-ième fonction de contrainte. Si l'on note δq la matrice colonne contenant les inconnues $(\delta q_1,\delta q_2,\dots ,\delta q_n)$ et C la matrice colonne contenant les n valeurs $C_k(q_1,q_2,\dots q_n)$ pour $k=1,\dots n$, alors le système linéaire à résoudre s'écrit :

$$J\cdot \delta q=-C\text{(37)}$$

Ce système est résolu par la méthode d'élimination de Gauss-Jordan. Les valeurs $(\delta q_1,\delta q_2,\dots ,\delta q_n)$ obtenues permettent de calculer une nouvelle approximation $(q_1+\delta q_1,\dots q_n+\delta q_n)$ plus proche de la solution, à condition que la première estimation soit assez proche de la solution. La procédure est appliquée itérativement, ce qui permet de s'approcher de plus en plus de la solution. Les itérations sont stoppées lorsqu'on estime que les incréments $\delta q_i$ sont assez petits, par exemple lorsque l'inégalité suivante est vérifiée :

$$\sum _{i=1}^n{\left(\delta q_i\right)}^2<\epsilon \text{(38)}$$

où $\epsilon$ est une tolérance qui devra être d'autant plus faible que l'on souhaite une bonne précision.

Supposons que l'on cherche les configurations du système obtenues en faisant varier un paramètre, l'angle θ₂ dans notre exemple. Il est parfois possible de choisir une valeur initiale du paramètre qui permette de calculer à la main les coordonnées initiales des solides. Dans le cas contraire, il faudra choisir des coordonnées initiales proches de la solution cherchée, assez proches pour que l'itération de Newton-Raphson converge effectivement vers cette solution. Chaque nouvelle valeur du paramètre est obtenue à partir de la précédente par un petit incrément, de telle sorte que la nouvelle solution soit très proche de la précédente. Dans ces conditions, la méthode de Newton-Raphson converge rapidement vers la nouvelle solution. Si une discontinuité de mouvement d'un des solides est observée, il faut réduire l'incrément de variation du paramètre.

4.a. Principe

L'objectif est de concevoir un ensemble de fonctions permettant de définir un système mécanique quelconque et d'accomplir le calcul de sa configuration avec l'algorithme décrit ci-dessus. Il devra aussi être en mesure de représenter graphiquement les solides. Une animation du mouvement du système (lorsqu'on fait varier un paramètre) permettra de vérifier le bon déroulement des calculs.

Avant de penser à coder l'algorithme à proprement parler, il faut bien réfléchir aux structures de données que l'on va utiliser, car un mauvais choix peut rendre l'algorithme très difficile à implémenter.

4.b. Implémentation des solides

Un solide est défini par ces trois coordonnées $R_{ix},R_{iy},{\theta }_i$. Il faut aussi définir sa représentation graphique. Pour faire au plus simple, on définira un contour sous la forme d'une liste de points à relier par des segments. Les coordonnées de ces points doivent être données dans le repère propre de chaque solide, car elles sont fixes dans ce repère. Nous aurons aussi besoin d'une fonction pour tracer le contour. Lorsqu'un système comporte plusieurs objets similaires (ici les solides) avec des fonctions permettant de les manipuler, il est intéressant d'utiliser la programmation orientée objet. Pour définir des objets permettant de représenter les solides, il faut définir une classe, qui représente une classe d'objets similaires. Nous allons définir une classe intitulée Solide. Un objet comporte des données et des fonctions agissant sur ces données. En python, on ne déclare pas explicitement les données (car celle-ci sont créées dynamiquement au moment de l'exécution) mais on doit définir les fonctions. Voici la définition de la classe que nous allons utiliser :

class Solide:
    def __init__(self,Rx,Ry,theta,contour=[]):
        self.Rx = Rx
        self.Ry = Ry
        self.theta = theta
        self.contour = contour
        self.line = None
    def coord_point(self,xp,yp):
        # xp,yp : coordonnées d'un point lié au solide dans le repère propre
        cos = numpy.cos(self.theta)
        sin = numpy.sin(self.theta)
        X = self.Rx + xp*cos-yp*sin
        Y = self.Ry + xp*sin+yp*cos
        return [X,Y]
    def dessiner(self,ax):
        liste_x = []
        liste_y = []
        for k in range(len(self.contour)):
            p = self.contour[k]
            XY = self.coord_point(p[0],p[1])
            liste_x.append(XY[0])
            liste_y.append(XY[1])
        self.line, = ax.plot(liste_x,liste_y,"-",linewidth=2)
    def redessiner(self,ax):
        liste_x = []
        liste_y = []
        for k in range(len(self.contour)):
            p = self.contour[k]
            XY = self.coord_point(p[0],p[1])
            liste_x.append(XY[0])
            liste_y.append(XY[1])
        self.line.set_data(liste_x,liste_y)
                         

Une classe comporte obligatoirement une fonction __init__ qui est appelée pour créer l'objet (fonction constructeur). Dans notre cas, cette fonction prend en argument les coordonnées initiales de l'objet et la définition de son contour. Voici comment créer un objet :

solide_1 = Solide(0.1,0,0,[[-0.1,0],[0.1,0]])

L'appel de la fonction portant le nom de la classe exécute la fonction __init__ de cette classe. On remarque que le premier argument de cette fonction, nommé self, n'apparaît pas dans l'appel. Il représente l'objet qui est en train d'être créé et qui est en fait renvoyé par le constructeur. Les variables associées à l'objet sont créées dans __init__. Par exemple la ligne self.Rx=Rx crée une variable numérique nommée Rx et lui attribue la valeur de l'argument nommé Rx (on utilise le même nom pour la clarté).

Toutes les autres fonctions de la classe ont un premier argument self qui représente l'objet particulier qui doit être traité. Par exemple, la fonction coord_point, dont le rôle est de calculer les coordonnées d'un point lié au solide, se sert de l'argument self pour désigner l'objet sur lequel la fonction agit, par exemple self.Rx désigne la variable Rx de l'objet en cours de traitement. Voyons comment utiliser cette fonction avec l'objet créé ci-dessus :

[X,Y] = solide_1.coord_point(1,0)

La référence de l'objet (solide_1) n'est pas fournie avec les autres arguments mais juste avant le point. Elle est transmise à la fonction par l'argument self. Il faut remarquer que le mot self n'est pas un mot clé de Python mais un nom adopté par l'usage. On peut en principe donner le nom que l'on veut à ce premier argument, bien qu'il n'y ait aucune raison de ne pas utiliser self. Le plus important est de ne pas oublier ce premier argument dans les définitions des fonctions de la classe. Bien entendu, on doit utiliser la syntaxe self. à chaque fois qu'on veut accéder à une variable de la classe. Les autres variables apparaissant dans les fonctions, par exemple la variable cos, sont des variables locales, qui cessent d'exister à la fin de la fonction.

4.c. Implémentation des contraintes

Une contrainte est définie par une fonction c(q) qui renvoie une valeur fonction des coordonnées des solides. Une liaison entre deux solides comporte plusieurs contraintes, par exemple deux pour la liaison pivot. Pour chaque contrainte, il n'y a que deux solides concernés, mais l'argument q est un tableau comportant les coordonnées des solides mises à plat. La difficulté de l'implémentation réside dans le grand nombre de types de liaison, chacune ayant ses propres fonctions de contrainte. La programmation orientée objet donne une solution simple à cette difficulté. On commence par définir une classe modèle qui correspond à un ensemble de contraintes :

class Contraintes:
    def __init__(self):
        pass
    def c(q): 
        # définition de la contrainte (c(q)=0)
        # q : [Rx,Ry,theta,...] liste à plat des coordonnées des N solides
        pass
    def Jc(q):
        # définition des lignes du jacobien de C
        pass                       
                       

Cette classe se contente de définir le gabarit de deux fonctions. La fonction c(q) fournit les valeurs de plusieurs fonctions de contrainte (sous forme d'une liste) correspondant à une liaison d'un type donné. La fonction Jc(q) fournit les lignes de la matrice jacobienne pour ces contraintes.

Considérons le cas de la liaison encastrement d'un solide avec le bâti, consistant à fixer les trois coordonnées du solide. Nous définissons une classe pour implémenter cette liaison :

class SolideFixe(Contraintes):
    def __init__(self,i,Rx,Ry,theta):
        self.i = i
        self.Rx = Rx
        self.Ry = Ry
        self.theta = theta
    def c(self,q):
        c1 = q[3*self.i]-self.Rx
        c2 = q[3*self.i+1]-self.Ry
        c3 = q[3*self.i+2]-self.theta
        return numpy.array([c1,c2,c3])
    def Jc(self,q):
        Jc1 = numpy.zeros(len(q))
        Jc1[3*self.i] = 1
        Jc2 = numpy.zeros(len(q))
        Jc2[3*self.i+1] = 1
        Jc3 = numpy.zeros(len(q))
        Jc3[3*self.i+2] = 1
        return numpy.array([Jc1,Jc2,Jc3])   
                        

Dans la déclaration de la classe SolideFixe, on précise que la classe hérite de la classe Contraintes. Cette dernière ne fait rien d'autre que fixer un gabarit pour les fonctions. Dans la classe SolideFixe, ces fonctions sont implémentées et un constructeur est introduit, pour traiter le cas particulier de la liaison encastrement. Le constructeur prend en argument l'indice i qui permet d'itentifier le solide dans une liste. Les autres paramètres transmis sont les trois valeurs de coordonnées à fixer. La fonction c(self,q) calcule les valeurs des trois fonctions de contrainte, qui doivent s'annuler lorsque la contrainte est effectivement réalisée. On remarque que la liste q (qui peut aussi être un tableau ndarray à une dimension) est une liste à plat des coordonnées de tous les solides du système. En conséquence, la première coordonnée du solide d'indice i se trouve à l'indice 3*self.i de ce tableau. La fonction Jc(self,q) calcule et renvoie les trois lignes de la matrice jacobienne correspondant aux trois contraintes.

Pour la liaison pivot, la classe correspondante (à compléter) est :

class Pivot(Contraintes):
    def __init__(self,i,j,xpi,ypi,xpj,ypj):
        self.i = i
        self.j = j
        self.xpi = xpi
        self.ypi = ypi
        self.xpj = xpj
        self.ypj = ypj
    def c(q):
        # à compléter
    def Jc(q):
        # à compléter
                              

Pour cette liaison, on doit fournir les indices des deux solides et les coordonnées locales des points P_i et P_j liés respectivement au solide i et au solide j.

Voici la classe de la liaison glissière horizontale (à compléter) :

class GlissiereHorizontale(Contraintes):
    def __init__(self,i,Y):
        self.i = i
        self.Y = Y
    def c(q):
        # à compléter
    def Jc(q):
        # à compléter
                              

La liaison glissière entre deux solides est définie par :

class Glissiere(Contraintes):
    def __init__(self,i,j,xpi,ypi,xqi,yqi,xpj,ypj,angle):
        self.i = i
        self.j = j
        self.xpi = xpi
        self.ypi = ypi
        self.xqi = xqi
        self.yqi = yqi
        self.xpj = xpj
        self.ypj = ypj
        self.angle = angle
    def c(q):
        # code fourni dans le fichier annexe
    def Jc(q):
        # code fourni dans le fichier annexe
                              

Voici la classe permettant de fixer l'angle d'un solide à une valeur (qui pourra varier au cours du temps) :

class Angle(Contraintes):
    def __init__(self,i,theta):
        self.i = i
        self.theta = theta
    def c(q):
        # à compléter
    def Jc(q):
        # à compléter
                              

4.d. Système et calcul de la configuration

Nous devons finalement définir une classe Systeme qui stocke la définition du système (solides et contraintes) et qui implémente l'algorithme de calcul de la configuration, c'est-à-dire le calcul des coordonnées des N solides, compte tenu de la présence des 3N contraintes.

class Systeme:
    def __init__(self):
        self.liste_solides = []
        self.liste_contraintes = []
        self.n = 0
    def ajouter_solide(self,solide):
        self.liste_solides.append(solide)
        self.n += 3
    def ajouter_contrainte(self,contrainte):
        self.liste_contraintes.append(contrainte)
    def dessiner(self,ax):
        for solide in self.liste_solides:
            solide.dessiner(ax)
    def redessiner(self,ax):
        for solide in self.liste_solides:
            solide.redessiner(ax)
    def coordonnees(self):
        # renvoie la liste des coordonnées des solides (q)
    def jacobien(self,q):
        # renvoie la matrice jacobienne J
    def C(self,q):
        #renvoie la liste des valeurs des Ck(q) (matrice colonne C)
    def calcul(self,tolerance,max_iter=100):
        # effectue le calcul de la configuration par la méthode de Newton
        # et modifie les coordonnées des solides
                    

Les données de l'objet Systeme sont : une liste d'objets Solide, une liste d'objets Contraintes, et le nombre de contraintes à fournir (3 fois le nombre de solides). Les deux listes sont remplies comme des piles mais chaque solide est référencé par son indice, c'est-à-dire son ordre d'entrée dans la pile. Lorsqu'on définit les contraintes, il faut déjà connaître l'indice de chaque solide. Dans une version plus évoluée, on pourra bien sûr mettre en place un mode de référencement plus facile à utiliser, par exemple en attribuant un nom à chaque solide.

Les différentes matrices (q,J,C) doivent être générées dans des tableaux ndarray.

Le cœur de l'algorithme (la méthode de Newton-Raphson) est implémentée dans la fonction calcul. Il peut arriver que la méthode de Newton ne converge pas, ce qui se traduit par l'impossibilité de parvenir au critère de convergence. Il faut donc prévoir un nombre maximal d'itérations à ne pas dépasser. Si ce nombre est atteint, la boucle est stoppée et un message d'erreur doit s'afficher. La résolution du système d'équations se fait avec la fonction numpy.linalg.solve (qui implémente la méthode d'élimination de Gauss). On remarquera que le calcul d'incrémentation des coordonnées peut se faire directement avec le tableau q et le tableau δq. Lorsque la boucle de calcul est terminée, c'est-à-dire lorsque le critère de convergence $\mathrm{(38)}$ est satisfait, il est nécessaire de mettre à jour les coordonnées des solides, car celles-ci sont utilisées par les fonctions de tracé.