Femalg_m - Interface zum FEMSET-Solver für elastostatische Probleme

Die MATLAB-Interface-Routine zum FEMSET-Solver ("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  ###                               */
/*                                                                           */
/*  Finite-Elemente-Algorithmus                                              */
/*  ===========================                                              */
/*                                                                           */
/*  Es wird der komplette Finite-Elemente-Algorithmus realisiert mit         */
/*                                                                           */
/*     *  Aufbau der Systemsteifigkeitsbeziehung,                            */
/*     *  Einbau der geometrischen Randbedingungen und                       */
/*     *  Loesung des linearen Gleichungssystems (Cholesky-Verfahren).       */
/*                                                                           */
/*  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)                 */
/*             bk  -  Knotenlasten                       (4)                 */
/*             sc  -  Federsteifigkeiten                 (5)                 */
/*             li  -  Identische Verschiebungen          (6)                 */
/*             pu  -  Vorgeschriebene Verschiebungen     (7)                 */
/*             et  -  Element-Typen                      (8)                 */
/*             la  -  Lager unter Winkel                 (9)                 */
/*             aa  -  Winkel fuer Lager                 (10)                 */
/*                                                                           */
/*  Output:    succ = 1 --> Erfolg, die berechneten Verschiebungen wurden    */
/*                          auf dem Feld uv (nk Zeilen, kf Spalten) abgelegt */
/*                    0 --> Misserfolg                                       */
/*                                                                           */
/*  Es sind grundsaetzlich zwei Typen von Funktionsaufrufen moeglich, die    */
/*  in ihren jeweils kuerzesten Varianten so aussehen:                       */
/*                                                                           */
/*  Der "einfache Femalg_m-Aufruf"                                           */
/*                                                                           */
/*               [succ uv] = femalg_m (xy,km,ep,kr,bk)                       */
/*                                                                           */
/*  ermittelt die Parameter kx, kf, ke, kp, ne und nk aus den Dimensionen    */
/*  der uebergebenen Matrizen.                                               */
/*                                                                           */
/*  Der "sichere Femalg_m-Aufruf"                                            */
/*                                                                           */
/*         [succ uv] = femalg_m (kx,kf,ke,kp,ne,nk,xy,km,ep,kr,bk)           */
/*                                                                           */
/*  ermoeglicht der Interface-Funktion den Test der Dimensionen der          */
/*  uebergebenen Matrizen mit den Werten auf den ersten 6 Positionen 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 Femalg_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)                      */
/*  bk - nk*kf-Matrix (oder Vektor mit nk*kf Werten, nacheinander jeweils    */
/*       die kf Knotenlasten fuer einen Knoten)                              */
/*                                                                           */
/*  Die nachfolgend fuer den "einfachen Femalg_m-Aufruf" beschriebenen       */
/*  erweiterten Varianten sind sinngemaess auch fuer den "sicheren           */
/*  Femalg_m-Aufruf" moeglich:                                               */
/*                                                                           */
/*               [succ uv] = femalg_m (xy,km,ep,kr,bk,sc)                    */
/*                                                                           */
/*  sc - nk*kf-Matrix (oder Vektor mit nk*kf Werten, nacheinander jeweils    */
/*       die kf Federsteifigkeiten fuer einen Knoten)                        */
/*                                                                           */
/*               [succ uv] = femalg_m (xy,km,ep,kr,bk,sc,li)                 */
/*                                                                           */
/*  li - nk*kf-Matrix (oder Vektor mit nk*kf Werten, nacheinander jeweils    */
/*       die Spalten der nk*kf-Matrix (Achtung, diese spaltenweise Uebergabe */
/*       der Werte als Vektor unterscheidet sich von den zeilenweise in      */
/*       einen Vektor zu packenden Werte der uebrigen Felder)                */
/*                                                                           */
/*               [succ uv] = femalg_m (xy,km,ep,kr,bk,sc,li,pu)              */
/*                                                                           */
/*  pu - nk*kf-Matrix (oder Vektor mit nk*kf Werten, nacheinander jeweils    */
/*       die kf vorgeschriebenen Verschiebungen fuer einen Knoten)           */
/*                                                                           */
/*          [succ uv] = femalg_m (xy,km,ep,kr,bk,sc,li,pu,et)                */
/*                                                                           */
/*  et - ne*5-Matrix (oder Vektor mit nk*5 Werten, nacheinander jeweils      */
/*       die 5 charakteristischen Groessen fuer ein Element)                 */
/*                                                                           */
/*          [succ uv] = femalg_m (xy,km,ep,kr,bk,sc,li,pu,et,la,aa)          */
/*                                                                           */
/*  la - Vektor mit nk Werten (jeweils die Kennzeichung fuer einen Konten:   */
/*       1 --> spezielles Lager, 0 --> kein spezielles oder gar kein Lager)  */
/*  aa - Vektor mit nk Werten (jeweils der Winkel bezueglich der x-Achse,    */
/*       wenn an diesem Knoten ein spezielles Lager existiert).              */
/*       Weil diese Lagerungsart zunaechst nur fuer zweidimensionale         */
/*       Probleme realisiert ist, ist nur eine Winkelangabe moeglich, obwohl */
/*       das Feld aa intern bereits fuer die Aufnahme von jeweils 3 Werten   */
/*       fuer jeden Knoten vorbereitet ist.                                  */
/*                                                                           */
/*  Autor: J. Dankert                                                        */
/* ************************************************************************* */

Download

Für den Aufruf der Interface-Funktion femalg_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:

femalg_m.dll      femalg_m.mexw64

Für Interessenten

Die komplette (in C geschriebene) "Mex-Funktion" femalg_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  femalg_m.c  femset_f.lib  femtnw_f.lib

und für die 64-Bit-Version mit

mex  femalg_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.