Array teilen und neu zusammenfügen

[mathman]

Einen wunderschönen guten Abend

Wen es interessiert
Das Modul was ich gerade schreibe soll die Kraft und Verformungsgrößen eines 1feldträgers lastfallweise ausgeben.
(Erste Spalte Querkraft, zweite Spalte Moment, dritte Spalte Verdrehungswinkel phi und vierte Spalte Durchbiegung - ein Schleifendurchgang entspricht 11 Zwischenschnittgrößen, die letzten 11 Zeilen sind ein zweiter Lastfall)

folgendes Problem hat sich heute aufgetan:

Ich habe folgendes Array:

Code: Alles auswählen

[[  2.50000000e+01   0.00000000e+00  -8.66971841e-07   0.00000000e+00]
 [  2.00000000e+01   1.12500000e+01  -8.18421418e-07   4.25249688e-04]
 [  1.50000000e+01   2.00000000e+01  -6.86641698e-07   8.04549868e-04]
 [  1.00000000e+01   2.62500000e+01  -4.92440006e-07   1.10148772e-03]
 [  5.00000000e+00   3.00000000e+01  -2.56623665e-07   1.29005410e-03]
 [  0.00000000e+00   3.12500000e+01   1.05879118e-22   1.35464350e-03]
 [ -5.00000000e+00   3.00000000e+01   2.56623665e-07   1.29005410e-03]
 [ -1.00000000e+01   2.62500000e+01   4.92440006e-07   1.10148772e-03]
 [ -1.50000000e+01   2.00000000e+01   6.86641698e-07   8.04549868e-04]
 [ -2.00000000e+01   1.12500000e+01   8.18421418e-07   4.25249688e-04]
 [ -2.50000000e+01   0.00000000e+00   8.66971841e-07   1.69406589e-18]
 [  5.00000000e+01   0.00000000e+00  -1.73394368e-06   0.00000000e+00]
 [  4.00000000e+01   2.25000000e+01  -1.63684284e-06   8.50499376e-04]
 [  3.00000000e+01   4.00000000e+01  -1.37328340e-06   1.60909974e-03]
 [  2.00000000e+01   5.25000000e+01  -9.84880011e-07   2.20297545e-03]
 [  1.00000000e+01   6.00000000e+01  -5.13247330e-07   2.58010820e-03]
 [  0.00000000e+00   6.25000000e+01   2.11758237e-22   2.70928700e-03]
 [ -1.00000000e+01   6.00000000e+01   5.13247330e-07   2.58010820e-03]
 [ -2.00000000e+01   5.25000000e+01   9.84880011e-07   2.20297545e-03]
 [ -3.00000000e+01   4.00000000e+01   1.37328340e-06   1.60909974e-03]
 [ -4.00000000e+01   2.25000000e+01   1.63684284e-06   8.50499376e-04]
 [ -5.00000000e+01   0.00000000e+00   1.73394368e-06   3.38813179e-18]]

Was ich mit dieser Schleife erzeugt habe

Code: Alles auswählen

    # Berechnung der Zwischenwerte fuer V, M, w, phi
    en = []

    # l Zaehltvariabel fuer die Lastfaelle
    for l in range(0,2):
      # i Zaehlvariabel fuer die Intervalle der Zwischenschnittgroessen eines Stabes
      for i in range(0,11):
        
        x = i/10. * l1
        
        V = (asm[0,l]) - p[l] * x        
          
        M = (asm[0,l]) * x + (asm[1,l]) - p[l] * x ** 2 / 2
        
        phi = (((asm[0,l]) * (x ** 2 / 2) + (asm[1,l]) * x - p[l] * ( x ** 3 / 6)) / steifigkeit) + (asm[3,l])
        
        w = (((- (asm[0,l]) * (x ** 3 /6) - (asm[1,l]) * (x ** 2 / 2) + p[l] * (x ** 4 / 24)) / steifigkeit) - (asm[3,l]) * x + (asm[2,l]))*1000
        e = [V, M, phi, w]
        en.append(e)
        
    print asmatrix(en)

Jetzt möchte ich das Array nach der 11. Zeile horizontal teilen und in "rechts wieder anhängen" ?
Also das aus der 22x4 eine 11x 8 Matrix entsteht.

Kann man das evtl. auch in der Schleife oben lösen? Das müsste dann in der ersten Schleife nach dem ersten Durchlauf passieren.

Gruß
Mathman

[HerrHagen]

Nimm das passende Werkzeug für diese Aufgabe und verwende numpy:

Code: Alles auswählen

>>> import numpy
>>> en = numpy.arange(22*4).reshape((22,4))
>>> en
0: array([[ 0,  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]])
>>> numpy.hstack((en[:11], en[11:]))
1: array([[ 0,  1,  2,  3, 44, 45, 46, 47],
       [ 4,  5,  6,  7, 48, 49, 50, 51],
       [ 8,  9, 10, 11, 52, 53, 54, 55],
       [12, 13, 14, 15, 56, 57, 58, 59],
       [16, 17, 18, 19, 60, 61, 62, 63],
       [20, 21, 22, 23, 64, 65, 66, 67],
       [24, 25, 26, 27, 68, 69, 70, 71],
       [28, 29, 30, 31, 72, 73, 74, 75],
       [32, 33, 34, 35, 76, 77, 78, 79],
       [36, 37, 38, 39, 80, 81, 82, 83],
       [40, 41, 42, 43, 84, 85, 86, 87]])

... das wurde genau für solche Aufgaben gemacht. Wenn du mit Python wissenschaftlich arbeiten willst, ist numpy einfach das Werkzeug.

[Darii]

Kann man das evtl. auch in der Schleife oben lösen?

Bestimmt, aber dazu müsste ich mir deine Berechnungen genauer angucken. Du kannst das aber auch einfach später machen:

Code: Alles auswählen

[l + r for l, r in zip(en[:11], en[11:])]

[gkuhl]

Drei Anmerkungen noch:

• [a] Verwende direkt NumPy Arrays und vermeide den Umweg über die for-Schleifen und die Listen. Das ist meist kürzer und auch schneller, wenn man später größere Datensätze hat:

  Code: Alles auswählen

  x = numpy.linspace(0,1,11)
  M = c[0] + c[1] * x + 0.5 * c[2] * x**2

  Versuche die Gleichungen leichter lesbar zu schreiben:
  • Die Klammern um "x ** 4 / 24" oder "asm[1,l]" sind unnötig.
  • "x**2" liest sich meiner Meinung besser als "x ** 2"
  • Keine Zeile sollte mehr als 80 Zeichen haben.
  
  
  [c] Gibt es einen guten Grund die Werte als 11x8 Array (oder gar Matrix) zu verarbeiten. Meiner Meinung ist es übersichtlicher, wenn du für jede physikaliche Größe einen eigenen Array verwendest. Das ganze kann man dann z.B. mit Listen und Dictionaries verschachteln:

  Code: Alles auswählen

  lastfaelle = {
      1: {"x": ndarray, "M": ndarray},
      2: {"x": ndarray, "M": ndarray}
  }

Grüße
Gerrit

[mathman]

Vielen Dank für eure Antworten

Ich habe jetzt versucht die Antworten umzusetzen und habe folgenden Code

Code: Alles auswählen

    # Berechnung der Zwischenwerte fuer V, M, w, phi
    en = array([])

    # l Zaehltvariabel fuer die Lastfaelle
    for l in range(0,2):
      # i Zaehlvariabel fuer die Intervalle der Zwischenschnittgroessen eines Stabes
      for i in range(0,11):
        
        x = i/10. * l1
        
        V = asm[0,l] - p[l] * x        
          
        M = asm[0,l] * x + asm[1,l] - p[l] * x**2 / 2
        
        phi = ((asm[0,l] * (x**2 / 2) + asm[1,l] * x - p[l] * ( x ** 3 / 6)) / steifigkeit) + asm[3,l]
        
        w = (((- asm[0,l] * (x**3 /6) - asm[1,l] * (x**2 / 2) + p[l] * (x**4 / 24)) / steifigkeit) - asm[3,l] * x + asm[2,l])*1000
        e = array([V, M, phi, w])
        append(en, e, axis=0)
    reshape(en, (22,4))
    hstack((en[:11], en[11:]))
    print asmatrix(en)

Jetzt habe ich das Problem, das an en e nicht an gehangen wird, reshape funktioniert und hstack funktioniert so leider nicht
In der Doku wird es so meiner Meinung gemacht, aber mit Sicherheit sehe ich da was falsch

Gruß
Mathman

[BlackJack]

@mathman: Du solltest mit den Rückgabewerten der Funktionen vielleicht auch etwas machen und sie nicht einfach ignorieren.

[mathman]

@mathman: Du solltest mit den Rückgabewerten der Funktionen vielleicht auch etwas machen und sie nicht einfach ignorieren.

vielen Dank, jetzt funktioniert es

Code: Alles auswählen

    # ecz Ergbinsse Container der Zwischenschnittgroessen fuer das Zeichnen 
    ecz = array([])

    # l Zaehltvariabel fuer die Lastfaelle
    for l in range(0,2):
      # i Zaehlvariabel fuer die Intervalle der Zwischenschnittgroessen eines Stabes
      for i in range(0,11):
        
        x = i/10. * l1
        
        V = asm[0,l] - p[l] * x        
          
        M = asm[0,l] * x + asm[1,l] - p[l] * x**2 / 2
        
        phi = ((asm[0,l] * (x**2 / 2) + asm[1,l] * x - p[l] * ( x ** 3 / 6)) / steifigkeit) + asm[3,l]
        
        w = (((- asm[0,l] * (x**3 /6) - asm[1,l] * (x**2 / 2) + p[l] * (x**4 / 24)) / steifigkeit) - asm[3,l] * x + asm[2,l])*1000
        # e Berechnung der Zwischenwerte fuer V, M, w, phi
        e = array([x, V, M, phi, w])
        ecz = append(ecz, e, axis=0)
    # ecz in 22x5 Matrix konvertieren, 11x10 Matrix konvertieren, 2. x Spalte loeschen, runden auf 10 Stellen 
    ecz = reshape(ecz, (22,5))
    ecz = hstack((ecz[:11], ecz[11:]))
    ecz = delete(ecz, [5], axis=1)
    ecz = round(ecz, decimals=10)
    print ecz

Drei Anmerkungen noch:

• [a] Verwende direkt NumPy Arrays und vermeide den Umweg über die for-Schleifen und die Listen. Das ist meist kürzer und auch schneller, wenn man später größere Datensätze hat:

  Code: Alles auswählen

  x = numpy.linspace(0,1,11)
  M = c[0] + c[1] * x + 0.5 * c[2] * x**2

@gkuhl
das verstehe nicht.
die Funktion linspace erzeugt folgendes Array
array([ 0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])
Leider verstehe ich gerade den Sinn nicht davon.

zu Punkt [c]
das kann ich so leider noch überblicken, das stellt sich dann erst heraus wenn ich das ganze zeichne. Ich möchte da u. A. die Querkraftlinie in Abhängigkeit von x zeichnen für den Träger zeichnen.

[gkuhl]

das verstehe nicht.
die Funktion linspace erzeugt folgendes Array
array([ 0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])
Leider verstehe ich gerade den Sinn nicht davon.

Das ganze macht den Umweg über for-Schleifen und Listen unnötig, weil NumPy automatisch alle Elemente des Arrays verknüpft. Schau dir am besten die folgenden Beispiele an:

Bsp.: ohne NumPy*:

Code: Alles auswählen

x = list()
y = list()
z = list()
for i in range(0,11):
    xc = 0.1 * i
    yc = xc**2
    zc = math.exp(xc) + math.sin(yc)
    x.append(xc)
    y.append(yc)
    z.append(zc)

Bsp.: mit Numpy:

Code: Alles auswählen

x = numpy.linspace(0,1,11)
y = x**2
z = numpy.exp(x) + numpy.sin(y)

das kann ich so leider noch überblicken, das stellt sich dann erst heraus wenn ich das ganze zeichne. Ich möchte da u. A. die Querkraftlinie in Abhängigkeit von x zeichnen für den Träger zeichnen.

Du kannst es überblicken oder du kannst es nicht überblicken?

Grüße
Gerrit

* mit 3x LC ginge es wohl hier auch, allerdings kann das schnell unübersichtlich werden.

[mathman]

Guten Abend,

ich glaub jetzt habe ich es Begriffen dank deinem zweiten
Beispiel

Mit linspace generiere ich einen Vektor von a bis b mit x Werten, wobei die Werte gleichmäßig zwischen a und b verteilt sind
Im zweiten Schritt hast du hier dann einfach die Werte potenziert und damit entsteht ein neuer Vektor mit den Lösungen drinne

Demnach müsste ich mein i so erzeugen "i = numpy.linspace(0,1,11)" und die innere Schleife entfernen.

Code: Alles auswählen

    # l Zaehltvariabel fuer die Lastfaelle
    for l in range(0,2):
      # i Zaehlvariabel fuer die Intervalle der Zwischenschnittgroessen eines Stabes
      i = numpy.linspace(0,1,11)
      x = i/10. * l1
      V = asm[0,l] - p[l] * x
      M = asm[0,l] * x + asm[1,l] - p[l] * x**2 / 2
      phi = ((asm[0,l] * (x**2 / 2) + asm[1,l] * x - p[l] * ( x ** 3 / 6)) / steifigkeit) + asm[3,l]
      w = (((- asm[0,l] * (x**3 /6) - asm[1,l] * (x**2 / 2) + p[l] * (x**4 / 24)) / steifigkeit) - asm[3,l] * x + asm[2,l])*1000

x, V, M, phi, w wären dabei jeweils ein Array mit den Ergebnissen drinnen.
Dies muss ich dann nur noch zum Schluss so zusammen fügen, das meine gewünschte Array Struktur herauskommt.

das verstehe nicht.

das kann ich so leider noch überblicken, das stellt sich dann erst heraus wenn ich das ganze zeichne. Ich möchte da u. A. die Querkraftlinie in Abhängigkeit von x zeichnen für den Träger zeichnen.

Du kannst es überblicken oder du kannst es nicht überblicken?

Ich kann es noch nicht überblicken

Ich habe mir mal das Array das bei meiner Berechnung herauskommt aus geben lassen und in Excel verarbeitet, so wie es später auch in Python passieren soll um dir zu zeigen was ich damit vor habe

Hier lass ich mir die Durchbiegung und hier deb Momentenverlauf eines 3 Feld Durchlaufträger ausgeben.

Auf der X-Achse wird in [m] die Länge der Träger abgetragen und die Y-Werte kommen dann aus dem Array.

Später will ich dann eine Funktion schreiben, die mir das Diagramm so in der Art zeichnet.
Dafür brauche dann halt auch das Array.

Ein frohes Weihnachtsfest
Mathman