Discussion :

[michelmich]

Bonjour à tous,

Malgré quelques utilisations de Matlab dans le passé, je suis relativement novice et je suis confronté à un problème qui semble assez banal chez les débutants en Matlab:

Lorsque j'execute mon code, le message suivant s'inscrit:
"In an assignment A(I) = B, the number of elements in B and I must be the same.

Error in fonctionAcc (line 59)
VYRFGeom (i)= VRF * sin(atan(ALPHA - RAYON * sin(BETA) / (Vlacet(i-1) * cos(BETA) - Voieavant / 2)));"


J'ai bien évidemment effectué quelques recherches, et je comprend que la taille des vecteurs à droite et à gauche de la parenthèse ne sont pas identiques.
Seulement.... Je ne comprend absolument pas pourquoi, je pense que je ne saisis pas la manière dont Matlab interprète/calcule mon code.
Pour moi, je fais mes calculs entre des scalaires et des composantes de vecteurs qui sont elles aussi des scalaires, donc pas de soucis.

Je vous joins mon code pour plus de clareté:

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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
function AccYMax=fonctionAcc(RAYON, ALPHA, BETA) %RAYON, ALPHA et BETA sont des constantes
 
MasseMs = 200;
CentrageM = 0.5;
MasseMnSAV = 20;
MasseMnSAR = 20;
Massepilote = 70;
HcdGMnS = 0.3;
ZHcdGMS = 0.4;
Voieavant = 1.5;
Voiearriere = 1.5;
empattement = 3;
RaideurressortAV = 10;
RaideurressortAR = 10;
RaideurBARAV = 10;
RaideurBARAR = 10;
RaideurPNEU = 10;
InertieTanguage = 10;
ButeedetenteOhlins = 0.2;
ButeecompressionOhlins = 0.5;
PackersAV = 0.2;
CdRAV = 0.3;
CdRAR = 0.7;
OuvertureD = 1;
OuvertureG = 1;
CarossageD = 1;
CarossageG = 1;
HdCD = 0.4;
HdCG = 0.3;
MRRAV=1.2;
MRRAR=1.2;
MRARBAV=0.5;
MRARBAR=0.5;
CdG=0.7;
 
%Initialisation Accélération LAT
Ayinit = 1;
 
%Calcul du poids au roue inital
MasseTot = Massepilote + MasseMs + MasseMnSAV + MasseMnSAR;
FZAvd = MasseTot * (1 - CentrageM) / 4;
FZAvg = MasseTot * (1 - CentrageM) / 4;
FZArd = MasseTot * CentrageM / 4;
FZArg = MasseTot * CentrageM / 4;
 
%Calcul Vitesse liénaire/lacet initiale
V(1) = sqrt(RAYON * Ayinit);
Vlacet(1) = Ayinit / V(1);
 
for i=2:4
 
 
%Calcul des angles de dérives
 
%FRONT
%Geometric
VRF (i) = RAYON * Vlacet(i-1);
VYRFGeom (i)= VRF * sin(atan(ALPHA - RAYON * sin(BETA) / (Vlacet(i-1) * cos(BETA) - Voieavant / 2))); -->ZONE DE L ERREUR
VXRFGeom (i)= VRF * cos(atan(ALPHA - RAYON * sin(BETA) / (Vlacet(i-1) * cos(BETA) - Voieavant / 2)));
 
%From Yaw Speed
VXRFYawSpeed (i)= (sqrt(Voieavant / 2 + (CentrageM) * empattement) * Vlacet(i-1)* cos(atan(Voieavant / 2 / ((CentrageM) * empattement))));
VYRFYawSpeed (i)= (sqrt(Voieavant / 2 + (CentrageM) * empattement) * Vlacet(i-1) * sin(atan(Voieavant / 2 / ((CentrageM) * empattement))));
 
VYRF(i) = VYRFGeom(i) + VYRFYawSpeed(i);
VXRF (i)= VXRFGeom(i)+ VXRFYawSpeed(i);
 
%Final value for front (Approximation Slipangle avant droite = slip angle avant gauche)
SlipAngleRF(i) = atan(VYRF(i) / VXRF(i));
SlipAngleLF (i)= SlipAngleRF(i); %Il faudrait connaitre l'ackerman de la FE
 
%REAR
%Geometric
VRR(i) = RAYON * Vlacet(i-1);
VYRRGeom(i) = VRR(i) * sin(atan(RAYON * sin(BETA) / (Vlacet(i) * cos(BETA) - Voiearriere / 2)));
VXRRGeom(i) = VRR(i) * cos(atan(RAYON * sin(BETA) / (Vlacet(i) * cos(BETA) - Voiearriere / 2)));
 
%From Yaw Speed
VXRRYawSpeed(i) = (sqrt(Voiearriere / 2 + (1 - CentrageM) * empattement) * Vlacet(i) * cos(atan(Voiearriere / 2 / ((1 - CentrageM) * empattement))));
VYRRYawSpeed(i) = (sqrt(Voiearriere / 2 + (1 - CentrageM) * empattement) * Vlacet(i) * sin(atan(Voiearriere / 2 / ((1 - CentrageM) * empattement))));
 
VYRR(i) = VYRRGeom(i) + VYRRYawSpeed(i);
VXRR(i) = VXRRGeom(i) + VXRRYawSpeed(i);
 
%Final value for front (Approximation Slipangle avant droite = slip angle avant gauche)
SlipAngleRR(i) = atan(VYRR(i) / VXRR(i));
SlipAngleLR(i) = SlipAngleRR(i);
 
 
%Appel des fonctions de Pacejka
%Call FY(FZ, ALP, GAM, KPU, PNEU)
 
FYAvd(i) = FY(FZAvd(i), SlipAngleRF(i), CarossageD, 0.1) %fonction définie en parallèle
FYAvg(i) = FY(FZAvg(i), SlipAngleLF(i), CarossageG, 0.1)
FYArd(i) = FY(FZArd(i), SlipAngleRR(i), CarossageD, 0.1)
FYArg(i) = FY(FZArg(i), SlipAngleLR(i), CarossageG, 0.1)
 
 
%Calcul de l'Ay correspondant
Acc(i) = (FYAvd(i) + FYAvg(i) + FYArd(i) + FYArg(i)) / MasseTot;
 
%Calcul de l'angle de roulis
RaideurRoulisPneuAV = RaideurPNEU * Voieavant * Voieavant / 2;
RaideurRoulisPneuAR = RaideurPNEU * Voiearriere * Voiearriere / 2;
RaideurRoulisPneu = RaideurRoulisPneuAV + RaideurRoulisPneuAR;
RaideurRoulisBARAV = RaideurBARAV * MRARBAV * MRARBAV;
RaideurRoulisBARAR = RaideurBARAR * MRARBAR * MRARBAR;
RaideurRoulisBAR = RaideurRoulisBARAV + RaideurRoulisBARAR;
RaideurRoulisRessortAV = RaideurressortAV * (3.14 / 180) * 0.5 / (MRRAV * MRRAV) * Voieavant * Voieavant;
RaideurRoulisRessortAR = RaideurressortAR * (3.14 / 180) * 0.5 / (MRRAR * MRRAR) * Voiearriere * Voiearriere;
RaideurRoulisRessort = RaideurRoulisRessortAV + RaideurRoulisRessortAR;
AntiRollTorqueFront = (RaideurRoulisRessortAV + RaideurRoulisBARAV) * RaideurRoulisPneuAV / (RaideurRoulisRessortAV + RaideurRoulisBARAV + RaideurRoulisPneuAV);
AntiRollTorqueRear = (RaideurRoulisRessortAR + RaideurRoulisBARAR) * RaideurRoulisPneuAR / (RaideurRoulisRessortAR + RaideurRoulisBARAR + RaideurRoulisPneuAR);
RollAngle(i) = (MasseMs * Acc(i) * (CdG - ((CdRAV + CdRAR) / 2))) / (RaideurRoulisPneu + RaideurRoulisBAR + RaideurRoulisRessort)
 
 
%Calcul des nouveaux transferts de charge
SElasticWTfront(i) = MasseMs * (1 - CentrageM) * Acc(i) * (CdG - CdRAV) / Voieavant * (AntiRollTorqueFront / (AntiRollTorqueFront + AntiRollTorqueRear));
SElasticWTrear(i) = MasseMs * CentrageM * Acc(i) * (CdG - CdRAR) / Voiearriere * (AntiRollTorqueRear / (AntiRollTorqueFront + AntiRollTorqueRear));
LatGeoWT(i) = MasseMs * Acc(i) * CdRAV / ((Voieavant + Voiearriere) / 2);
LatNsWT(i) = ((MasseMnSAV + MasseMnSAR) / 2 * Acc(i) * HcdGMnS) / ((Voieavant + Voiearriere) / 2);
 
 
%Calcul du poids au roues
FZAvd(i) = MasseTot * (1 - CentrageM) / 4 + SElasticWTfront(i) + LatGeoWT(i) + LatNsWT(i);
FZAvg(i) = MasseTot * (1 - CentrageM) / 4 - SElasticWTfront(i) - LatGeoWT(i) - LatNsWT(i);
FZArd(i) = MasseTot * CentrageM / 4 + SElasticWTrear(i) + LatGeoWT(i) + LatNsWT(i);
FZArg(i) = MasseTot * CentrageM / 4 - SElasticWTrear(i) - LatGeoWT(i) - LatNsWT(i);
 
%Calcul de la nouvelle vitesse
V(i) = sqrt(RAYON * Acc(i));
Vlacet(i) = Acc(i) / V(i);
 
end
AccYMax = Acc(4)
 
end

Je sais que la cause de mon problème sera repéré rapidement pas certains d'entre vous, je me permet donc de poster.

Merci à tous

[Gooby]

Bonjour,

Tu as oublié l'indice sur VRF je pense:

Code :

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

1
2
VYRFGeom (i)= VRF(i) * sin(atan(ALPHA - RAYON * sin(BETA) / (Vlacet(i-1) * cos(BETA) - Voieavant / 2))); % -->ZONE DE L ERREUR
VXRFGeom (i)= VRF(i) * cos(atan(ALPHA - RAYON * sin(BETA) / (Vlacet(i-1) * cos(BETA) - Voieavant / 2)));

[michelmich]

Alors la, je ne peux que me cacher derrière ma bêtise, et te remercier de m'avoir éclairé... Après avoir passé une heure à chercher l'erreur ailleurs, elle était en fait très simple! Merci beaucoup

Maintenant que la boucle marche, j'en profite pour poser une seconde question: les valeurs générées, et notamment celle qui m'intéresse, "AccYMax", est un nombre imaginaire.. Comment cela est possible? Comment résoudre ce problème?

J'ai l'impression que toutes les questions classiques du programmeur débutant en Matlab me tombent sous le nez en même temps

[Gooby]

Ne connaissant pas la fonction FY que tu utilises, j'aurai peine à comprendre la logique des résultats retournés.

[michelmich]

C'est vrai, excuse moi.


La fonction FY retourne une force en N, donc normalement un scalaire, et sa fonction est la suivante:

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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
function FY=FY(FZ, ALP, GAM, KPU)
 
COEF=3,1415927 / 180
GAM=GAM * COEF
ALP=ALP * COEF
KPU=KPU / 100
 
 
data=dlmread('C:\Users\stagiaire3\Documents\Pac.txt') %ici les valeurs du fichier importé sont 2 colonnes de nombres, dans un txt
 
BREFF=data(1);
DREFF=data(2);
FREFF=data(3);
FNOMIN=data(4);
LFZ0=data(5);
LCX=data(6);
MBELT=data(7);
LMUX=data(8);
LEX=data(9);
LKX=data(10);
LHX=data(11);
LVX=data(12);
LCY=data(13);
LMUY=data(14);
LEY=data(15);
LKY=data(16);
LHY=data(17);
LVY=data(18);
LGAY=data(19);
LTR=data(20);
LRES=data(21);
LGAZ=data(22);
LXAL=data(23);
LYKA=data(24);
LVYKA=data(25);
LS=data(26);
LSGKP=data(27);
LSGAL=data(28);
LGYR=data(29);
LMX=data(30);
LMY=data(31);
PCX1=data(32);
PDX1=data(33);
PDX2=data(34);
PEX1=data(35);
PEX2=data(36);
PEX3=data(37);
PEX4=data(38);
PKX1=data(39);
PKX2=data(40);
PKX3=data(41);
PHX1=data(42);
PHX2=data(43);
PVX1=data(44);
PVX2=data(45);
RBX1=data(46);
RBX2=data(47);
RCX1=data(48);
RHX1=data(49);
PTX1=data(50);
PTX2=data(51);
PTX3=data(52);
QSX1=data(53);
QSX2=data(54);
QSX3=data(55);
PCY1=data(56);
PDY1=data(57);
PDY2=data(58);
PDY3=data(59);
PEY1=data(60);
PEY2=data(61);
PEY3=data(62);
PEY4=data(63);
PKY1=data(64);
PKY2=data(65);
PKY3=data(66);
PHY1=data(67);
PHY2=data(68);
PHY3=data(69);
PVY1=data(70);
PVY2=data(71);
PVY3=data(72);
PVY4=data(73);
RBY1=data(74);
RBY2=data(75);
RBY3=data(76);
RCY1=data(77);
RHY1=data(78);
RVY1=data(79);
RVY2=data(80);
RVY3=data(81);
RVY4=data(82);
RVY5=data(83);
RVY6=data(84);
PTY1=data(85);
PTY2=data(86);
QSY1=data(87);
QSY2=data(88);
QBZ1=data(89);
QBZ2=data(90);
QBZ3=data(91);
QBZ4=data(92);
QBZ5=data(93);
QBZ9=data(94);
QBZ10=data(95);
QCZ1=data(96);
QDZ1=data(97);
QDZ2=data(98);
QDZ3=data(99);
QDZ4=data(100);
QDZ6=data(101);
QDZ7=data(102);
QDZ8=data(103);
QDZ9=data(104);
QEZ1=data(105);
QEZ2=data(106);
QEZ3=data(107);
QEZ4=data(108);
QEZ5=data(109);
QHZ1=data(110);
QHZ2=data(111);
QHZ3=data(112);
QHZ4=data(113);
SSZ1=data(114);
SSZ2=data(115);
SSZ3=data(116);
SSZ4=data(117);
QTZ1=data(118);
 
 
DFZ = (FZ - LFZ0 * FNOMIN) / (LFZ0 * FNOMIN);
GAMY = GAM * LGAY;
SVY = FZ * (PVY1 + PVY2 * DFZ + (PVY3 + PVY4 * DFZ) * GAMY) * LVY * LMUY;
SHY = (PHY1 + PHY2 * DFZ + PHY3 * GAMY) * LHY;
ALPY = ALP + SHY;
CY = PCY1 * LCY;
MUY = (PDY1 + PDY2 * DFZ) * (1 - PDY3 * GAMY * GAMY) * LMUY;
DY = MUY * FZ;
EY = (PEY1 + PEY2 * DFZ) * (1 - (PEY3 + PEY4 * GAMY) * sign(ALPY)) * LEY;
if (EY>1)
   EY = 1;
end 
KY = PKY1 * FNOMIN * sin(2 * atan(FZ / (PKY2 * FNOMIN * LFZ0))) * (1 - PKY3 * abs(GAMY)) * LFZ0 * LKY;
BY = KY / (CY * DY);
FYint = DY * sin(CY * atan(BY * ALPY - EY * (BY * ALPY - atan(BY * ALPY)))) + SVY; 
CYK = RCY1;
SHYK = RHY1;
DVYK = MUY * FZ * (RVY1 + RVY2 * DFZ + RVY3 * GAM) * cos(atan(RVY4 * ALP));
SVYK = DVYK * sin(RVY5 * atan(RVY6 * KPU)) * LVYKA;
BYK = RBY1 * cos(atan(RBY2 * (ALP - RBY3))) * LYKA;
GYK = cos(CYK * atan(BYK * (KPU + SHYK))) / cos(CYK * atan(BYK * SHYK));
FY = FYint * GYK + SVYK
 
end

Je ne vois pas pourquoi il me revois un nombre imaginaire...

[Beltharion]

Bonjour,

Pour commencer un nombre scalaire peut être complexe. Scalaire veut simplement dire que tu as une matrice de taille (1,1).
Tu devrais commencer par vérifier tes données. Si tes données n'ont pas de problèmes, tu peux vérifier tes calculs ligne par ligne. Cela va te permettre de localiser ton problème.

Bon courage