kramann.info
© Guido Kramann

Login: Passwort:










8 Simulationstechnik UND Kinetik/Kinematik day by day

8 (EN google-translate)

8 (PL google-translate)

  • 1 -- 01|10|2018 -- MONDAY SIMULATIONSTECHNIK
50_Simulationstechnik/01_Systemtheorie/01_System
50_Simulationstechnik/01_Systemtheorie/02_Modell
50_Simulationstechnik/01_Systemtheorie/03_Verifikation
  • 2 -- 02|10|2018 -- TUESDAY SIMULATIONSTECHNIK
50_Simulationstechnik/01_Systemtheorie/04_Seerosen
50_Simulationstechnik/01_Systemtheorie/05_Eulerintegration
50_Simulationstechnik/01_Systemtheorie/06_Saaluebung
50_Simulationstechnik/01_Systemtheorie/07_scilab
skripteteich.zip -- Scilab-Programme aus der Vorlesung
  • 3 -- 08|10|2018 -- MONDAY Kinetik/Kinematik
54_Kinetik/01_Newton
54_Kinetik/01_Newton/01_LinearSchwinger
50_Simulationstechnik/02_Eigenwerte/01_DGLS_Eigenwerte
skriptschwinger.zip -- Scilab-Programm zum linearen Schwinger.
  • 4 -- 09|10|2018 -- TUESDAY Kinetik/Kinematik
54_Kinetik/01_Newton/05_Saaluebung
/50_Simulationstechnik/02_Eigenwerte

C = 1;
m = 1;
A = [      0   1      0    0
      -2*C/m   0    C/m    0
           0   0      0    1
         C/m   0   -2*C/m  0];

spec(A)

//    1.388D-16 + 1.7320508i  
//    1.388D-16 - 1.7320508i  
//  - 5.551D-17 + i           
//  - 5.551D-17 - i       


Code 8-1: Eigenwertberechnung mit Scilab beim Doppelschwinger

  • 5 -- 15|10|2018 -- MONDAY Simulationstechnik
  • Simulation des Doppelschwinger mit Scilab
  • Hinzufügen von Dämpfungstermen beim Doppelschwinger
  • Anregung der Eigenformen beim Doppelschwinger
doppelschwinger.zip -- Scilab-Programme zur LV
  • 6 -- 16|10|2018 -- TUESDAY Kinetik/Kinematik
  • Koordinatentransformationen
  • Newton-Euler-Gleichung
54_Kinetik/03_Kinematik/01_Koordinatentransformation
54_Kinetik/02_NewtonEuler
54_Kinetik/02_NewtonEuler/01_Traegheitsmomente
AUFGABE FÜR ZUHAUSE 54_Kinetik/05_Tilger
  • 7 -- 22|10|2018 -- MONDAY Simulationstechnik
  • Einführung in VRML
50_Simulationstechnik/03_VRML
  • 8 -- 23|10|2018 -- TUESDAY Kinetik/Kinematik
  • Herleitung Körperpendel (Tafel)
  • 9 -- 29|10|2018 -- MONDAY Simulationstechnik
ÜBUNG
  1. Entwickeln Sie ein Simulationsmodell für das Körperpendel in Scilab.
  2. Schauen Sie sich fprintfMat in der Scilab-Hilfe an.
  3. Erzeugen Sie Bewegungsdaten für das Körperpendel in Scilab und importieren Sie diese in ein VRML-Modell.
  4. Untersuchen Sie qualitativ die Schwingung des Körperpendels.
Das Pendel ist ein homogener Zylinder.
Masse  m = 10kg
Länge  l = 1m
Radius r = 0.05m

Code 8-2: Parameter für das Körperpendel

#VRML V2.0 utf8
#Beispiel eines Zyllinders
DEF FIGUR4 Transform
{
    translation 0 0 0
    rotation 0 0 1 0.0
    children
    [
    DEF FIGUR5 Transform
    {
       translation 0 -0.5 0
       rotation 1 0 0 0.0
       children
       [



        Shape
        {
            geometry Cylinder
            {
                    height 1.0
                    radius 0.05
            }
            appearance Appearance
            {
                material Material
                {
                    diffuseColor  0.0 0.8 0.8
                }
            }
        }
      ]
     }

     DEF START TouchSensor {}
    ]
}
DEF ZEIT TimeSensor 
{
  cycleInterval 8
}
DEF DREHUNG OrientationInterpolator
{
    #Zeit
    key
    [
        0.0
        0.33
        0.66
        1.0
    ]
    #Drehachse: x y z  Winkel
    keyValue
    [
        0.0  0.0 1.0  0.0
        0.0  0.0 1.0  1.5   
        0.0  0.0 1.0  0.0   
        0.0  0.0 1.0 -1.5   
    ]
}
ROUTE START.touchTime TO ZEIT.startTime
ROUTE ZEIT.fraction_changed TO DREHUNG.set_fraction
ROUTE DREHUNG.value_changed  TO FIGUR4.rotation

Code 8-3: Musterlösung für die Animation eines Körperpendels mit VRML.

  • 10 -- 30|10|2018 -- TUESDAY Vorbesprechung der E-Tests
  • Vorbesprechung der E-Tests
  • Übungsaufgaben
  • Übungs-E-Test
  • 11 -- 05|11|2018 -- MONDAY E-Test Nr.1/2 Kinetik/Kinematik UND Simulationstechnik
  • 12 -- 06|11|2018 -- TUESDAY Besprechung E-Tests

Simulationstechnik: Einführung in die Optimierung

  • Heuristiken
  • Trial and Error
  • Gradientenverfahren
/50_Simulationstechnik/06_Optimierung
  • 13 -- 12|11|2018 -- MONDAY Simulationstechnik
  • Partielle Differentiation einer Fehlerfunltion
  • Entwicklung eines einfachen Optimierers
  • Anpassung des Optimierers an das Tilger-Problem
/50_Simulationstechnik/06_Optimierung
/54_Kinetik/05_Tilger
zufallszahl = 1+ floor(grand(1, 1, "unf", 0, 1.999999999));

Code 8-4: Erzeugen einer gleichverteilten diskreten Zufallszahl mit grand, die entweder 1 oder 2 liefert.

modifiziertes_gradientenverfahren.zip -- Quelltexte zur Implementierung des modifizierten Gradientenverfahrens für f(x,y)=x*x*x-4*x+y*y*y-16*y
  • 14 -- 13|11|2018 -- TUESDAY Simulationstechnik / Kinetik/Kinematik
  • Fortsetzung Anpassung des Optimierers an das Tilger-Problem
tilgeropt.zip -- Optimierer direkt implementiert und als Scilab-Funktion.
clear();
//Implementierung eines modifizierten
//Gradientenverfahrens mit Scilab für 
//die Fehlerfunktion f(x,y)=x^3-4x+y^3-16y

//1. Schritt: Fehlerfunktion formulieren

C1 = 1000.0;
C2 = 0.0;
D2 = 0.0;
m1 = 500.0;
m2 = 20.0;
function f = rechteSeite(t,y)

//  m1*a1 = -C1x1 -D1x1  + (x2-x1)C2 + (v2-v1)D2
//  m2*a2 =              + (x1-x2)C2 + (v1-v2)D2

A = [
         0            1       0         0
        (-C1-C2)/m1  -D2/m1   C2/m1   D2/m1
         0            0       0         1
         C2/m2        D2/m2  -C2/m2  -D2/m2
    ];

    f = A*y;
endfunction


function z = berechneFehler(x,y)
    C2 = x;
    D2 = y;

    y0 = [1;0;0;0];
    t  = 0:0.01:100;
    t0 = 0;
    yy = ode(y0,t0,t,rechteSeite);

    fehler = sum(abs(yy(1,:)));    
    disp(fehler);
    z = fehler;    
endfunction

//2. Schritt: Startwert festlegen:
// (hier beginnt "unsere Skifahrt")

x_alt = 10;
y_alt = 10;

//3. Implementierung des iterativen Verfahrens

aktueller_fehler = berechneFehler(x_alt,y_alt);

alfa = 0.1; //Gewichtung der Änderung.

//Zielwert: xsoll = 1.154700538,  ysol = 2.309401077

for i=1:1000  //innere Befehle iterativ ausführen
    dx = 2*floor(grand(1, 1, "unf", 0, 1.999999999)) - 1;  //liefert -1 oder +1 zufällig
    dy = 2*floor(grand(1, 1, "unf", 0, 1.999999999)) - 1;  //liefert -1 oder +1 zufällig

    x_neu = x_alt + alfa*dx;
    y_neu = y_alt + alfa*dy;

    neuer_fehler = berechneFehler(x_neu,y_neu);

//Prüfen, ob neuer Fehler kleiner, wenn ja, zu neuem Punkt gehen, sonst bei altem bleiben    
    if neuer_fehler<=aktueller_fehler then
        x_alt = x_neu;
        y_alt = y_neu;
        aktueller_fehler = neuer_fehler;
        disp('fehler='+string(aktueller_fehler));     
        disp('x='+string(x_alt));     
        disp('y='+string(y_alt));     
    end
end

disp('Fehler zu Beginn:');
berechneFehler(10,10);

disp('Fehler am Ende:');
berechneFehler(x_alt,y_alt);

Code 8-5: Tilger mit Optimierer.

  • 15 -- 19|11|2018 -- MONDAY Simulationstechnik

Methode der kleinsten Quadrate / Least Square Fit

Tafelbeispiel


y = c0*x + c1*2^x

Meßwerte:

x | y
0 | 1
1 | 4
2 | 9


Code 8-6: Tefelbeispiel

B = [0 1
     1 2
     2 4];

d = [ -1
      -4
      -9 ];

A = B' * B

b = B' * d

//   A*c+b=0 =>

c = inv(A)*(-b)

//direkte Implementierung in Scilab von LSQ == Kleinste Quadrate Methode
lsq(B,-d)

Code 8-7: Tafelbeispiel in Scilab umgesetzt

Skript

50_Simulationstechnik/05_Parameterindentifikation/01_KleinsteQuadrate
  • 16 -- 03|12|2018 -- MONDAY Simulationstechnik

Herleitung Doppelpendel

doppelpendel.zip
  • 17 -- 04|12|2018 -- TUESDAY Simulationstechnik
  • Simulation und Animation Doppelpendel
  • Übung zu Kleinste Quadrate-Methode: Sharp IR-Entfernungssensor
  • #ul -- 10|12|2018 -- MONDAY Simulationstechnik

Umsetzung Unterrichtsbeispiel mit Processing:

Genetisch002.zip
Genetisch003.zip
Genetisch004.zip
Genetisch005.zip -- korrigiert
import java.util.Random;
Random zufall = new Random(System.currentTimeMillis());
int anzahlGene  = 8;
int anzahlBeste = 3;
int genlaenge   = 6;
int[][] gene = new int[anzahlGene][genlaenge];
int[][] bestegene = new int[anzahlBeste][genlaenge];
int[] alleFehler = new int[anzahlGene];
public void setup()
{
    size(500,500);
    frameRate(1);
    //Erste Generation von Zufallsgenen bilden:
    for(int i=0;i<gene.length;i++)
    {
         for(int k=0;k<gene[i].length;k++)
         {
             gene[i][k] = zufall.nextInt(2);
         }
    }
}

public int berechneFehler(int[] gen)
{
     int[] soll_pattern = new int[] {1,0,1,0,1,0};
     int fehler = 0;
     for(int i=0;i<gen.length;i++)
         if(gen[i]!=soll_pattern[i])
             fehler++;
     return fehler;        
}

public void draw()
{
    background(255,255,255);
    fill(0,0,0);
    stroke(0,0,255);
    //ellipse(width/2, height/2, 50,50);
    textSize(18);
    for(int i=0;i<gene.length;i++)
    {
         for(int k=0;k<gene[i].length;k++)
         {
             text(gene[i][k],50+k*60,50+i*18);
         }         
    }
    //1. Alle Fehler aktualisieren:
    for(int i=0;i<gene.length;i++)
    {
         alleFehler[i] = berechneFehler(gene[i]);
    }
    fill(255,0,0);
    for(int i=0;i<gene.length;i++)
    {
         text(alleFehler[i],400,50+i*18);
    }
    //2. Finde die drei Besten
    int[] beste_index = new int[3];
    int[] h_beste = new int[] {Integer.MAX_VALUE,Integer.MAX_VALUE,Integer.MAX_VALUE};
    for(int iii=0;iii<anzahlBeste;iii++)
    {
      for(int i=0;i<alleFehler.length;i++)
      {
         if(alleFehler[i]<=h_beste[iii])// || alleFehler[i]<=h_beste[1] || alleFehler[i]<=h_beste[2])
         {
                h_beste[iii] = alleFehler[i];                
                beste_index[iii] = i; 
         }
         alleFehler[beste_index[iii]] = Integer.MAX_VALUE; //für nächsten Durchlauf neutraliseren
      }
    }
    //3. Rekombination aus den drei Besten:
    //3a die besten merken:
    for(int i=0;i<anzahlBeste;i++)
          for(int k=0;k<gene[beste_index[i]].length;k++)
              bestegene[i][k] = gene[beste_index[i]][k];
    //3b in gene kopieren als erste drei:           
    for(int i=0;i<anzahlBeste;i++)
          for(int k=0;k<gene[beste_index[i]].length;k++)
              gene[i][k] = bestegene[i][k];
    //3c Rekombinieren aller anderen
    for(int i=anzahlBeste;i<gene.length;i++)
    {
         int quelle1 = zufall.nextInt(anzahlBeste);
         int quelle2 = (quelle1 + 1 + zufall.nextInt(anzahlBeste-1))%anzahlBeste;
         for(int k=0;k<gene[i].length;k++)
         {
            if(zufall.nextInt(100)>95)
            {
               if(zufall.nextBoolean()==true)
                   gene[i][k] = gene[quelle1][k];
               else    
                   gene[i][k] = gene[quelle2][k];
            }
            else
            {
                   gene[i][k] = zufall.nextInt(2);
            }
         }
         
         
    }
}
Quelltext von Genetisch005


Code 8-8: #ul -- 11|12|2018 -- TUESDAY Simulationstechnik

Genetisch006.zip -- korrigiert
GROSSE ÜBUNG

Parameter C,D,m optimieren für den Tilger

54_Kinetik/05_Tilger

Arbeitsschritte:

  1. Simulationsmodell für Tilger in Java/Processing erstellen
  2. Mapping-Funktion für Paramater
  3. Wertebereich der Parameter sinnvoll festlegen
  4. Fehlerfunktion komplettieren
  5. Genetischen Algorithmus zur OIptimierung der Parameter schreiben

Hinweise:

  • Arbeiten Sie in Gruppen.
  • Arbeiten Sie die Punkte in der obigen reihenfolge ab.
  • Verwenden Sie Tabs.
  • Verwenden Sie Klassen.
  • Testen Sie jeden Softwarestand bevor Sie mit dem nächsten beginnen
  • Speichern Sie Fallback-Versionen.
30_Informatik3/16_Nuetzliches/03_RungeKutta -- Runge-Kutta-Integrationsverfahren bei Bedarf.

  • -- 17|12|2018 -- MONDAY Simulationstechnik

Vorarbeit für genetische Optimierung: Codieren eines Simulators für das Tilgersystem mit Processing und Austesten (Durchführen einer Simulation).

Nächster Schritt: Fehlerfunktion schreiben.

HINWEIS: ty enthält als erste Zeile die Zeitstützstellen und danach y1, v1, y2, v2.

TILGER_001.zip

  • -- 08|01|2019 -- TUESDAY Kinetik/Kinematik
Invertierendes Pendel, dynamische Gleichungen

Bild 8-1: Invertierendes Pendel, dynamische Gleichungen

Bestimmung der Zwangskräfte für invertierendes Pendel

Bild 8-2: Bestimmung der Zwangskräfte für invertierendes Pendel

Inverses Pendel vom 15.1.
inverspendulum.zip
invers001.zip -- Processing-Modell aus Regelungstechnik-Vorlesung
invers002.zip -- Processing-Modell mit Regler
Screenshot von Processing-Programm

Bild 8-3: Screenshot von Processing-Programm

Bild 8-4:

21.1.: Partikelsimulation