Matlab-Femset

MATLAB-Interface-Routine Elemat_m zur FEMSET-Funktion elemat_f

Die MATLAB-Interface-Routine Elemat_m (“MexFunction”) liefert mit Hilfe der FEMSET-Funktion elemat_f eine Elementbeziehung eines Finite-Elemente-Modells ab. Die Möglichkeiten des Aufrufs aus MATLAB wird im Kommentar am Anfang der Interface-Funktion beschrieben:

/* ************************************************************************* */
/*  ###  Finite-Elemente-Baukasten FEMSET  ###                               */
/*                                                                           */
/*  Aufbau einer Elementsteifigkeitsbeziehung bzw. der                       */
/*  Elementsteifigkeitsmatrix und der Elementmassenmatrix                    */
/*  =====================================================                    */
/*                                                                           */
/*  Es wird eine durch Knotenkoordinaten und Elementparameter beschriebene   */
/*  Elementbeziehung (Fall a) oder die ie-te Elementbeziehung eines          */
/*  FEM-Modells (Fall b) abgeliefert.                                        */
/*                                                                           */
/*  Fuer Elemente, die fuer elastostatische Berechnungen vorgesehen sind,    */
/*  werden Elementsteifigkeitsmatrix und Elementbelastungsvektor             */
/*  abgeliefert, fuer Elemente für die Eigenschwingungsberechnung sind es    */
/*  die Elementsteifigkeitsmatrix und die Elementmassenmatrix.               */
/*                                                                           */
/*  Fall a:                                                                  */
/*  -------                                                                  */
/*                                                                           */
/*  Es muessen genau 3 Input-Parameter uebergeben werden.                    */
/*                                                                           */
/*  Input:     kf - Anzahl der Freiheitsgrade pro Elementknoten              */
/*             xy - Matrix der Knotenkoordinaten (Reihenfolge der Knoten     */
/*                  muss der Elementknotennummerierung entsprechen)          */
/*             ep - Vektor der Elementparameter                              */
/*                                                                           */
/*  Aufruf:    [em eb] = elemat_m (kf , xy , ep)                             */
/*                                                                           */
/*  Output:    em  -  Elementsteifigkeitsmatrix                              */
/*             eb  -  Elementbelastungsvektor bzw. Elementmassenmatrix       */
/*                                                                           */
/*  Es wird die durch kf, xy und ep beschriebene                             */
/*  Elementbeziehung abgeliefert, wobei elemat_m die                         */
/*  die Information ueber den Elementtyp aus kf und den Formaten der         */
/*  Matrix xy und des Vektors ep entnimmt. Wenn damit ein nicht in FEMSET    */
/*  vorgesehener Elementtyp beschrieben wird, liefert elemat_m               */
/*  Nullmatrizen ab.                                                         */
/*                                                                           */
/*  Wenn der zweite Output-Parameter weggelassen wird, wird nur die          */
/*  die Elementsteifigkeitsmatrix abgeliefert.                               */
/*                                                                           */
/*                                                                           */
/*  Fall b:                                                                  */
/*  -------                                                                  */
/*                                                                           */
/*  Es wird die ie-te Elementbeziehung des FEM-Modells                       */
/*  abgeliefert. Die Knotennummern muessen in der ie-ten Zeile der           */
/*  Koinzidenzmatrix km stehen, die das Element beschreibenden Parameter     */
/*  in der ie-ten Zeile der Elementparametermatrix ep. Die Koordinaten       */
/*  der Elementknoten befinden sich in der Knotenkoordinatenmatrix xy.       */
/*  Zusaetzlich muss mindestens die Anzahl der Freiheitsgrade pro Knoten     */
/*  kf als Inputparameter erscheinen, so dass der einfachste Aufruf von      */
/*  elemat_m fuer Fall b so aussieht:                                        */
/*                                                                           */
/*            [em eb] = elemat_m (ie , kf , xy , km , ep)                    */
/*                                                                           */
/*  Output:    em  -  Elementsteifigkeitsmatrix                              */
/*             eb  -  Elementbelastungsvektor bzw. Elementmassenmatrix       */
/*                                                                           */
/*  Folgende Modifikationen des elemat_m-Aufrufs sind moeglich:              */
/*                                                                           */
/*  - Wenn der zweite Output-Parameter weggelassen wird, wird nur die        */
/*    die Elementsteifigkeitsmatrix abgeliefert.                             */
/*                                                                           */
/*  - Die von elemat_m benoetigten Informationen ueber die Element-          */
/*    Charakteristik (kx, kf, ke, kp) werden (bis auf kf, der immer          */
/*    als Input-Parameter angegeben werden muss) beim oben gezeigten Aufruf  */
/*    aus den Dimensionen der Matrizen ermittelt. Man kann diese Parameter   */
/*    auch alle entsprechend                                                 */
/*                                                                           */
/*         [em eb] = elemat_m (ie , kx , kf , ke , kp , xy , km , ep)        */
/*                                                                           */
/*    an elemat_m uebergeben, sie werden dann fuer eine Kompatibilitaets-    */
/*    pruefung benutzt ("sicherer Aufruf").                                  */
/*                                                                           */
/*             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 das Element beschreiben      */
/*                                                                           */
/*  - FEM-Modelle mit unterschiedlichen Elementtypen verwalten diese in      */
/*    der Elementtypmatrix et, die in jeweils einer Zeile 5 Informationen    */
/*    fuer das Element enthaelt:                                             */
/*                                                                           */
/*      *  Elementtyp,                                                       */
/*      *  Anzahl der Knoten,                                                */
/*      *  Anzahl der Elementparameter,                                      */
/*      *  Dimension des Elements (ein-, zwei- oder dreidimensional),        */
/*      *  Anzahl der Freiheitsgrade pro Knoten                              */
/*                                                                           */
/*    (entspricht einer kompletten "individuellen Element-Charakteristik"    */
/*    fuer den Elementtyp).                                                  */
/*                                                                           */
/*    In diesem Fall muss et als zusaetzlicher Input-Parameter uebergeben    */
/*    werden:                                                                */
/*                                                                           */
/*     [em eb] = elemat_m (ie , kx , kf , ke , kp , xy , km , ep , et) ;     */
/*                                                                           */
/*    In diesem Fall sind die Werte der "uebergeordneten Element-            */
/*    Charakteristik" kx, kf, ke, kp die Maximalwerte aus allen              */
/*    individuellen Element-Charakteristiken.                                */
/*                                                                           */
/*  Autor: J. Dankert                                                        */
/* ************************************************************************* */

Für Interessenten, so wird die DLL erzeugt: Mit der Anweisung

mex elemat_m.c femset_f.lib femtnw_f.lib

wird die Interface-Funktion elemat_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  elemat_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 Elemat_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  Elemat_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