Matlab-Femset

MATLAB-Interface-Routine Eigwbc_m zu den FEMSET-Funktionen, die dieSystemmatrizen für die
Berechnung von Eigenschwingungen (einschließlich Einbau der verhinderten Verschiebungen) aufbauen

Die MATLAB-Interface-Routine Eigwbc_m (“MexFunction”) liefert mit Hilfe mehrerer FEMSET-Funktionen die Systemmatrizen K und M eines Finite-Elemente-Modells für die Berechnung von Eigenschwingungen ab. Es sind die symmetrischen Bandmatrizen des allgemeinen symmetrischen Eigenwertproblems

(K - ω2 B) x = o  ,

das z. B. mit der FEMSET-Interface-Routine Isiasb_m oder (nach Umwandlung der Matrixform) mit der MATLAB-Function eigs gelöst werden kann.

 Die Möglichkeiten des Aufrufs aus MATLAB wird im Kommentar am Anfang der Interface-Funktion beschrieben:

/* ************************************************************************* */
/*  ###  Finite-Elemente-Baukasten FEMSET  ###                               */
/*                                                                           */
/*  Aufbau des symmetrischen Matrizeneigenwertproblems fuer die              */
/*  Eigenschwingungsberechnung mit der Fnite-Elemente-Methode                */
/*  ===========================================================              */
/*                                                                           */
/*  Es wird der komplette Finite-Elemente-Algorithmus realisiert mit         */
/*                                                                           */
/*    *  Aufbau der Systemsteifigkeitsmatrix,                                */
/*    *  Aufbau der Systemmassenmatrix und                                   */
/*    *  Einbau der geometrischen Randbedingungen (Zeilen-Spalten-Streichen) */
/*                                                                           */
/*  Abgeliefert werden die beiden Bandmatrizen K und M des allgemeinen       */
/*  symmetrischen Eigenwertproblems                                          */
/*                            2                                              */
/*                  (K - omega M) x = o                                      */
/*                                                                           */
/*  Input:     kx  -  "Dimension" des Problems (1, 2 oder 3)                 */
/*             kf  -  Maximale Anzahl der Freiheitsgrade pro Knoten          */
/*             ke  -  Maximale Knotenanzahl pro Element                      */
/*             kp  -  Anzahl der Parameter, die ein Element beschreiben      */
/*             ne  -  Elementanzahl                                          */
/*             nk  -  Knotenanzahl                                           */
/*             xy  -  Knotenkoordinaten                  (0)                 */
/*             km  -  Koinzidenzmatrix                   (1)                 */
/*             ep  -  Elementparameter                   (2)                 */
/*             kr  -  Randbedingungen                    (3)                 */
/*             mk  -  Knotenmassen                       (4)                 */
/*             sc  -  Federsteifigkeiten                 (5)                 */
/*                                                                           */
/*  Output:  succ >  0 --> Erfolg, die Matrizen K und M werden abgeleiefert  */
/*                   0 --> Misserfolg                                        */
/*                                                                           */
/*  Es sind grundsaetzlich zwei Typen von Funktionsaufrufen moeglich, die    */
/*  in ihren jeweils kuerzesten Varianten so aussehen:                       */
/*                                                                           */
/*  Der "einfache Eigwbc_m-Aufruf"                                           */
/*                                                                           */
/*               [succ K M] = Eigwbc_m (xy,km,ep,kr,mk,sc)                   */
/*                                                                           */
/*  ermittelt die Parameter kx, kf, ke, kp, ne und nk aus den Dimensionen    */
/*  der uebergebenen Matrizen.                                               */
/*                                                                           */
/*  Der "sichere Eigwbc_m-Aufruf"                                            */
/*                                                                           */
/*     [succ om x] = Eigwbc_m (kx,kf,ke,kp,ne,nk,xy,km,ep,kr,mk,sc)          */
/*                                                                           */
/*  ermoeglicht der Interface-Funktion den Test der Dimensionen der          */
/*  uebergebenen Matrizen mit den Werten der                                 */
/*  Input-Parameterliste. Bei dieser Variante duerfen die Matrizen auch      */
/*  als eindimensionale Vektoren uebergeben werden. Nachdruecklich           */
/*  wird jedoch in jedem Fall die Uebergabe der Input-Parameter als          */
/*  Matrizen empfohlen.                                                      */
/*                                                                           */
/*  Formate der Input-Matrizen (die weniger empfehlenswerte Variante in      */
/*  Klammern ist jeweils nur fuer den "sicheren Eigwbc_m-Aufruf" gueltig):   */
/*                                                                           */
/*  xy - nk*kx-Matrix (oder Vektor mit nk*kx Werten, nacheinander jeweils    */
/*       die kx Werte für einen Knotenpunkt)                                 */
/*  km - ne*ke-Matrix (oder Vektor mit ne*ke Werten, nacheinander jeweils    */
/*       die ke Knotennummern fuer ein Element)                              */
/*  ep - ne*kp-Matrix (oder Vektor mit ne*kp Werten, nacheinander jeweils    */
/*       die kp Parameter fuer ein Element)                                  */
/*  kr - nk*kf-Matrix (oder Vektor mit nk*kf Werten, nacheinander jeweils    */
/*       die kf Indikatoren 0 oder 1 fuer einen Knoten)                      */
/*  mk - nk*kf-Matrix (oder Vektor mit nk*kf Werten, nacheinander jeweils    */
/*       die kf Massen bzw. Massentraegheitsmomente fuer einen Knoten)       */
/*  sc - nk*kf-Matrix (oder Vektor mit nk*kf Werten, nacheinander jeweils    */
/*       die kf Federsteifigkeiten fuer einen Knoten)                        */
/*                                                                           */
/*  In beiden Aufrufvarianten koennen der letzte oder die beiden letzten     */
/*  Parameter weggelassen werden, wenn diese Vektoren nur Nullelemente       */
/*  enthalten.                                                               */
/*                                                                           */
/*  Autor: J. Dankert                                                        */
/* ************************************************************************* */

Am Beispiel eines einfachen geraden Biegeträgers wird der  Aufbau der Systemmatrizen für die Eigenschwingungsberechnung aus  vier Elementbeziehungen und die anschließende Berücksichtigung der vorgeschriebenen Verschiebungen demonstriert (Klicken auf das nebenstehende Bild).

Zum Download verfügbar: DLL Eigwbc_m.dll (genügt für den Aufruf aus Matlab).

Für Interessenten, die den Weg zum Erzeugen der DLL nachempfinden wollen, stehen die komplette MexFunction, von der oben nur der Kopf-Kommentar zu sehen ist, als  Eigwbc_m.c und die beiden Femset-Libraries femset_f.lib und femtnw_f.lib zur Verfügung.

Homepage MatlabFemset

www.JuergenDankert.de

D

nkert.de