Matlab-Femset

Die MATLAB-Interface-Routine Foumod_m zur FEMSET-Funktion foumod_f

Die MATLAB-Interface-Routine Foumod_m (“MexFunction”) speichert mit Hilfe der FEMSET-Funktion foumod_f den kompletten Datensatz eines Finite-Elemente-Modells ab. Das Dateiformat ist kompatibel mit allen Vorgänger-Versionen von FEMSET (BASIC, FORTRAN- und C-Version), die Dateien können also auch von den damit erzeugten Programmen und natürlich von der MATLAB-Interface-Funktion Finmod_m gelesen werden.

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

/* ************************************************************************* */
/*  ###  Finite-Elemente-Baukasten FEMSET  ###                               */
/*                                                                           */
/*  Schreiben aller Felder des Berechnungsmodells in eine Datei              */
/*  ===========================================================              */
/*                                                                           */
/*  Input:     filename (String)  -  Filename der zu lesenden Datei          */
/*             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)                 */
/*             uv  -  Matrix der Knotenverformungen     (11)                 */
/*                                                                           */
/*  Output:    succ = 1 --> Erfolg, die Datei wurde geschrieben              */
/*                    0 --> Misserfolg                                       */
/*                                                                           */
/*  Es sind grundsaetzlich zwei Typen von Funktionsaufrufen moeglich, die    */
/*  in ihrer jeweils kompletten Variante so aussehen:                        */
/*                                                                           */
/*  Der "einfache Foumod_m-Aufruf"                                           */
/*                                                                           */
/*      succ = foumod_m ('filename' , xy , km , ep , kr , bk , ...           */
/*                                    sc , li , pu , et , la , aa , uv)      */
/*                                                                           */
/*  ermittelt die Parameter kx, kf, ke, kp, ne und nk aus den Dimensionen    */
/*  der uebergebenen Matrizen. Bei dieser Variante duerfen beliebig viele    */
/*  der letzten 7 Matrizen weggelassen werden, fuer die dann Nullmatrizen    */
/*  ausgegeben werden (Aufruf mit mindestens 5 Matrizen).                    */
/*                                                                           */
/*  Der "sichere Foumod_m-Aufruf"                                            */
/*                                                                           */
/*      succ = foumod_m ('filename' , kx , kf , ke , kp , ne , nk , ...      */
/*                                    xy , km , ep , kr , bk , ...           */
/*                                    sc , li , pu , et , la , aa , uv)      */
/*                                                                           */
/*  ermoeglicht der Interface-Funktion den Test der Dimensionen der          */
/*  uebergebenen Matrizen mit den Werten auf den ersten 6 Positionen der     */
/*  Input-Parameterliste. Bei dieser Variante duerfen beliebig viele         */
/*  (gegebenenfalls alle) der 12 Matrizen (ab xy) weggelassen werden, fuer   */
/*  die dann Nullmatrizen ausgegeben werden (Aufruf mit mindestens den       */
/*  6 Werten kx, kf, ke, kp, ne, nk).                                        */
/*                                                                           */
/*  Beim "sicheren Aufruf" duerfen die Matrizen auch als eindimensionale     */
/*  Vektoren uebergeben werden (diese Variante ist allerdings nicht          */
/*  empfehlenswert).                                                         */
/*                                                                           */
/*  Formate der Input-Matrizen (die - nicht empfehlenswerte Variante in      */
/*  Klammern ist jeweils nur fuer den "sicheren Foumod_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 (1 oder 0 für verhinderte bzw. mögliche Verschiebung   */
/*       oder Vektor mit nk Werten (jeweils die Beschreibung der             */
/*       verhinderten Freiheitsgrade an einem Knoten - externes Format -)    */
/*  bk - nk*kf-Matrix (oder Vektor mit nk*kf Werten, nacheinander jeweils    */
/*       die kf Knotenlasten fuer einen Knoten)                              */
/*  sc - nk*kf-Matrix (oder Vektor mit nk*kf Werten, nacheinander jeweils    */
/*       die kf Federsteifigkeiten fuer einen Knoten)                        */
/*  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)                */
/*  pu - nk*kf-Matrix (oder Vektor mit nk*kf Werten, nacheinander jeweils    */
/*       die kf vorgeschriebenen Verschiebungen fuer einen Knoten)           */
/*  et - ne*5-Matrix (oder Vektor mit nk*5 Werten, nacheinander jeweils      */
/*       die 5 charakteristischen Groessen fuer ein Element)                 */
/*  la - Vektor mit nk Werten (jeweils die Kennzeichung fuer einen Knoten:   */
/*       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.                                  */
/*  uv - nk*kf-Matrix (oder Vektor mit nk*kf Werten, nacheinander jeweils    */
/*       die kf Verformungen fuer einen Knoten)                              */
/*                                                                           */
/*  Autor: J. Dankert                                                        */
/* ************************************************************************* */

Mit der Anweisung

mex foumod_m.c femset_f.lib femtnw_f.lib

wird die Interface-Funktion foumod_m.c übersetzt, und es werden alle Referenzen aufgelöst. Dafür müssen die beiden Femset-Libraries femset_f.lib und femtnw_f.lib bereitgestellt werden. Das Ergebnis ist eine DLL  foumod_m.dll, die wie eine Matlab-Function aus Matlab aufgerufen werden kann (und weil alle Referenzen aus Femset aufgelöst wurden, benötigt der Matlab-Benutzer nur diese DLL).

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

Für Interessenten, die den oben beschriebenen Weg zum Erzeugen der DLL nachempfinden wollen, stehen die komplette MexFunction, von der oben nur der Kopf-Kommentar zu sehen ist, als  Foumod_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