correction regime transitoire

R model/main_model_electra.R

@@ -444,10 +444,14 @@ plot(times,u(times), type = "l")
 # plot(times,vitesse, type = "l")
 
 t=1
-vitesse_rotation_moteur(t,u,A,C)
+res = vitesse_rotation_moteur(t,u,A,C)
 res = vitesse_rotation_moteur(times,u,A,C)
 plot(times,res, type = "l")
 
+# angle
+angle_t =  integrate(function(x){vitesse_rotation_moteur(x,u,A,C)},0,t, stop.on.error = F)$value
+angle_all = sapply(times, function(a){integrate(function(x){vitesse_rotation_moteur(x,u,A,C)},0,a, stop.on.error = F)$value})
+plot(times,angle_all)
 
 # moteur 1
 u1=u
@@ -486,12 +490,12 @@ finalTime = 10
 times = seq(0,finalTime, by = timeStep)
 
 u1 = function(t){
-  1
+  2
 }
 
 
 u2 = function(t){
-  2
+  1
 }
 
 
@@ -518,22 +522,25 @@ p <- ggplot(df) + coord_fixed(ratio=1) +
 p
 
 
+res = vitesse_rotation_moteur(times,u1,A1,C1)
+plot(times, res, type = "l")
 
 
-
-dirRes = "plot_transitoire"
+dirRes = "plot_transitoire_1"
 dir.create(dirRes)
-times = seq(0,4, by = 0.02)
+times = seq(0,5, by = 0.02)
+start_time <- Sys.time()
 savePlot_index_and_paramsInFile_TRANSITOIRE(times, dirRes, r1B, r1C, r2D, r2E, r3F, r3G, 
                                             alphaH, alphaI, angleIni_B, angleIni_D, angleIni_F,
                                             A1,C1,A2,C2,A3,C3,
                                             u1,u2,u3)
-
+end_time <- Sys.time()
+end_time - start_time
 
 # savePlot_index_and_paramsInFile(times,dirRes,v1,v2,v3,r1B,r1C,r2D,r2E,r3F,r3G,alphaH,alphaI,angleIni_B,angleIni_D,angleIni_F)
 
 # command line in linux to create a video from images with index (adapt the framerate)
-# ffmpeg -framerate 1/0.02 -i plot_%01d.png -crf 15  output1.mp4
+# ffmpeg -framerate 1/0.02 -i plot_%01d.svg -crf 15  output1.mp4
 
 
 

R model/utils_model_electra.R

@@ -366,13 +366,13 @@ scalarProdutRenormalized = function(x1,y1,x2,y2){
 
 
 # renvoit la vitesse du moteur en fonction de la vitesse demandée
-vitesse_rotation_moteur <- function(times,u,A,C) {
+vitesse_rotation_moteur <- function(time,u,A,C) {
   temp = function(t){
     A/C*u(t)*exp(1/C*t)
   }
   
-  temp2 = unlist(sapply(times, function(t){integrate(temp,0,t)$value}))
-  vitesse = exp(-1/C*times) * temp2
+  temp2 = unlist(sapply(time, function(t){integrate(temp,0,t)$value}))
+  vitesse = exp(-1/C*time) * temp2
 }
 
 
@@ -381,63 +381,120 @@ vitesse_rotation_moteur <- function(times,u,A,C) {
 
 
 
-# TRANSITOIRE (LES VITESSES CHANGENT) Positions des loupiottes en fonction du temps 
-positions_t_TRANSITOIRE = function(t, r1B, r1C, r2D, r2E, r3F, r3G, 
-                                   alphaH, alphaI, angleIni_B, angleIni_D, angleIni_F,
-                                   A1,C1,A2,C2,A3,C3,
-                                   u1,u2,u3){
-  
-  vitesse1 = vitesse_rotation_moteur(t,u1,A1,C1) 
-  vitesse2 = vitesse_rotation_moteur(t,u2,A2,C2) 
-  vitesse3 = vitesse_rotation_moteur(t,u3,A3,C3) 
-  
-  # B,C
-  Bx = r1B * cos(2*pi*vitesse1*t + angleIni_B)    
-  By = r1B * sin(2*pi*vitesse1*t + angleIni_B)   
-  Cx = r1C * cos(2*pi*vitesse1*t + angleIni_B+pi)    
-  Cy = r1C * sin(2*pi*vitesse1*t + angleIni_B+pi)
-  
-  # H,I
-  Hx = Bx / alphaH 
-  Hy = By / alphaH 
-  Ix = Cx / alphaI   
-  Iy = Cy / alphaI 
-  # position de H sur AB: alpha in [1,+infty], =1 => B, =2 milieu de AB, =+infty => A
-  
-  # D,E
-  #r1H = r1B / alphaH 
-  HDx = r2D  * cos(2*pi*(vitesse2+vitesse1)*t + (angleIni_D+ angleIni_B))
-  HDy = r2D  * sin(2*pi*(vitesse2+vitesse1)*t + (angleIni_D+ angleIni_B))
-  HEx = r2E  * cos(2*pi*(vitesse2+vitesse1)*t + (angleIni_D+ angleIni_B) +pi)
-  HEy = r2E  * sin(2*pi*(vitesse2+vitesse1)*t + (angleIni_D+ angleIni_B) +pi)
-  
-  Dx = Hx + HDx
-  Dy = Hy + HDy
-  Ex = Hx + HEx
-  Ey = Hy + HEy
-  
-  # F,G
-  #r1I = r1C / alphaI 
-  IFx = r3F  * cos(2*pi*(vitesse3+vitesse1)*t + (angleIni_F+ (angleIni_B+pi)) )
-  IFy = r3F  * sin(2*pi*(vitesse3+vitesse1)*t + (angleIni_F+ (angleIni_B+pi)))
-  IGx = r3G  * cos(2*pi*(vitesse3+vitesse1)*t + (angleIni_F+ (angleIni_B+pi)) +pi)
-  IGy = r3G  * sin(2*pi*(vitesse3+vitesse1)*t + (angleIni_F+ (angleIni_B+pi)) +pi)
-  
-  Fx = Ix + IFx
-  Fy = Iy + IFy
-  Gx = Ix + IGx
-  Gy = Iy + IGy
-  
-  
-  return(data.frame(Bx = Bx, By = By, Cx = Cx, Cy = Cy,
-                    Hx = Hx, Hy = Hy,
-                    Dx = Dx, Dy = Dy, Ex = Ex, Ey = Ey,
-                    Ix = Ix, Iy = Iy,
-                    Fx = Fx, Fy = Fy, Gx = Gx, Gy = Gy,
-                    time = t))
-
-}
-
+# next_positions_t_TRANSITOIRE = function(t, r1B, r1C, r2D, r2E, r3F, r3G, 
+#                                    alphaH, alphaI, 
+#                                    #angleIni_B, angleIni_D, angleIni_F,
+#                                    A1,C1,A2,C2,A3,C3,
+#                                    u1,u2,u3,
+#                                    Bx,By,Cx,Cy,
+#                                    Hx,Hy,
+#                                    Dx,Dy,Ex,Ey,
+#                                    Ix,Iy,
+#                                    Fx,Fy,Gx,Gy,
+#                                    currentStateDf, deltaT){
+#   
+#   vitesse1 = vitesse_rotation_moteur(t,u1,A1,C1) 
+#   vitesse2 = vitesse_rotation_moteur(t,u2,A2,C2) 
+#   vitesse3 = vitesse_rotation_moteur(t,u3,A3,C3) 
+#   
+#   # B,C
+#   newBx = currentStateDf$Bx + r1B * cos(2*pi*vitesse1*deltaT)    
+#   newBy = currentStateDf$By + r1B * sin(2*pi*vitesse1*deltaT ) #+ angleIni_B   
+#   newCx = currentStateDf$Cx + r1C * cos(2*pi*vitesse1*deltaT ) #+angleIni_B+pi    
+#   newCy = currentStateDf$Cy + r1C * sin(2*pi*vitesse1*deltaT ) #+ angleIni_B+pi
+#   
+#   # H,I
+#   newHx = newBx / alphaH 
+#   newHy = newBy / alphaH 
+#   newIx = newCx / alphaI   
+#   newIy = newCy / alphaI 
+#   # position de H sur AB: alpha in [1,+infty], =1 => B, =2 milieu de AB, =+infty => A
+#   
+#   # D,E
+#   #r1H = r1B / alphaH 
+#   newHDx = currentStateDf$HDx + r2D  * cos(2*pi*(vitesse2+vitesse1)*deltaT) # + (angleIni_D+ angleIni_B))
+#   newHDy = currentStateDf$HDy + r2D  * sin(2*pi*(vitesse2+vitesse1)*deltaT) # + (angleIni_D+ angleIni_B))
+#   newHEx = currentStateDf$HEx + r2E  * cos(2*pi*(vitesse2+vitesse1)*deltaT) # + (angleIni_D+ angleIni_B) +pi)
+#   newHEy = currentStateDf$HEy + r2E  * sin(2*pi*(vitesse2+vitesse1)*deltaT) # + (angleIni_D+ angleIni_B) +pi)
+#   
+#   newDx = newHx + newHDx
+#   newDy = newHy + newHDy
+#   newEx = newHx + newHEx
+#   newEy = newHy + newHEy
+#   
+#   # F,G
+#   #r1I = r1C / alphaI 
+#   newIFx = currentStateDf$IFx + r3F  * cos(2*pi*(vitesse3+vitesse1)*deltaT) #+ (angleIni_F+ (angleIni_B+pi)) )
+#   newIFy = currentStateDf$IFy + r3F  * sin(2*pi*(vitesse3+vitesse1)*deltaT) #+ (angleIni_F+ (angleIni_B+pi)))
+#   newIGx = currentStateDf$IGx + r3G  * cos(2*pi*(vitesse3+vitesse1)*deltaT) #+ (angleIni_F+ (angleIni_B+pi)) +pi)
+#   newIGy = currentStateDf$IGy + r3G  * sin(2*pi*(vitesse3+vitesse1)*deltaT) #+ (angleIni_F+ (angleIni_B+pi)) +pi)
+#   
+#   newFx = newIx + newIFx
+#   newFy = newIy + newIFy
+#   newGx = newIx + newIGx
+#   newGy = newIy + newIGy
+#   
+#   
+#   return(data.frame(Bx = newBx, By = newBy, Cx = newCx, Cy = newCy,
+#                     Hx = newHx, Hy = newHy,
+#                     Dx = newDx, Dy = newDy, Ex = newEx, Ey = newEy,
+#                     Ix = newIx, Iy = newIy,
+#                     Fx = newFx, Fy = newFy, Gx = newGx, Gy = newGy,
+#                     time = t+deltaT))
+# 
+# }
+
+
+# create_position_ini_TRANSITOIRE = function(r1B, r1C, r2D, r2E, r3F, r3G, 
+#                                     alphaH, alphaI, 
+#                                     angleIni_B, angleIni_D, angleIni_F){
+#     
+#     # B,C
+#     Bx = r1B * cos(angleIni_B)    
+#     By = r1B * sin(angleIni_B)   
+#     Cx = r1C * cos(angleIni_B+pi)    
+#     Cy = r1C * sin(angleIni_B+pi)
+#     
+#     # H,I
+#     Hx = Bx / alphaH 
+#     Hy = By / alphaH 
+#     Ix = Cx / alphaI   
+#     Iy = Cy / alphaI 
+#     
+#     # D,E
+#     HDx = r2D  * cos((angleIni_D+ angleIni_B))
+#     HDy = r2D  * sin((angleIni_D+ angleIni_B))
+#     HEx = r2E  * cos((angleIni_D+ angleIni_B) +pi)
+#     HEy = r2E  * sin((angleIni_D+ angleIni_B) +pi)
+#     
+#     Dx = Hx + HDx
+#     Dy = Hy + HDy
+#     Ex = Hx + HEx
+#     Ey = Hy + HEy
+#     
+#     # F,G
+#     #r1I = r1C / alphaI 
+#     IFx = r3F  * cos((angleIni_F+ (angleIni_B+pi)) )
+#     IFy = r3F  * sin((angleIni_F+ (angleIni_B+pi)))
+#     IGx = r3G  * cos((angleIni_F+ (angleIni_B+pi)) +pi)
+#     IGy = r3G  * sin((angleIni_F+ (angleIni_B+pi)) +pi)
+#     
+#     Fx = Ix + IFx
+#     Fy = Iy + IFy
+#     Gx = Ix + IGx
+#     Gy = Iy + IGy
+#     
+#     
+#     return(data.frame(Bx = Bx, By = By, Cx = Cx, Cy = Cy,
+#                       Hx = Hx, Hy = Hy,
+#                       Dx = Dx, Dy = Dy, Ex = Ex, Ey = Ey,
+#                       Ix = Ix, Iy = Iy,
+#                       Fx = Fx, Fy = Fy, Gx = Gx, Gy = Gy,
+#                       time = 0)
+#     )  
+#   
+# }  
+    
 
 
 
@@ -520,6 +577,8 @@ create_df_TRANSITOIRE = function(times, r1B, r1C, r2D, r2E, r3F, r3G,
 
 
 
+
+
 # function to save all plots (%time)
 savePlot_index_TRANSITOIRE = function(times, dirRes, r1B, r1C, r2D, r2E, r3F, r3G, 
                                       alphaH, alphaI, angleIni_B, angleIni_D, angleIni_F,
@@ -636,3 +695,69 @@ savePlot_index_and_paramsInFile_TRANSITOIRE = function(times, dirRes, r1B, r1C,
   }
 
 
+
+
+
+
+positions_t_TRANSITOIRE= function(t, r1B, r1C, r2D, r2E, r3F, r3G, 
+                                  alphaH, alphaI, angleIni_B, angleIni_D, angleIni_F,
+                                  A1,C1,A2,C2,A3,C3,
+                                  u1,u2,u3){
+  
+  angle1_t =  integrate(function(x){vitesse_rotation_moteur(x,u1,A1,C1)},0,t, stop.on.error = F)$value
+  angle2_t =  integrate(function(x){vitesse_rotation_moteur(x,u2,A2,C2)},0,t, stop.on.error = F)$value
+  angle3_t =  integrate(function(x){vitesse_rotation_moteur(x,u3,A3,C3)},0,t, stop.on.error = F)$value
+  
+  
+  # B,C
+  Bx = r1B * cos(2*pi*angle1_t + angleIni_B)    
+  By = r1B * sin(2*pi*angle1_t + angleIni_B)   
+  Cx = r1C * cos(2*pi*angle1_t + angleIni_B+pi)    
+  Cy = r1C * sin(2*pi*angle1_t + angleIni_B+pi)
+  
+  # H,I
+  Hx = Bx / alphaH 
+  Hy = By / alphaH 
+  Ix = Cx / alphaI   
+  Iy = Cy / alphaI 
+  # position de H sur AB: alpha in [1,+infty], =1 => B, =2 milieu de AB, =+infty => A
+  
+  # D,E
+  #r1H = r1B / alphaH 
+  HDx = r2D  * cos(2*pi*(angle1_t+angle2_t) + (angleIni_D+ angleIni_B))
+  HDy = r2D  * sin(2*pi*(angle1_t+angle2_t) + (angleIni_D+ angleIni_B))
+  HEx = r2E  * cos(2*pi*(angle1_t+angle2_t) + (angleIni_D+ angleIni_B) +pi)
+  HEy = r2E  * sin(2*pi*(angle1_t+angle2_t) + (angleIni_D+ angleIni_B) +pi)
+  
+  Dx = Hx + HDx
+  Dy = Hy + HDy
+  Ex = Hx + HEx
+  Ey = Hy + HEy
+  
+  # F,G
+  #r1I = r1C / alphaI 
+  IFx = r3F  * cos(2*pi*(angle1_t+angle3_t) + (angleIni_F+ (angleIni_B+pi)) )
+  IFy = r3F  * sin(2*pi*(angle1_t+angle3_t) + (angleIni_F+ (angleIni_B+pi)))
+  IGx = r3G  * cos(2*pi*(angle1_t+angle3_t) + (angleIni_F+ (angleIni_B+pi)) +pi)
+  IGy = r3G  * sin(2*pi*(angle1_t+angle3_t) + (angleIni_F+ (angleIni_B+pi)) +pi)
+  
+  Fx = Ix + IFx
+  Fy = Iy + IFy
+  Gx = Ix + IGx
+  Gy = Iy + IGy
+  
+  
+  return(data.frame(Bx = Bx, By = By, Cx = Cx, Cy = Cy,
+                    Hx = Hx, Hy = Hy,
+                    Dx = Dx, Dy = Dy, Ex = Ex, Ey = Ey,
+                    Ix = Ix, Iy = Iy,
+                    Fx = Fx, Fy = Fy, Gx = Gx, Gy = Gy) )
+}
+
+
+
+
+
+
+
+

rapport/modele_electra.tex

@@ -412,7 +412,7 @@ solution, en imposant $y(0) = \omega(0) = 0$: $\omega(t) := y(t) = e^{-\frac{t}{
 
 
 On suppose les trois moteurs "indépendants", ils ont chacun leurs paramètres (électriques et mécaniques) mais fonctionnent selon les mêmes équations.
-Dans le régime stationnaire, on supposait la vitesse des moteurs constante au cours du temps (égale  respectivement à $v_1$, $v_2$ et $v_3$). Désormais, cette vitesse $\omega_1, \omega_2, \omega_3$ peut varier au cours du temps, en particulier, on suppose qu'elle est nulle initialement, puis qu'on applique une tension au moteur. Les équations de la dynamique dans le cadre stationnaire sont ainsi conservées, et seule la vitesse $v_i$ est remplacée par $\omega_i$.
+Dans le régime stationnaire, on supposait la vitesse des moteurs constante au cours du temps (égale  respectivement à $v_1$, $v_2$ et $v_3$). Désormais, cette vitesse $\omega_1, \omega_2, \omega_3$ peut varier au cours du temps, en particulier, on suppose qu'elle est nulle initialement, puis qu'on applique une tension au moteur. Les équations de la dynamique dans le cadre stationnaire sont ainsi conservées, et seule la vitesse $v_i$ est remplacée par $\omega_i$, donc l'angle à l'instant $t$ n'est plus $v_1 *t$ mais $ \int_0^t v_1(x)dx$ (condition initiale nulle).
 
 Remarque: Si on applique une tension constante $U$, la vitesse de rotation en sortie tend vers $U*A$. On peut déduire de cette dernière égalité la valeur de la tension à appliquer au moteur pour obtenir la vitesse de rotation désirée.