KerMor  0.9
Model order reduction for nonlinear dynamical systems and nonlinear approximation
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
StraightBeam.m
Go to the documentation of this file.
1 namespace models{
2 namespace beam{
3 
4 
5 /* (Autoinserted by mtoc++)
6  * This source code has been filtered by the mtoc++ executable,
7  * which generates code that can be processed by the doxygen documentation tool.
8  *
9  * On the other hand, it can neither be interpreted by MATLAB, nor can it be compiled with a C++ compiler.
10  * Except for the comments, the function bodies of your M-file functions are untouched.
11  * Consequently, the FILTER_SOURCE_FILES doxygen switch (default in our Doxyfile.template) will produce
12  * attached source files that are highly readable by humans.
13  *
14  * Additionally, links in the doxygen generated documentation to the source code of functions and class members refer to
15  * the correct locations in the source code browser.
16  * However, the line numbers most likely do not correspond to the line numbers in the original MATLAB source files.
17  */
18 
19 class StraightBeam
20  :public models.beam.Beam {
39  public:
40 
41 
42  StraightBeam(models.BaseFullModel model,material,pointsidx) {
43  this = this@models.beam.Beam(model, material, pointsidx);
44  this.initialize;
45  }
46 
47 
48  function M = getLocalMassMatrix() {
49 
50  c = this.c;
51  l = this.Length;
52 
53  M_u_block = c(12) * [2 1; 1 2];
54  M_phi_block = c(15) * [2 1; 1 2];
55 
56  d1 = 12*(1680*c(2) + 294*c(7) + 13*c(6));
57  d2 = 4*l^2*(126*c(2) + 21*c(7) + c(6));
58  n1 = 2*l*(1260*c(2) + 231*c(7) + 11*c(6));
59  n2 = l*(2520*c(2) + 378*c(7) + 13*c(6));
60  b1 = 18*(560*c(2) + 84*c(7) + 3*c(6));
61  b2 = 3*l^2*(168*c(2) + 28*c(7) + c(6));
62 
63  factor1 = c(9)*l / (420 * (12*c(1) + c(5))^2 );
64 
65  M_v =factor1 * [
66  d1 n1 b1 -n2;
67  n1 d2 n2 -b2;
68  b1 n2 d1 -n1;
69  -n2 -b2 -n1 d2];
70 
71  M_w = factor1 * [
72  d1 -n1 b1 n2;
73  -n1 d2 -n2 -b2;
74  b1 -n2 d1 n1;
75  n2 -b2 n1 d2];
76 
77  d1 = 36*c(4);
78  d2 = 4*(360*c(2) + 15*c(7) + c(6));
79  n1 = 3*c(3)*(-60*c(1) + c(5));
80  b2 = 720*c(2) - 60*c(7) - c(6);
81  factor2 = c(11)*l / (30 * (12*c(1) + c(5))^2 );
82 
83  M_theta = factor2 * [
84  d1 n1 -d1 n1;
85  n1 d2 -n1 b2;
86  -d1 -n1 d1 -n1;
87  n1 b2 -n1 d2];
88  M_psi = factor2 * [
89  d1 -n1 -d1 -n1;
90  -n1 d2 n1 b2;
91  -d1 n1 d1 n1;
92  -n1 b2 n1 d2];
93 
94  M = [M_u_block zeros(2,2) zeros(2,4) zeros(2,4);
95  zeros(2,2) M_phi_block zeros(2,4) zeros(2,4);
96  zeros(4,2) zeros(4,2) M_v+M_theta zeros(4,4);
97  zeros(4,2) zeros(4,2) zeros(4,4) M_w+M_psi];
98 
99  M = this.TG * M * this.TG^t;
100 
101  /* Komisches umsortieren */
102  index_lok = [1 5 9 3 10 6 2 7 11 4 12 8];
103  M = M(index_lok,index_lok);
104  }
127  function K = getLocalStiffnessMatrix() {
128 
129  c = this.c;
130  l = this.Length;
131 
132  K_u_block = c(13) * [1 -1; -1 1]; /* * E A/L */
133 
134  K_phi_block = c(14)* [1 -1; -1 1]; /* * G I_t/L */
135 
136 
137  d1 = 12*c(8);
138  d2 = 4*c(1)*(3*c(1) + c(5));
139  n1 = 6*l*c(8);
140  b2 = 2*c(1)*(c(5) - 6*c(1));
141  factor3 = 1 / ( l * (12*c(1) + c(5)) );
142 
143  K_v_block = factor3 * [
144  d1 n1 -d1 n1;
145  n1 d2 -n1 b2;
146  -d1 -n1 d1 -n1;
147  n1 b2 -n1 d2];
148 
149  K_w_block = factor3 * [
150  d1 -n1 -d1 -n1;
151  -n1 d2 n1 b2;
152  -d1 n1 d1 n1;
153  -n1 b2 n1 d2];
154 
155  K = [K_u_block zeros(2,2) zeros(2,4) zeros(2,4);
156  zeros(2,2) K_phi_block zeros(2,4) zeros(2,4);
157  zeros(4,2) zeros(4,2) K_v_block zeros(4,4);
158  zeros(4,2) zeros(4,2) zeros(4,4) K_w_block];
159 
160  K = this.TG * K * this.TG^t;
161 
162  /* Komisches umsortieren */
163  index_lok = [1 5 9 3 10 6 2 7 11 4 12 8];
164  K = K(index_lok,index_lok);
165  }
195  function f = getLocalForceMatrix() {
196  l = this.Length;
197  q_lok = (this.c(9) + this.Material.q_plus) * this.T^t;
198 
199  f_u = 0.5 * l * [1; 1; 0; 0];
200  f_v = l/12 * [6; l; 6; -l];
201  f_w = l/12 * [6; -l; 6; l];
202 
203  f = this.TG * (blkdiag(f_u, f_v, f_w) * q_lok);
204 
205  /* Komisches umsortieren */
206  index_lok = [1 5 9 3 10 6 2 7 11 4 12 8];
207  f = f(index_lok,:);
208  }
209 
210 
211  function [K , R , U_pot ] = getLocalTangentials(u) {
212 
213  /* c kodiert Stoffparameter:
214  * c1 = E*I
215  * c2 = c1^2 = (E*I)^2
216  * c3 = G*As*L
217  * c4 = c3^2 = (G*As*L)^2
218  * c5 = G*As*L^2
219  * c6 = c5^2 = (G*As*L^2)^2
220  * c7 = c1*c5 = E*I*G*As*L^2
221  * c8 = c1*G*As = E*I*G*As
222  * c9 = rho*A
223  * c10= q = rho*A*Ortsfaktor
224  * c11 = rho*I
225  * c12 = rho*A*l/6;
226  * c13 = E*A/l;
227  * c14 = G*I_t/l */
228 
229  L = this.Length;
230  c = this.c;
231 
232  /* Potenzielle Energie */
233  U_pot = 0;
234  /* Residuumsvektor */
235  R = zeros(12,1);
236  /* Tangentielle lokale Steifigkeitsmatrix */
237  K = zeros(12);
238 
239  /* lokale Verschiebungen des Elements */
240  u_lok = this.TG^t * u;
241 
242  /* Stoff-Matrizen aufsetzen */
243  D = diag([c(13)*L, c(3)/L, c(3)/L]);
244  E = diag([c(14)*L, c(1), c(1)]);
245 
246 
247  /* % Stützstellen und Gewichte für Gaußquadratur */
248  num_gauss_points = 3;
249  switch (num_gauss_points)
250  case 1
251  /* Exakt bis Grad 1 */
252  s = 0.5*L;
253  w = L;
254  case 2
255  /* Exakt bis Grad 3 */
256  s = 0.5*L * [ (1-sqrt(1/3)), (1+sqrt(1/3)) ];
257  w = 0.5*L * [1 1];
258  case 3
259  /* Exakt bis Grad 5 */
260  s = 0.5*L * [ (1-sqrt(3/5)), 1, (1+sqrt(3/5)) ];
261  w = 0.5*L * 1/9 * [5 8 5];
262  case 4
263  /* Exakt bis Grad 7 */
264  s = 0.5*L * [ ( 1 - sqrt( 3/7 + 2/7*sqrt(6/5) ) ),
265  ( 1 - sqrt( 3/7 - 2/7*sqrt(6/5) ) ),
266  ( 1 + sqrt( 3/7 - 2/7*sqrt(6/5) ) ),
267  ( 1 + sqrt( 3/7 + 2/7*sqrt(6/5) ) )];
268  w = 0.5*L * 1/36 * [18-sqrt(30), 18+sqrt(30), 18+sqrt(30), 18-sqrt(30)];
269  case 5
270  /* Exakt bis Grad 9 */
271  s = 0.5*L * [ 1 - 1/3 * sqrt( 5 + 2*sqrt(10/7) ),
272  1 - 1/3 * sqrt( 5 - 2*sqrt(10/7) ),
273  1,
274  1 + 1/3 * sqrt( 5 - 2*sqrt(10/7) ),
275  1 + 1/3 * sqrt( 5 + 2*sqrt(10/7) )];
276  w = 0.5*L * 1/900 * [322 - 13*sqrt(70), 322 + 13*sqrt(70), 512, 322 + 13*sqrt(70), 322 - 13*sqrt(70)];
277  otherwise
278  /* Exakt bis Grad 5 */
279  s = 0.5*L * [ (1-sqrt(3/5)), 1, (1+sqrt(3/5)) ];
280  w = 0.5*L * 1/9 * [5 8 5];
281  end
282 
283 
284  /* Kreuzproduktsmatrix e1 x v = S_e1 * v */
285  S_e1 = [0 0 0; 0 0 -1; 0 1 0];
286 
287  for i=1:length(s)
288  /* Auswerten der Ansatzfunktionen und deren Ableitungen */
289  N = models.beam.StraightBeam.beam_shape_functions(s(i), L, c);
290  N_prime = this.beam_shape_functions_derivative(s(i));
291  /* N1 = N(1:3,:); % Verschiebungsansätze */
292  N2 = N(4:6,:); /* Verdrehungsansätze */
293 
294  N1_prime = N_prime(1:3,:);
295  N2_prime = N_prime(4:6,:);
296 
297  /* Vorberechnungen zur Auswertung der Verzerrungen */
298  E_lin = N1_prime + S_e1 * N2;
299  E_skw = N1_prime - S_e1 * N2;
300 
301  E_nl_1 = 0.125 * ( E_skw(2,:)" * E_skw(2,:) + E_skw(3,:) " * E_skw(3,:) );
302  E_nl_2 = 0.5 * N2(1,:)^t * E_skw(3,:);
303  E_nl_3 = 0.5 * N2(1,:)^t * E_skw(2,:);
304 
305  E_1 = 2 * E_nl_1; /* = E_nl_1 + E_nl_1'; */
306 
307  E_2 = E_nl_2 + E_nl_2^t;
308  E_3 = E_nl_3 + E_nl_3^t;
309 
310  E_nonlin = [u_lok" * E_nl_1; u_lok " * E_nl_2; u_lok^t * E_nl_3];
311  dE_nonlin = [u_lok" * E_1; u_lok " * E_2; u_lok^t * E_3];
312  dE = (E_lin + dE_nonlin);
313 
314  /* Verzerrung */
315  eps = (E_lin + E_nonlin) * u_lok;
316 
317  /* Krümmung */
318  kap = N2_prime * u_lok;
319 
320  /* Kraft */
321  F = D * eps;
322  /* Moment */
323  M = E * kap;
324 
325  /* Integrations-Update potenzielle Energie */
326  U_pot = U_pot + w(i) * ( eps" * F + kap " * M);
327  /* Integrations-Update Schwache Form */
328  R = R + w(i) * ( dE" * F + N2_prime " * M);
329  /* Integrations-Update Steifigkeitsmatrix */
330  K = K + w(i) * ( dE" * D * dE + N2_prime " * E * N2_prime + F(1)*E_1 + F(2)*E_2 + F(3)*E_3 );
331  end
332 
333  /* Transformation in globales Koordinatensystem (nicht nötig bei Skalaren) */
334  K = this.TG * K * this.TG^t;
335  R = this.TG * R;
336  }
345  function N = beam_shape_functions_derivative(s) {
346 
347  L = this.Length;
348  c = this.c;
349 
350  GAs = c(3)/L;
351  GAsL = c(3);
352  GAsLL = c(5);
353  EIy = c(1);
354  EIz = c(1);
355 
356  N_u = [-1/L 0 0 0 0 0 1/L 0 0 0 0 0];
357  N_phi = [0 0 0 -1/L 0 0 0 0 0 1/L 0 0];
358 
359  nenner_y = 1/(L * (12*EIy + GAsLL));
360  nenner_z = 1/(L * (12*EIz + GAsLL));
361  nenner2_y = 1/(12*EIy + GAsLL);
362  nenner2_z = 1/(12*EIz + GAsLL);
363 
364  V_v1 = nenner_y * (6*GAs * s^2 - 6*GAsL * s - 12*EIy);
365  V_theta1 = nenner_y * (3*GAsL * s^2 - 4*s*(3*EIy + GAsLL) + L*(6*EIy + GAsLL));
366  V_v2 = -nenner_y * (6*GAs * s^2 - 6*GAsL * s - 12*EIy);
367  V_theta2 = nenner_y * (3*GAsL * s^2 + 2*s*(6*EIy - GAsLL) - 6*EIy*L);
368 
369  N_v = [0 V_v1 0 0 0 V_theta1 0 V_v2 0 0 0 V_theta2];
370 
371 
372  W_w1 = nenner_z * (6*GAs * s^2 - 6*GAsL * s - 12*EIz);
373  W_psi1 = -nenner_z * (3*GAsL * s^2 - 4*s*(3*EIz+GAsLL) + L*(6*EIz + GAsLL));
374  W_w2 = -nenner_z * (6*GAs * s^2 - 6*GAsL * s - 12*EIz);
375  W_psi2 = -nenner_z * (3*GAsL * s^2 + 2*s*(6*EIz - GAsLL) - 6*EIz*L);
376 
377  N_w = [0 0 W_w1 0 W_psi1 0 0 0 W_w2 0 W_psi2 0];
378 
379  Psi_w1 = nenner_z *6*GAs * (L - 2*s);
380  Psi_psi1 = nenner2_z * 6*GAs * s - nenner_z * 4*(3*EIz + GAsLL);
381  Psi_w2 = nenner_z * 6*GAs * (2*s - L);
382  Psi_psi2 = nenner2_z * 6*GAs * s + nenner_z * 2*(6*EIz - GAsLL);
383 
384  N_psi = [0 0 Psi_w1 0 Psi_psi1 0 0 0 Psi_w2 0 Psi_psi2 0];
385 
386  Theta_v1 = nenner_y * 6*GAs * (2*s - L);
387  Theta_theta1 = nenner2_y * 6*GAs * s - nenner_y * 4*(3*EIy + GAsLL);
388  Theta_v2 = nenner_y * 6*GAs * (L - 2*s);
389  Theta_theta2 = nenner2_y * 6*GAs * s + nenner_y * 2*(6*EIy - GAsLL);
390 
391  N_theta = [0 Theta_v1 0 0 0 Theta_theta1 0 Theta_v2 0 0 0 Theta_theta2];
392 
393  N = [N_u; N_v; N_w; N_phi; N_psi; N_theta];
394  }
418  function plot(p,u1,u2,col1,col2,plot_options) {
419 
420  /* centerline = 2; % Art der Mittellinie (0: keine, 1: dünn, 2: dick mit Endmarkierung)
421  * crosssection = 0; % Querschnitte (0: keine, 1: nach Theorie 1. Ordn, 2: Theorie 2. Ordn, sonst: exakt rotiert) */
422 
423  /* Create the former function arguments */
424  split = this.split;
425  T = this.T;
426  c = this.c;
427  p1 = p(this.PointsIdx(1),:);
428  p2 = p(this.PointsIdx(2),:);
429  /* L = norm(p1-p2); */
430  L = this.Length;
431 
432  x = (0:L/(split+1):L)^t;
433  p = x/L*p2 + (L-x)/L*p1;
434  col = round(x/L*col2 + (L-x)/L*col1);
435 
436  /* Ausgangslage
437  * plot3(p(:,1), p(:,2), p(:,3),'k:'); */
438 
439  u_nodes = [u1;u2];
440  u_lok = zeros(6,split+2);
441  u_lok(:,1) = u1;
442  u_lok(:,split+2) = u2;
443 
444  for i = 2:split+1
445  N_U = models.beam.StraightBeam.beam_shape_functions(x(i), L, c);
446  u_lok(:,i) = N_U * u_nodes;
447  end
448 
449  u_glob = [T * u_lok(1:3,:); T * u_lok(4:6,:)];
450 
451  cmap = colormap;
452 
453  /* % Mittellinie plotten
454  * Einfarbig, dünn */
455  if (plot_options.centerline)
456  /* plot3(p(:,1) + u_glob(1,:)', p(:,2) + u_glob(2,:)', p(:,3) + u_glob(3,:)', 'Color', 0.5 * (cmap(col(1),:)+cmap(col(split+2),:)) )
457  * elseif (centerline == 2)
458  * Mehrfarbig, dick */
459  for i=1:split+1
460  plot3(p([i i+1],1) + u_glob(1,[i i+1])^t, ...
461  p([i i+1],2) + u_glob(2,[i i+1])^t, ...
462  p([i i+1],3) + u_glob(3,[i i+1])^t, ...
463  " LineWidth ", plot_options.centerline, ...
464  " Color ", 0.5 * (cmap(col(i),:)+cmap(col(i+1),:)) );
465  end
466  end
467 
468  if (plot_options.endmarker)
469  /* Elementgrenzenmarkierungen plotten */
470  plot3(p(1,1) + u_glob(1,1)" , p(1,2) + u_glob(2,1) ", ...
471  p(1,3) + u_glob(3,1)" , "+^t, ...
472  " LineWidth ", plot_options.endmarker, " Color ", cmap(col(1),:) );
473  plot3(p(split+2,1) + u_glob(1,split+2)^t, ...
474  p(split+2,2) + u_glob(2,split+2)^t, ...
475  p(split+2,3) + u_glob(3,split+2)" , "+^t, ...
476  " LineWidth ", plot_options.endmarker, " Color ", cmap(col(split+2),:) );
477  end
478 
479  /* % Querschnitte plotten */
480  if (plot_options.crosssection ~= 0)
481  N_angle = 18;
482  /* R_cross = L/10; */
483  R_cross = 0.6285;
484  angle = 0 : (2*pi/N_angle) : 2*pi;
485 
486  xx = zeros(1, N_angle+1);
487  yy = R_cross * cos(angle);
488  zz = R_cross * sin(angle);
489 
490  COR_lok = [xx; yy; zz];
491 
492  for i = 1:split+2
493  phi = u_lok(4,i);
494  psi = u_lok(5,i);
495  theta = u_lok(6,i);
496  rot_angle = norm([phi psi theta]);
497  S_rot = [0 -theta psi; theta 0 -phi; -psi phi 0];
498 
499  /* Rotationen 1. Ordnung */
500  if (plot_options.crosssection == 1)
501  ROT = eye(3) + S_rot;
502  elseif (plot_options.crosssection == 2)
503  /* Rotationen 2. Ordnung */
504  ROT = eye(3) + S_rot + 0.5*S_rot*S_rot;
505  else
506  /* Exakte Rotationen (R = e^(S_rot)) */
507  if (rot_angle > 1e-9)
508  ROT = eye(3) + sin(rot_angle)/rot_angle * S_rot + (1-cos(rot_angle))/rot_angle^2 * S_rot*S_rot;
509  else
510  ROT = eye(3);
511  end
512  end
513 
514  COR_u = T * ROT*COR_lok;
515  col_act = cmap(col(i),:);
516  plot3(p(i,1) + u_glob(1,i) + COR_u(1,:), p(i,2) + u_glob(2,i)+ COR_u(2,:), p(i,3) + u_glob(3,i) + COR_u(3,:), " Color ", col_act);
517  end
518  end
519  }
532  protected:
533 
534  function initialize() {
535 
536  /* Call superclass */
537  initialize@models.beam.Beam(this);
538 
539  m = this.Model;
540  pi = this.PointsIdx;
541 
542  /* Längenberechnung */
543  dx = (m.Points(pi(2), 1) - m.Points(pi(1), 1));
544  dy = (m.Points(pi(2), 2) - m.Points(pi(1), 2));
545  dz = (m.Points(pi(2), 3) - m.Points(pi(1), 3));
546  l = sqrt( dx^2 + dy^2 + dz^2 );
547  this.Length= l;
548 
549  /* Lokales Koordinatensystem */
550  e_x = [dx / l; dy / l; dz / l];
551  e_y = [-e_x(2) e_x(1) 0]^t;
552  if norm(e_y) == 0
553  e_y = [0 e_x(3) -e_x(2)]^t;
554  end
555  e_z = [e_x(2)*e_y(3) - e_x(3)*e_y(2);
556  e_x(3)*e_y(1) - e_x(1)*e_y(3);
557  e_x(1)*e_y(2) - e_x(2)*e_y(1)];
558  e_y = e_y / norm(e_y);
559  e_z = e_z / norm(e_z);
560  this.T= [e_x e_y e_z];
561 
562  T = zeros(12);
563  T([1 5 9], [1 5 9]) = this.T; /* Verschiebung links */
564 
565  T([2 7 11], [2 7 11]) = this.T; /* Verschiebung rechts */
566 
567  T([3 10 6], [3 10 6]) = this.T; /* Winkel links */
568 
569  T([4 12 8], [4 12 8]) = this.T; /* Winkel rechts */
570 
571  this.TG= T;
572 
573  /* Effektive Konstanten */
574  m = this.Material;
575  c(1) = m.E * m.Iy; /* c1 = E*I */
576 
577  c(2) = c(1)^2; /* c2 = c1^2 = (E*I)^2 */
578 
579  c(3) = m.k*m.G*m.A*l; /* c3 = G*As*L */
580 
581  c(4) = c(3)^2; /* c4 = c3^2 = (G*As*L)^2 */
582 
583  c(5) = c(3) * l; /* c5 = c3*L = G*As*L^2 */
584 
585  c(6) = c(5)^2; /* c6 = c5^2 = (G*As*L^2)^2 */
586 
587  c(7) = c(1) * c(5); /* c7 = c1*c5 = E*I*G*As*L^2 */
588 
589  c(8) = c(1) * m.k*m.G*m.A; /* c8 = c1*G*As = E*I*G*As */
590 
591  c(9) = m.rho * m.A; /* c9 = rho*A
592  * Wird nicht benutzt!
593  *c(10) = m.rho * m.A * g; % c10 = q = rho*A*Ortsfaktor */
594 
595  c(11) = m.rho * m.Iy; /* c11= rho*I */
596 
597  c(12) = c(9) * l / 6; /* c12= c9*L/6 = rho*A*L/6 */
598 
599  c(13) = m.E * m.A / l; /* c13= E*A/L */
600 
601  c(14) = m.G*m.It / l; /* c14= G*It/L */
602 
603  c(15) = m.rho*m.It*l / 6; /* c15= rho*It*L/6 */
604 
605  this.c= c;
606  }
613  public: /* ( Static ) */
614 
615  static function N = beam_shape_functions(s,L,c) {
616 
617  GAs = c(3)/L;
618  GAsL = c(3);
619  GAsLL = c(5);
620  EIy = c(1);
621  EIz = c(1);
622 
623  xsi = s/L;
624  N_u = [1-xsi 0 0 0 0 0 xsi 0 0 0 0 0];
625  N_phi = [0 0 0 1-xsi 0 0 0 0 0 xsi 0 0];
626 
627  nenner_y = 1/(L * (12*EIy + GAsLL));
628  nenner_z = 1/(L * (12*EIz + GAsLL));
629  nenner2_y = 1/(12*EIy + GAsLL);
630  nenner2_z = 1/(12*EIz + GAsLL);
631 
632  V_v1 = nenner_y * (2*GAs * s^3 - 3*GAsL * s^2 - 12*EIy * s) + 1;
633  V_theta1 = nenner_y * s * (GAsL * s^2 - 2*s*(3*EIy + GAsLL) + L*(6*EIy + GAsLL));
634  V_v2 = -nenner_y * s * (2*GAs * s^2 - 3*GAsL * s - 12*EIy);
635  V_theta2 = nenner_y * s * (GAsL * s^2 + s*(6*EIy - GAsLL) - 6*EIy*L);
636 
637  N_v = [0 V_v1 0 0 0 V_theta1 0 V_v2 0 0 0 V_theta2];
638 
639 
640  W_w1 = nenner_z * (2*GAs * s^3 - 3*GAsL * s^2 - 12*EIz * s) + 1;
641  W_psi1 = -nenner_z * s * (GAsL * s^2 - 2*s*(3*EIz+GAsLL) + L*(6*EIz + GAsLL));
642  W_w2 = -nenner_z * s * (2*GAs * s^2 - 3*GAsL * s - 12*EIz);
643  W_psi2 = -nenner_z * s *(GAsL * s^2 + s*(6*EIz - GAsLL) - 6*EIz*L);
644 
645  N_w = [0 0 W_w1 0 W_psi1 0 0 0 W_w2 0 W_psi2 0];
646 
647  Psi_w1 = nenner_z *6*GAs * (L*s - s^2);
648  Psi_psi1 = nenner2_z * 3*GAs * s^2 - nenner_z * 4*(3*EIz + GAsLL) * s + 1;
649  Psi_w2 = nenner_z * 6*GAs * (s^2 - L*s);
650  Psi_psi2 = nenner2_z * 3*GAs * s^2 + nenner_z * 2*(6*EIz - GAsLL) * s;
651 
652  N_psi = [0 0 Psi_w1 0 Psi_psi1 0 0 0 Psi_w2 0 Psi_psi2 0];
653 
654  Theta_v1 = nenner_y * 6*GAs * (s^2 - L*s);
655  Theta_theta1 = nenner2_y * 3*GAs * s^2 - nenner_y * 4*(3*EIy + GAsLL) * s + 1;
656  Theta_v2 = nenner_y * 6*GAs * (L*s - s^2);
657  Theta_theta2 = nenner2_y * 3*GAs * s^2 + nenner_y * 2*(6*EIy - GAsLL) * s;
658 
659  N_theta = [0 Theta_v1 0 0 0 Theta_theta1 0 Theta_v2 0 0 0 Theta_theta2];
660 
661  N = [N_u; N_v; N_w; N_phi; N_psi; N_theta];
662  }
687 };
688 }
689 }
690 
models.beam.StructureElement.Model
Model
The model that contains the structure element.
Definition: StructureElement.m:80
models.beam.StructureElement.TG
TG
c_theta = []; kappa = []; alphaA = []; The global transformation matrix (?)
Definition: StructureElement.m:116
models.BaseFullModel
The base class for any KerMor detailed model.
Definition: BaseFullModel.m:18
models.beam.StructureElement.PointsIdx
PointsIdx
Punkt-Index-Array.
Definition: StructureElement.m:41
models.beam.Beam
Beam:
Definition: Beam.m:19
models.beam.StraightBeam.getLocalTangentials
function [ K , R , U_pot ] = getLocalTangentials(u)
Wertet tangentielle Steifigkeitsmatrix, "Residuumsvektor" (= Vektor der virtuellen internen Energie) ...
Definition: StraightBeam.m:211
models.beam.StraightBeam.initialize
function initialize()
Initializes the straight beam element.
Definition: StraightBeam.m:534
models.beam.StraightBeam.getLocalMassMatrix
function M = getLocalMassMatrix()
Berechnet lokale Steifigkeits- und Massenmatrix eines Timoshenko-Balkens c kodiert Stoffparameter: c1...
Definition: StraightBeam.m:48
models.beam.StructureElement.Length
Length
Indizes (lokal pro Knoten) in die die lokalen Matrizen assembliert werden Konvention: Freiheitsgrade ...
Definition: StructureElement.m:66
F
#define F(x, y, z)
Definition: CalcMD5.c:168
models.beam.StructureElement.c
c
Effektive Stoffkonstanten.
Definition: StructureElement.m:102
models.beam.Material
Material:
Definition: Material.m:19
models.beam.StraightBeam.getLocalStiffnessMatrix
function K = getLocalStiffnessMatrix()
Berechnet lokale Steifigkeitsmatrix eines Timoshenko-Balkens.
Definition: StraightBeam.m:127
models.beam.Beam.split
split
Speichert den anteil des jeweiligen Elements an der Gesamtsystemlänge.
Definition: Beam.m:42
models.beam.StraightBeam.getLocalForceMatrix
function f = getLocalForceMatrix()
Definition: StraightBeam.m:195
models.beam.StraightBeam.StraightBeam
StraightBeam(models.BaseFullModel model, material, pointsidx)
Definition: StraightBeam.m:42
l
* l
Definition: Gordon66SarcoForceLength.m:120
models.beam.StraightBeam.beam_shape_functions
static function N = beam_shape_functions(s, L, c)
Wertet (analytische) Basisfunktion für einen geraden Balken der Länge L und den Stoffkonstanten c an de...
Definition: StraightBeam.m:615
t
* t
Definition: Gordon66SarcoForceLength.m:116
models.beam.StraightBeam.plot
function plot(p, u1, u2, col1, col2, plot_options)
Zeichnet Timoshenko Balken mit analytischen Ansatzfunktionen mit Stoffparametern c Die Ansatzfunktion...
Definition: StraightBeam.m:418
models.beam.StraightBeam.beam_shape_functions_derivative
function N = beam_shape_functions_derivative(s)
Wertet (analytische) Basisfunktion für einen geraden Balken der Länge L und den Stoffkonstanten c an de...
Definition: StraightBeam.m:345
models.beam.StructureElement.T
T
Transformationsmatrix für das lokale Koordinatensystem.
Definition: StructureElement.m:91