.. _accessEle: =========== **Element** =========== .. role:: red .. role:: big Befehle, die das Lesen und Zuweisen der Werte bzw. Eigenschaften von finiten Elementen ermöglichen. Geometrische Größen (Koordinaten, Längen und Flächen) entsprechen der global gewählten Längeneinheit (gobal_unit, siehe :any:`settings`). Übergebene oder zurückgelieferte Vektoren (Komponenten der Vektoren) beziehen sich, wenn in der Funktionsbeschreibung nicht explizit angegeben, auf das kartesisches System. Zur einfachen Umrechnung zwischen unerschiedlichen Bezugssystemen stehen Funktionen zur :any:`trans` zur Verfügung. :big:`Übersicht` ---------------------------------------------------------------------- +------------+--------------+----------+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Bezeichner | Anzahl Werte | Einheit | Zugriff get/set | Beschreibung | +------------+--------------+----------+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | valid | 1 | - | g | Gültigkeit | +------------+--------------+----------+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | type | 1 | - | g | Typ (linear, bilinear, quadratisch) | +------------+--------------+----------+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | key | 1 | - | g | Nummer | +------------+--------------+----------+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | sekey | 1 | - | g | Nummer des übergeordneten Superelement | +------------+--------------+----------+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | ndkeys | [N] | - | g | Nummern der N Knoten des Elements | +------------+--------------+----------+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | vertices | [2][N] | gu | g | Kartesische Koordinaten der N Knoten des Elements (Reihenfolge entgegen dem Uhrzeigersinn) | +------------+--------------+----------+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | reluc | 2 | Am/Vs | g/s | Reluktivität | +------------+--------------+----------+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | perm | 2 | Vs/Am | g/s | Permeabilität | +------------+--------------+----------+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | mag | 2 | T | g/s | Magnetisierung | +------------+--------------+----------+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | xycp | 2 | gu | g | Koordinaten des Elementmittelpunkts | +------------+--------------+----------+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | area | 1 | gu² | g | Elementfläche | +------------+--------------+----------+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | induc | 2 | T | g | Induktionsvektor im Elementmittelpunkt (Komponenten im aktuellen Bezugssystem). Siehe nachfolgendes Anwendungsbeispiel. | +------------+--------------+----------+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | induc(x) | 3 | T, T, gu | g | Induktionsvektor im Elementmittelpunkt (Komponenten im kartesischen Bezugssystem) für vorgegebene Position/Zeitschritt und Lastfall. Siehe nachfolgendes Anwendungsbeispiel. | +------------+--------------+----------+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | induc() | [3][N] | T, T, gu | g | Induktionsvektor im Elementmittelpunkt (Komponenten im kartesischen Bezugssystem) über alle Positionen/Zeitschritte N für vorgegebenen Lastfall. Siehe nachfolgendes Anwendungsbeispiel. | +------------+--------------+----------+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | curd | 2 | A/mm² | g | Stromdichte (Realteil, Imaginärteil) im Element einer Wicklung oder eines Massivleiters | +------------+--------------+----------+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | curlosd | 1 | W/mm³ | g | (Wirbelstrom)verlustdichte (Mittelwert) im Element eines Massivleiters nach magnetostatischer oder -dynamischer Rechnung | +------------+--------------+----------+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | pmfelosd | 1 | W/mm³ | g | Verlustdichte (Mittelwert) im Eisen oder Permanentmagnet nach magnetostatischer Feld- und Verlustberechnung | +------------+--------------+----------+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ gu = globale Längeneinheit :big:`Befehlsbeschreibung` ---------------------------------------------------------------------- .. admonition:: Function: *key* = get_elem_key ( *x, y* ) Gibt die Nummer eines Elementes zurück, das über die kartesischen Koordinaten x und y ausgewählt ist. **Parameter** | [in] :red:`x` Coordinate 1 | [in] :red:`y` Coordinate 2 **Return values** key Elementnummer Beispiel :: key = get_elem_key(x,y) -- Get the element's number printf("element key = %d",key) -- Output to shell .. admonition:: Command: get_elem_keys ( *x, y, "var"* ) Gibt die Nummern aller Elemente eines Superelementes zurück, das über die kartesischen Koordinaten x und y ausgewählt ist. **Parameter** | [in] :red:`x` Koordinate 1 | [in] :red:`y` Koordinate 2 | [out] :red:`var` Bezeichner des Arrays in dem Elementnummern zurückgegeben werden Beispiel :: get_elem_keys(x,y,"keys") -- Get all elements of the superelement addressed by x,y N = table.getn(keys) -- Number of elements in array .. admonition:: Command: get_elem_keys ( *sekey, "var"* ) Gibt die Nummern aller Elemente eines Superelements zurück, dessen Nummer sekey angegeben ist. **Parameter** | [in] :red:`sekey` Nummer des SuperekementsKoordinate | [out] :red:`var` Bezeichner des Arrays in dem Elementnummern zurückgegeben werden Beispiel :: get_elem_keys(36,"keys") -- Get all elements of the superelement addressed by its number N = table.getn(keys) -- Number of elements in array .. admonition:: Command: get_elem_keys ( *"var"* ) Gibt die Nummern aller Elemente des Modells zurück. **Parameter** [out] :red:`var` Bezeichner des Arrays in dem Elementnummern zurückgegeben werden Beispiel :: get_elem_keys("keys") -- Get all elements N = table.getn(keys) -- Number of elements in array .. admonition:: Function: *d1, d2, ...* = get_elem_data ( *"identifier", key* ) Liest Daten eines Elementes und gibt diese zurück. **Parameter** | [in] :red:`identifier` Art der auszulesenden Daten (siehe Tabelle) | [in] :red:`key` Elementnummer **Return values** d1 Erster Rückgabewert d2 Zweiter Rückgabewert Beispiel: Lesen der Magnetisierung :: Mx,My = get_elem_data("mag",key) Alternativ zu key kann das Element auch über kartesische Koordinaten in der globalen Einheit adressiert werden. :: Mx,My = get_elem_data("mag",x,y) .. admonition:: Command: set_elem_data ( "identifier", key, d1, d2, ... ) Weist einem Element die angegebenen Eigenschaften zu. **Parameter** | [in] :red:`identifier` Art der zuzuweisenden Eigenschaft (siehe Tabelle) | [in] :red:`key` Elementnummer | [in] :red:`d1` Erster zuzuweisender Wert | [in] :red:`d2` Zweiter zuzuweisender Wert Beispiel: Festlegung der Magnetisierung eines Elementes :: set_elem_data("mag",key,1.2,0) Anwendungsbeispiele ^^^^^^^^^^^^^^^^^^^ Allgemeiner Zugriff auf die Elementdaten ---------------------------------------- Alle Elemente eines Superelementes werden ermittelt und die Koordinaten, Flächen und weitere Eigenschaften der Elemente in einer Datei ausgegeben. :: cosys('polar') -- coordinate system has to be r-phi grf_clear() -- clear graphic output draw_spels() -- draw superelements x = 23 y = 5 get_elem_keys(x,y,"elkeys") -- get all element keys of addressed superelement data=io.open("el_data_1.txt","w+") -- output in data file data:write("# elkeys x y A mu M\n"); N = table.getn(elkeys) -- number of elements in array i = 0 verbosity = 1 -- suppress detailed output repeat i = i+1 x,y = get_elem_data("xycp",elkeys[i]) -- read element data "coordinates of center point" A = get_elem_data("area",elkeys[i]) -- ... "area" point(x,y,"black","x") -- draw points draw_elem(x,y,"black",0) -- and elements draw_elem(elkeys[i],"black",0) -- ... using the element key alternatively mu = get_elem_data("perm",elkeys[i]) -- read element data "permeability" Mx,My = get_elem_data("mag",elkeys[i]) data:write(string.format("%d %d %g %g %g %g %g\n",i,elkeys[i],x,y,A,mu,math.sqrt(Mx*Mx+My*My))) set_elem_data("mag",elkeys[i],0.5*Mx,0.5*My) -- set element data "magnetization" until i>=N io.close(data) -- don't forget to close the file Einfärben der Elemente eines Superelementes entsprechend einer Elementeigenschaft/-größe. :: function colgrad(elkey,val,low,high) -- user defined function in FSL for specific color gradations if val>=low and val<=high then rval=(val-low)/(high-low) col = 45-(45-21)*rval draw_elem(elkey,col,0) elseif val high then draw_elem(elkey,"black",0) end return end get_elem_keys(x,y,"keys") -- get all element numbers of addressed superelement N = table.getn(keys) -- determine number of keys for i=1,N do M1,M2 = get_elem_data("mag",keys[i]) -- get magnetization of superelements M = math.sqrt(M1*M1+M2*M2) colgrad(keys[i],M,0,1.4) -- color gradation of elements end .. _accessEle_Induct: Induktion und Induktionsverlauf in den Elementen ------------------------------------------------ Rückgabe der Induktion des letzten durchgeführten Berechnungsschrittes. Die Rückgabewerte B1 und B2 sind die Komponenten des Induktionsvektors im gewählten globalen Bezugssystem (kartesisch: B1=x, B2=y, polar: B1=R, B2=phi, zylindrisch: B1=R, B2=z). :: B1,B2 = get_elem_data("induc",elkey) print(B1, B2) Rückgabe der Anzahl der Berechnungsschritte :: N = get_sim_data("num_move_steps") Rückgabe der Induktion zum Berechnungsschritt mstep des Lastfalls lstep. Die Rückgabewerte B1 und B2 sind die Komponenten des Induktionsvektors in einem kartesischen Bezugssystem. Der Rückgabewert x entspricht der Position oder der Zeit zum Berechnungsschritt mstep. Das Bezugssystem ist für die Elemente des ruhenden Teil der Maschine gleich dem globalen. Für die Elemente des rotierenden Teils gilt ein bewegtes Bezugssystem, d. h. ein um die Rotordrehstellung gegenüber dem globalen gedrehten System. Die Induktionsverläufe werden also je nach Zugehörigkeit der Elemente zu Stator oder Rotor in einem stator- bzw. rotorfesten kartesischen Bezugssystem zurückgegeben. Syntax:: B1,B2,x,stat = get_elem_data("induc(x)",elkey,mstep,lstep) -- B1: Erste kartesische Komponente des Induktionsvektors -- B2: Zweite kartesische Komponente des Induktionsvektors -- x: Position oder Zeit zum Berechnungsschritt mstep -- stat: 1 = Ausführung ohne Fehler, 0 = Fehler bei der Ausführung -- elkey: Elementnummer -- mstep: Berechnungsschritt 1, 2, ... N -- lstep: Lastfall 1, 2, 3, ... Im Falle einer Reluktanz-/PM-Synchronmotor-Simulation (FSL-Befehl: run_models("pm_sym_fast")) hat das Argument "lstep" folgende Bedeutung 1: Leerlauf 2: Stromwinkel Null 3: Stromwinkel wie vorgegeben (oder durch FEMAG ermittelt) Im Falle einer Multiple-I/x-Berechnung (FSL-Befehl run_models("mult_cal_fast")) entspricht lstep der Nummer des berechneten Lastfalls. Wird nur ein Fall berechnet, ist lstep = 1 anzugeben. Wird das Argument lstep bei Adressierung des Elements über elkey nicht angegeben, nimmt FEMAG implizit lstep = 1 an. .. note:: Die implizite Auswahl des Lastfalls 1 ist bei Adressierung des Elements über Koordinaten nicht zulässig. Beispiel:: verbosity = 1 data=io.open("elem_data.txt","w+") for i=1,N do B1,B2,x = get_elem_data("induc(x)",elkey,i,3) -- Adressierung über Elementnummer B1,B2,x = get_elem_data("induc(x)",x,y,i,3) -- Adressierung über Elementkoordinaten B1,B2,x = get_elem_data("induc(x)",elkey,i) -- Adressierung über Elementnummer, implizit erster Lastfall data:write(string.format("%d %g %g %g\n",i,x,B1,B2)) end io.close(data) Rückgabe des Induktionsverlaufs im Element für den Lastfalls lstep. Zurückgegeben wird eine Matrix der Dimension B[3][N] für alle berechneten Positionen/Zeitschritte. Syntax:: B,stat = get_elem_data("induc()",elkey,lstep) -- Adressierung über Elementnummer -- B[1][...]: Erste kartesische Komponente des Induktionsvektors -- B[2][...]: Zweite kartesische Komponente des Induktionsvektors -- B[3][...]: Position in Grad (Rotation), globaler Längeneinheit (Translation) oder Zeit in s -- stat: 1 = Ausführung ohne Fehler, 0 = Fehler bei der Ausführung -- elkey: Elementnummer -- lstep: Lastfall 1, 2, 3, ... Beispiel:: B,stat = get_elem_data("induc()",elkey,3) -- Adressierung über Elementnummer B,stat = get_elem_data("induc()",x,y,3) -- Adressierung über Elementkoordinaten B,stat = get_elem_data("induc()",elkey) -- Adressierung über Elementnummer, implizit erster Lastfall print(stat) M = table.getn(B) N = table.getn(B[1]) print(M, N) data=io.open("elem_data.txt","w+") for i=1,N do data:write(string.format("%d %g %g %g\n",i,B[3][i],B[1][i],B[2][i])) end io.close(data)