Femeig_m - Interface zum FEMSET-Solver für Eigenschwingungsberechnung

Die MATLAB-Interface-Routine zum FEMSET-Solver für die Berechnung von Eigenschwingungen ("Mex-Function") beschreibt am Anfang im nachfolgend zu sehenden Kommentar die unterschiedlichen Möglichkeiten des Aufrufs aus MATLAB und die jeweils erwarteten Matrizen des Berechnungsmodells: 

/* ************************************************************************* */
/*  ###  Finite-Elemente-Baukasten FEMSET  ###                               */
/*                                                                           */
/*  Eigenschwingungsberechnung mit der Finite-Elemente-Methode               */
/*  ==========================================================               */
/*                                                                           */
/*  Es wird der komplette Finite-Elemente-Algorithmus realisiert mit         */
/*                                                                           */
/*     *  Aufbau der Systemsteifigkeitsmatrix,                               */
/*     *  Aufbau der Systemmassenmatrix,                                     */
/*     *  Einbau der geometrischen Randbedingungen und                       */
/*     *  Loesung des allgemeinen Matrizeneigenwertproblems                  */
/*        (inverse Simultaniteration)                                        */
/*                                                                           */
/*  Berechnet werden die neig kleinsten Eigenkreisfrequenzen und die         */
/*  zugehoerigen Eigenschwingungsformen.                                     */
/*                                                                           */
/*  Input:   neig  -  Anzahl der zu berechnenden Eigenfrquenzen              */
/*             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:    nc >  0 --> Erfolg, es werden nc Eigenkreisfrequenzen und     */
/*                         die zugehoerigen Eigenschwingungsformen auf den   */
/*                         Feldern om (nc Werte) bzw. x (nk * kf Zeilen,     */
/*                         nc Spalten) abgeliefert                           */
/*                   0 --> Misserfolg                                        */
/*                                                                           */
/*  Wenn nur zwei Output-Parameter vorgesehen werden, wird neben nc nur      */
/*  der Vektor om mit den nc Eigenkreisfrequenzen abgeliefert.               */
/*                                                                           */
/*  Es sind grundsaetzlich zwei Typen von Funktionsaufrufen moeglich, die    */
/*  in ihren jeweils kuerzesten Varianten so aussehen:                       */
/*                                                                           */
/*  Der "einfache Femeig_m-Aufruf"                                           */
/*                                                                           */
/*               [succ om x] = femeig_m (neig,xy,km,ep,kr,mk,sc)             */
/*                                                                           */
/*  ermittelt die Parameter kx, kf, ke, kp, ne und nk aus den Dimensionen    */
/*  der uebergebenen Matrizen.                                               */
/*                                                                           */
/*  Der "sichere Femeig_m-Aufruf"                                            */
/*                                                                           */
/*     [succ om x] = femeig_m (neig,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                                 */
/*  der Input-Parameterliste. Bei dieser Variante duerfen die Matrizen auch  */
/*  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 Femeig_m-Aufruf" gueltig):   */
/*                                                                           */
/*  xy - nk*kx-Matrix (oder Vektor mit nk*kx Werten, nacheinander jeweils    */
/*       die kx Werte fuer 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 die Vektoren nur Nullelemente         */
/*  enthalten.                                                               */
/*                                                                           */
/*  Autor: J. Dankert                                                        */
/* ************************************************************************* */

Download

Für den Aufruf der Interface-Funktion femeig_m aus Matlab genügt die Möglichkeit des Zugriffs auf die .dll-Datei (für die 32-Bit-Version) bzw. die .mexw64-Datei (für die 64-Bit-Version), die über die folgenden Links zum Download verfügbar sind:

femeig_m.dll      femeig_m.mexw64

Für Interessenten

Die komplette (in C geschriebene) "Mex-Funktion" femeig_m.c im Quelltext und die beiden einzubindenden Libraries für das Erzeugen einer aufrufbaren Interface-Funktion (.dll-Datei bzw. .mexw64-Datei) sind auch für beide Matlab-Varianten verfügbar:

Damit können aus Matlab aufrufbare Interface-Dateien erzeugt werden für die 32-Bit-Version mit

mex  femeig_m.c  femset_f.lib  femtnw_f.lib

und für die 64-Bit-Version mit

mex  femeig_m.c  femset64.lib  femtnw64.lib

Diese Kommandos müssen aus dem Matlab-Command-Window heraus gestartet werden. Weitere Hinweise und ein Beispiel findet man auf der Seite "Erzeugen von Mex-Files".

Das ist aber wirklich nur für Interessenten, die selbst Mex-Files erzeugen wollen. Für den Aufruf der Interface-Routine aus Matlab genügen die oben zum Download offerierten fertigen Dateien.