Discussion :

[Totor63]

Bonjour.

Je dois effectuer un programme sous MatLab qui va permettre de déterminer la résistance d'un pont soumis au passage d'un train en mouvement. Dans un premier temps, nous devons étudier le comportement du pont seul, à partir de ses matrices de rigidité K et de masse M.

Ce pont se décompose en n éléments et chaque élément est composé de 2 nœuds. En sachant que, par exemple, le nœud 2 est présent à la fin de l'élément 1 et au début de l'élément 2. L'objectif, sur MatLab, est de déterminer les matrices globales du pont, en sachant que l'on connait les matrices pour chaque élément. Il faut donc faire une addition de matrice en décalé puisque, pour l'élément 1, les lignes/colonnes 3-4 correspondent au nœud 2 et pour l'élément 2, les lignes/colonnes 1-2 correspondent aussi au nœud 2 donc lors de la création de la matrice générale, les lignes/colonnes correspondant au nœud 2 vont s'additionner et ainsi de suite pour chaque nœud (excepté pour les nœuds 1 et n qui sont aux extrémités du pont).

Le problème que je rencontre est que je ne sais pas comment on fait ce type d'addition (en décalé) car je ne maîtrise pas très bien MatLab.

Merci de votre aide.

Cordialement,

Victor.

[shaiHulud]

Bonjour,

Il y a plusieurs approches selon le type de décalage, par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
X(2:end;:)+ Y(1:end-1,:); % Décalage simple (lag constant) 
X+ Y(Z,:); % Décalage spécifié par un autre vecteur Z(i) donne la ligne de Y qu'on additionne à X(i,:);
 
somme=[];
for n=1:N % on peut aussi tout faire avec une boucle et des fonctions
    m= find_index(n);
    somme(n)= X(n)+Y(m);
end

Avec bien sur pleins de solutions intermédiaire. Pour commencer, essaye de créer un vecteur Z tel que i et Z(i) soient deux indices que tu veux voir additionnés, puis montre nous ton code et dis nous ou tu bloques.

[Jerome Briot]

Ce que tu appelles "décalage" est dû au fait que chaque noeud du modèle a plusieurs inconnnues (degré de liberté ou ddl) associées.

Tu modèlise sans doute le pont à l'aide d'un treillis 2D de barres. Chaque élément possède deux noeuds et chaque noeud deux ddl (u et v).

Les matrices de rigidité élémentaires sont donc de dimension 4x4

Par exemple pour l'élément 1 :

	U1	V1	U2	V2
U1	X	X	X	X
V1	X	X	X	X
U2	X	X	X	X
V2	X	X	X	X

Si par exemple, le modèle ne contient que deux barres (donc trois noeuds), la matrice globale sera de dimension 6x6 :

	U1	V1	U2	V2	U3	V3
U1	X	X	X	X
V1	X	X	X	X
U2	X	X	X	X	X	X
V2	X	X	X	X	X	X
U3			X	X	X	X
V3			X	X	X	X

La position des valeurs dans la matrice globale est directement relié à l'indice du noeud concerné.

Par exemple pour les colonnes (c'est pareil pour les lignes) :

• Noeuds 1 : colonnes 1 et 2 donc pour nk = 1, j = 1, 2
• Noeuds 2 : colonnes 3 et 4 donc pour nk = 2, j = 3, 4
• Noeuds 3 : colonnes 5 et 6 donc pour nk = 3, j = 5, 6

C'est une suite mathématique que je te laisse trouver par toi-même.

Il suffit donc de boucler sur chaque élément, en attribuant les valeurs en fonction des indices des noeuds :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
K = zeros(numNodes,numNodes);
 
for m = 1:numElements
 
    for n = 1:2 % Deux noeuds par element
 
        % Indice du noeud n de l element m
        nk = Elements(m,n);
 
        % Indice correspondant dans K
        i = f(nk);
        j = f(nk);
 
        % Matrice elementaire de l element m
        ke = [...];
 
        % Matrice globale du modele
        K(i,j) = K(i,i)+ke(1,1);
        K(j,i) = K(j,i)+ke(2,1);
        K(i,j) = K(i,j)+ke(1,2);
        K(j,j) = K(j,j)+ke(2,2);            
 
    end
 
end

En pratique, on utilise plutôt une matrice creuse (sparse) pour le stockage de la matrice globale (besoin de moins de mémoire). On utilise alors la fonction sparse en une seul fois. On passe tous les indices et toutes les valeurs et MATLAB se charge de faire la sommation des termes identiques.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
ke{1} = ones(4);
ke{2} = ones(4)+1;
 
i = [1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4 ...
    3 4 5 6 3 4 5 6 3 4 5 6 3 4 5 6];
 
j = [1 1 1 1 2 2 2 2 3 3 3 3 4 4 4 4 ...
     3 3 3 3 4 4 4 4 5 5 5 5 6 6 6 6];
 
Ks = sparse(i,j,[ke{1}(:);ke{2}(:)],6,6);

Ce qui donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
>> ke{1}
 
ans =
 
     1     1     1     1
     1     1     1     1
     1     1     1     1
     1     1     1     1
 
>> ke{2}
 
ans =
 
     2     2     2     2
     2     2     2     2
     2     2     2     2
     2     2     2     2

et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
>> full(Ks)
 
ans =
 
     1     1     1     1     0     0
     1     1     1     1     0     0
     1     1     3     3     2     2
     1     1     3     3     2     2
     0     0     2     2     2     2
     0     0     2     2     2     2