Bonjour,

Mon problème concerne l’utilisation du Solver (peu importe celui utilisé) de Matlab.
Je dois résoudre un système de N équations différentielles d’ordre 2, MAIS en plus, chacune à plusieurs définitions en fonctions de « l’ordre » (harmonique) du calcul.

Voici le code que j’utilise :

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
 
close all
clear all
clc
warning off
 
global Nbr_elements Inertie Raideur Amor_Relatif Amor_Absolu  M_iq
 
Nbr_elements = 4; % Nombre d'éléments du modèle
 
% Inertie de chaque élément
Inertie=[ 1 0 0 0;
          0 2 0 0;
          0 0 3 0;
          0 0 0 4];
 
% Raideur de chaque élément
Raideur=[ 1 0 0 0;
          0 2 0 0;
          0 0 3 0;
          0 0 0 4];
 
% Amortissement relatif
Amor_Relatif=[ .3 0 0 0;
          0 .2 0 0;
          0 0 .3 0;
          0 0 0 .2];
 
% Amortissement relatif
Amor_Absolu=[ 100 0 0 0;
          0 200 0 0;
          0 0 100 0;
          0 0 0 200];
 
Tfin = 10 * pi;
 
Teta = 0;
Teta_p = 0;
 
[t,y] = ode45('Equations', [0 Tfin], [Teta Teta_p]);
 
 
 ******************************
 
function Teta_pp = Equations (t, Teta)
 
global Nbr_elements Inertie Raideur Amor_Relatif Amor_Absolu
 
% Définition des équations du mouvement, il y a autant d'équations que
% d'éléments, avec le premier et le dernier élément défini différement
 
% Boucle pour les 10 ordres (harmoniques) de calcul à faire
for Ordre=0.5:0.5:5
 
    % Définition de l'équation particulière 1
    Teta_pp(1,Ordre) = ( 1/Inertie(1) ) * ( Raideur(2) * ( Teta(2) - Teta(1) ) + ...
                    Amor_Relatif(1) * ( Teta_p(2) - Teta_p(1) ) - ...
                    Teta_p(1) * Amor_Absolu(1) + 53.6 * cost (Ordre*t));
 
    % Définition des équations de 2 à N
    for i=2:(Nbr_elements-1)
        Teta_pp(1,Ordre) = ( 1/Inertie(i) ) * ( ...
                    ( - Raideur(i) ) * ( Teta(i) - Teta(i-1) ) + ...
                    Raideur(i+1) * ( Teta(i+1) - Teta(i) ) - ...
                    Amor_Relatif(i) * ( Teta_p(i) - Teta_p(i-1) ) + ...
                    Amor_Relatif(i+1) * ( Teta_p(i+1) - Teta_p(i) ) - ...
                    Teta_p(i) * Amor_Absolu(i) + 53.6 * cost (Ordre*t));
    end
 
    % Définition de l'équation particulière N
    Teta_pp(Nbr_elements,Ordre) = ( 1/Inertie(Nbr_elements) ) * ( ...
                ( - Raideur(Nbr_elements) ) * ( Teta(Nbr_elements) - Teta(Nbr_elements-1) ) ...
                - Amor_Relatif(Nbr_elements) * ( Teta_p(Nbr_elements) - Teta_p(Nbr_elements-1) ) ...
                - Teta_p(Nbr_elements) * Amor_Absolu(Nbr_elements) + 53.6 * cost (Ordre*t));
 
end
Le problème est que je ne peut me ramener à une forme canonique, puisque j’utilise déjà les indices pour représenter quelque chose (Numéro de l’équation + Ordre du calcul)

Quelqu’un aurait-il déjà rencontré un système de ce genre à résoudre et pourrait m’aider.
Ou quelqu'un aurait une idée ?


PS: Toutes les valeurs prises ne sont qu'indicatives, elles me servaient à tenter de compiler, pour ne laisser que les "vraix" erreurs