Aufbau der REXS Objekte
Modell-Objekt
Das REXS Modell ist in einem XML- oder JSON-Objekt namens "model" enthalten.
Merkmal | Beschreibung | |
---|---|---|
Teil der REXS-Datei | version | Version der REXS Schnittstelle. Format: Hauptversionsnummer.Unterversionsnummer Beispiel: version="1.2" |
applicationId | Name der Applikation, die die XML-Datei erzeugt hat, z.B. „FVA-Workbench“. | |
applicationVersion | Version der Applikation. | |
date | Zeitpunkt zu dem die Datei erstellt wurde. Datums- und Zeitangabe nach ISO 8601 im Format „yyyy-mm-ddThh:mm:ss+<offset to UTC>“ Beispiel: 2016-06-03T11:35:17+01:00 | |
applicationLanguage | Optional: Angabe der Sprache die in der Anwendung verwendet wurde. Sprachcode nach ISO 639-1 Beispiel: applicationLanguage="en" |
Modell-Objekt - XML-Syntax
Das REXS Modell ist in einem XML-Tag namens "model" enthalten. Dieses enthält wiederum die "relations"- und "components"-Tags, sowie ggfs. das "load_spectrum"-Tag.
Beispiel Modell REXS-Datei | XML-Syntax
<model version="1.4" applicationId="FVA-Workbench" applicationVersion="7.0.0" date="2021-11-03T11:35:17+01:00" applicationLanguage="en"> <relations>...</relations> <components>...</components> <load_spectrum>...</load_spectrum> (optional) </model>
Modell-Objekt - JSON-Syntax
Das REXS Modell ist in einem JSON-Objekt namens "model" enthalten. Dieses beinhaltet eine Reihe von Namen-Wert-Paaren. Neben den Metadaten ("version", "applicationId", "applicationVersion", "date", "applicationLanguage") enthält das "model"-Objekt die "relations" und "components" Arrays, sowie ggfs. ein "load_spectrum" Objekt.
Beispiel Modell REXS-Datei | JSON-Syntax
{"model": { "version": "1.4", "applicationId":"FVA-Workbench", "applicationVersion":"7.0.0", "date":"2021-11-03T11:35:17+01:00", "applicationLanguage":"en", "relations": [...], "components": [...], "load_spectrum": {...} (optional) } }
Aufbau der Komponenten
Merkmal | Beschreibung | Details | |
---|---|---|---|
Teil der REXS-Datei | type | Typ der Komponente, z.B. „shaft“ (Welle) Datentyp: Enum | Namenskonvention Liste Komponenten |
id | Eindeutiger Bezeichner der Komponente in der konkreten Modellinstanz Datentyp: Integer | ||
name | Vom Anwender festgelegte Bezeichnung der Komponente in der konkreten Modellinstanz Datentyp: String | optional | |
Meta-Daten (in der Datenbank) | designation | Bezeichnung der Komponente (Mehrsprachig) |
Komponenten - XML-Syntax
In der Schnittstellendatei werden Komponenten mit dem XML-Tag <component></component> beschrieben.
Der Inhalt des Tags sind die der Komponente zugehörigen Attribute:
Beispiel Komponenten | XML-Syntax
<components> <component id="4" type="cylindrical_gear" name="Pinion"> <attribute id="attr1"> .. </attribute> <attribute id="attr2"> .. </attribute> ... </component > <component id="6" type="cylindrical_gear" name="Wheel"> <attribute id="attr1"> .. </attribute> <attribute id="attr2"> .. </attribute> ... </component > </components>
Komponenten - JSON-Syntax
Das "components" Array enthält eine Liste von JSON Objekten. Jedes dieser Objekte enthält die Namen-Wert-Paare "id" (Id der Komponente), "name" (Bezeichnung der Komponente), "type" (Komponententyp), sowie das "attributes" Array.
Beispiel Komponenten | JSON-Syntax
"components":[ {"id":4, "type"="cylindrical_gear", "name":"Pinion", "attributes": [ {"id": "attr1", "boolean": false}, {"id": "attr2", "unit": "none", "floating_point": 0.1}, ... ] }, {"id":6, "type"="cylindrical_gear", "name":"Wheel", "attributes": [ ... ] } ]
Aufbau der Attribute
Merkmal | Beschreibung | Details | |
---|---|---|---|
Teil der REXS-Datei | id | Eindeutiger Bezeichner des Attributes in REXS Datentyp: String | |
unit | Als Einheitensystem wird vorzugsweise das SI-System verwendet. Die zu verwendende Einheit ist für jedes Attribut in der Attributdatenbank festgelegt. Alle Werte eines Arrays oder einer Matrix besitzen dieselbe Maßeinheit. | ||
Optional in REXS-Datei | origin | Möglichkeit für eine Anwendung einen Attributwert als entweder "user_defined" oder "calculated" zu kennzeichnen. Die Unterscheidung welche Attribute Eingabeparameter und/ oder Ausgabeparameter sein können ist sehr Anwendungsspezifisch. Es gibt daher dazu keine entsprechende Festlegung im Standard und es bleibt jeder Anwendung beim Lesen einer REXS-Datei überlassen ob Sie diese Zusatzinformation berücksichtigt oder nicht. | Optional HinweisÄnderung ggü. REXS Version 1.4 Die Möglichkeit Attribute als "user_defined" oder "calculated" zu kennzeichnen ist neu. |
Meta-Daten (in der Datenbank) | component | Komponententyp, der über dieses Attribut verfügt. Zuordnung zur Komponente in der REXS-Datei erfolgt über die XML-/ JSON-Hierarchie (siehe Aufbau der Komponenten) | |
numeric_id | Fortlaufende Nummerierung im Produktmodell | ||
type | Datentyp des Attributwertes | ||
value_range | Werte- bzw. Gültigkeitsbereich | ||
symbol | Formelzeichen des Attributes, falls vorhanden | ||
designation | Bezeichnung des Attributs (Mehrsprachig) | ||
description | Eindeutige Definition des Attributs (Mehrsprachig) |
Zulässige Datentypen
Folgende Datentypen stehen für die Attribute zur Auswahl:
Datentyp | Details |
---|---|
scalar | Skalare Werte |
boolean | true, false |
string | |
integer | |
floating_point | maximale Anzahl signifikanter Stellen: 15 |
enum | haben einen vorgegebenen Wertebereich |
file_reference | Verweis auf Datei oder Ordner (relativ oder absolut) |
reference_component | Verweis auf Komponenten-Id |
date_time | Datum und Uhrzeit nach ISO 8601 im Format: "yyyy-mm-ddThh:mm:ss+<offset to UTC>" Beispiel: 2016-06-03T11:35:17+01:00 |
array | Eindimensionales Array aus Werten |
floating_point_array | |
integer_array | |
boolean_array | |
string_array | |
enum_array | Array von enum-Werten |
matrix | Zweidimensionales Array aus Werten bei dem jede Zeile die gleiche Länge hat |
floating_point_matrix | |
integer_matrix | |
boolean_matrix | |
string_matrix | |
array_of_arrays | Zweidimensionales Array bei dem die Zeilen unterschiedliche Länge haben können |
array_of_integer_arrays |
Wertebereich - "value_range"
Bei numerischen Attributen wird der zulässige Definitionsbereich in der REXS-Datenbank in Intervallschreibweise angegeben. Es gilt folgende Konvention:
Öffnende-Klammer: Intervall-Untergrenze
Schließende-Klammer: Intervall-Obergrenze
Zusätzlich gilt
runde Klammer: Intervall-Grenze gehört nicht zum Intervall (< / >)
eckige Klammer: Intervall-Grenze gehört zum Intervall (<= / >=)
Wertebereich | Schreibweise |
---|---|
0 < Wert | (0; ∞) |
0 <= Wert < 1 | [0; 1) |
-90 <= value <= 90 | [-90;90] |
unbeschränkt | (-∞; ∞) |
Der Wertebereich von enum-Attributen ist ebenfalls in der REXS-Datenbank festgehalten.
Regeln zur Vergabe von Einheiten
Für jedes Attribut wird in der REXS-Datenbank festgelegt, in welcher Einheit es anzugeben ist. Falls das Attribut keine Einheit hat ist "none" als Einheit anzugeben. Eine Angabe in einer anderen Einheit als der in der REXS-Datenbank spezifizierten ist nicht zulässig, auch wenn diese konvertierbar wäre. Wenn Anwendungen intern andere Einheiten verwenden, müssen sie in/aus der in REXS angegebenen Einheit konvertieren.
Die Liste der möglichen Einheiten kann in der REXS-Datenbank eingesehen werden.
Konvention
Absolut-Temperaturen sind immer in °C anzugeben.
Temperaturdifferenzen sind immer in K anzugeben.
Regeln zur Kennzeichnung der Unit-ID:
Maximal ein SI-Präfix wird der Einheit vorangestellt. Bsp: mm
Produkt von Einheiten durch Leerzeichen kennzeichnen. Bsp: N m
Potenzen werden durch ^ dargestellt. Bsp: m^2
Brüche werden durch / dargestellt. Ein Produkt im Nenner ist durch Klammern zu kennzeichnen. Beispiel: kg / (m^2 s^3)
Base64-Kodierung von Attributen
Überschreiten Arrays und Matrizen eine gewissen Größe, kann es aus Performancegründen sinnvoll sein diese in Binärform in der REXS-Datei abzulegen.
Ein Array wird dazu zunächst in Binärform gebracht. Die Byte-Reihenfolge ist „Little Endian“. Im zweiten Schritt wird dieses byte-Array dann per base64-Kodierung in einen String gewandelt. Dieser steht dann in der REXS-Datei. Zusätzlich muss das verwendete Binärformat (int32, float64, oder float32) gekennzeichnet werden.
Bei der Codierung einer Matrix wird folgendermaßen vorgegangen: Zunächst wird die 2d-Matrix spaltenweise in ein 1d-Array überführt ( array = [spalte1, spalte2, ...]). Dieses wird dann wie oben beschrieben in Binärform gebracht (Byte-Reihenfolge ist „Little Endian“) und schließlich per base64-Kodierung in einen String gewandelt. Neben der Angabe des Binärformats (int32, float64, float32) ist die Angabe der Anzahl der Spalten und Zeilen der Matrix notwendig.
Für weitere Informationen zur Kennzeichnung von base64-kodierten Attributen in der REXS Datei siehe auch XML-Syntax, bzw. JSON-Syntax, sowie Code Beispiele
Attributwerte - XML-Syntax
Merkmal | Beschreibung | |
---|---|---|
Werte von skalaren Attributen: | Der Wert des Attributes ist der Inhalt des „attribute“-Tags, z.B. <attribute …>4.72</attribute>. | |
Das Gleitkomma-Zeichen ist „ . “ (Punkt). | ||
Werte von Arrays | array | Das Tag „array“ umschließt die Spalten eines eindimensionalen Arrays. |
c | Das Tag „c“ (column) kennzeichnet eine Spalte des Arrays, und umschließt einen skalaren Eintrag des Arrays (siehe Beispiel unten) | |
Das Gleitkomma-Zeichen ist „ . “ (Punkt). | ||
code | Überschreiten Arrays eine gewissen Größe, kann es aus Performancegründen sinnvoll sein diese in Binärform in der REXS-Datei abzulegen. Dazu kann das optionale xml-Attribut "code" im array-tag verwendet werden. Folgende Varianten stehen zur Verfügung:
Falls das Array in Binärform angegeben wird entfallen die "c" Tags. | |
Werte von Matrizen | matrix | Das Tag „matrix“ umschließt die Zeilen einer Matrix. |
r | Das Tag „r“ (row) kennzeichnet eine Zeile der Matrix, und umschließt eine Liste von "c" Einträgen. Der Inhalt aller Zeilen muss die gleiche Länge haben. | |
c | Das Tag „c“ (column) kennzeichnet eine Spalte der Matrix, und umschließt einen skalaren Eintrag der Matrix (siehe Beispiel unten) | |
Das Gleitkomma-Zeichen ist „ . “ (Punkt). | ||
code, rows, columns | Überschreiten Matrizen eine gewissen Größe, kann es aus Performancegründen sinnvoll sein diese in Binärform in der REXS-Datei abzulegen. Dazu kann das optionale xml-Attribut "code" im matrix-tag verwendet werden. Zusätzlich müssen bei binär kodierten Matrizen über "rows" und "columns" die Anzahl der Reihen und Spalten im matrix-tag mit angegeben werden. Dies ist Nowendig um bei der Decodierung das 1d-Byte-Array wieder in eine 2d-Matrix konvertieren zu können. Folgende Varianten stehen zur Verfügung:
Falls die Matrix in Binärform angegeben wird entfallen die "r" und "c" Tags. | |
Werte von Arrays-of-Arrays | array_of_arrays | Das Tag „array_of_array“ umschließt die Zeilen eines Array-of-Arrays. |
array | Das Tag „array“ kennzeichnet eine Zeile des Array-of-Arrays, und umschließt eine Liste von "c" Einträgen. Die Zeilen können unterschiedliche Länge haben. | |
c | Das Tag „c“ (column) kennzeichnet eine Spalte eines Array, und umschließt einen skalaren Eintrag des Array-of-Arrays (siehe Beispiel unten) |
Beispiel Attribute - XML-Syntax
Beispiel String-Attribut | XML-Syntax
<attribute id="name">30203-A</attribute>
Beispiel Double-Attribut mit Maßeinheit | XML-Syntax
<attribute id="normal_module" unit="mm">23.5</attribute>
Beispiel Double-Attribut ohne Maßeinheit | XML-Syntax
<attribute id="addendum_modification_coefficient" unit="none">0.5</attribute>
Beispiel Attribut mit origin="user_defined" | XML-Syntax
<attribute id=addendum_modification_coefficient" unit="none" origin="user_defined">0.5</attribute>
Besipiel Attribut mit origin="calculated" | XML-Syntax
<attribute id=addendum_modification_coefficient" unit="none" origin="calculated">0.5</attribute>
Beispiel Integer-Attribut ohne Maßeinheit | XML-Syntax
<attribute id="number_of_teeth" unit="none">8</attribute>
Beispiel Boolean-Attribut | XML-Syntax
<attribute id="is_driving_gear">false</attribute>
Beispiel Enum-Attribut | XML-Syntax
<attribute id="axial_force_absorption">both_directions</attribute>
Beispiel Array-Attribut | XML-Syntax
<attribute id="support_vector" unit="mm"> <array> <c>1.0</c> <c>1.0</c> <c>0.0</c> </array> </attribute>
Beispiel Matrix-Attribut | XML-Syntax
<attribute id="matrix_correction" unit="mm"> <matrix> <r> <c>0.0</c> <c>0.0</c> <c>0.0</c> <c>0.0</c> <c>0.0</c> <c>0.0</c> <c>0.0</c> <c>0.0</c> <c>0.0</c> </r> <r> <c>0.0</c> <c>0.0</c> <c>0.0</c> <c>0.0</c> <c>0.0</c> <c>0.0</c> <c>0.0</c> <c>0.0</c> <c>0.0</c> </r> ... <r> <c>0.0</c> <c>0.0</c> <c>0.0</c> <c>0.0</c> <c>0.0</c> <c>0.0</c> <c>0.0</c> <c>0.0</c> <c>0.0</c> </r> </matrix> </attribute>
Beispiel Array-Attribut in Binärform | XML-Syntax
<attribute id="example_attribute_id" unit="mm"> <array code="float64"/>62wRNhgQS0AAAAAAAAAAANgPsyG1MXDA=<array/> </attribute>
Beispiel Matrix-Attribut in Binärform | XML-Syntax
<attribute id="example_matrix_coded" unit="mm"> <matrix code="float64" columns="3" rows="2">AAAAAAAA8D8AAAAAAAAQQAAAAAAAAABAAAAAAAAAFEAAAAAAAAAIQAAAAAAAABhA</matrix> </attribute>
Beispiel array_of_integer_arrays-Attribut | XML-Syntax
<attribute id="element_structure" unit="none"> <array_of_arrays> <array><c>108</c><c>2</c><c>1</c><c>107</c></array> <array><c>109</c><c>3</c><c>2</c><c>108</c></array> <array><c>8</c><c>114</c><c>115</c></array> </array_of_arrays> </attribute>
Attributwerte - JSON-Syntax
Dass "attributes" Array enthält eine Liste von Objekten mit den folgenden Namen-Wert-Paaren: "id" (Attribut-Id), "unit" (Einheit, bei bestimmten Datentypen notwendig), "origin" (optional, kennzeichnet das Attribut als "calculated" oder "user_defined"), sowie dem Attributwert. Um eine JSON-Validierung zu ermöglichen wird dabei je nach Datentyp ein unterschiedlicher Kenner verwendet. Die verfügbaren Kenner werden im folgenden aufgelistet. Für Details zu binärcodierten Arrays und Matrizen siehe auch Anmerkung und Anmerkung.
Datentyp | Details | JSON-Kenner | JSON Beispielwert |
---|---|---|---|
scalar | Skalare Werte | ||
boolean | true, false | boolean | false |
string | string | "NU 206" | |
integer | integer | 3 | |
floating_point | Das Gleitkomma-Zeichen ist „ . “ (Punkt). maximale Anzahl signifikanter Stellen: 15 | floating_point | 2.0 |
enum | haben einen vorgegebenen Wertebereich | enum | "both_directions" |
reference_component | Id der Referenzkomponente für die Pose-Angabe | reference_component | 1 |
file_reference | Verweis auf Datei oder Ordner (relativ oder absolut) | file_reference | "example.gde" |
array | Eindimensionales Array aus Werten | ||
floating_point_array | Das Gleitkomma-Zeichen ist „ . “ (Punkt). maximale Anzahl signifikanter Stellen: 15 | floating_point_array | [1.0,0.0,0.0] |
floating_point_array | in Binärform | floating_point_array_coded | {"code": "float64", "value": "62wRNhgQS0AAAAAAAAAAANgPsyG1MXDA"}} |
integer_array | integer_array | [1,2,3] | |
boolean_array | boolean_array | [true,false,true] | |
string_array | string_array | ["example 1","example 2"] | |
enum_array | Der Datentyp enum_array ist neu. Array von enum-Werten | enum_array | ["quad4","triangle3","quad4"] |
matrix | Zweidimensionales Array aus Werten bei dem jede Zeile die gleiche Länge hat | ||
floating_point_matrix | Das Gleitkomma-Zeichen ist „ . “ (Punkt). maximale Anzahl signifikanter Stellen: 15 | floating_point_matrix | [[1.0,0.0,0.0],[0.0,1.0,0.0],[0.0,0.0,1.0]] |
floating_point_matrix | In Binärform | floating_point_matrix_coded | {"code": "float64", "rows":2, "columns":3 "value": "AAAAAAAA8D8AAAAAAAAQQAAAAAAAAABAAAAAAAAAFEAAAAAAAAAIQAAAAAAAABhA"}} |
integer_matrix | integer_matrix | [[1,0,0],[0,1,0],[0,0,1]] | |
boolean_matrix | boolean_matrix | [[true,false,true],[false,false,true],[true,false,false]] | |
string_matrix | string_matrix | [["example 1","example 2"],["example 3","example 4"]] | |
array_of_arrays | Zweidimensionales Array bei dem die Zeilen unterschiedliche Länge haben können | ||
array_of_integer_arrays | array_of_integer_arrays | [[1,2,3,4],[1,3,4,5,6],[7,9,11]] |
Beispiel Attributliste | JSON-Syntax
"attributes":[ {"id": "name", "string": "30203-A"}, {"id": "normal_module", "unit": "mm", "floating_point": 2.0}, {"id": "addendum_modification_coefficient", "unit": "none", "floating_point": 0.1}, {"id": "addendum_modification_coefficient", "unit": "none", "origin":"user_defined", "floating_point": 0.1}, {"id": "addendum_modification_coefficient", "unit": "none", "origin":"calculated", "floating_point": 0.1}, {"id": "number_of_gears", "integer": 3}, {"id": "is_driving_gear", "boolean": false}, {"id": "axial_force_absorption", "enum": "both_directions" }, {"id": "u_axis_vector", "unit": "mm","floating_point_array": [1.0,0.0,0.0]}, {"id": "matrix_correction", "unit": "mm", "floating_point_matrix": [[1.0,0.0,0.0],[0.0,1.0,0.0],[0.0,0.0,1.0]] }, {"id": "example_array_coded", "unit": "mm", "floating_point_array_coded": {"code": "float64", "value": "62wRNhgQS0AAAAAAAAAAANgPsyG1MXDA"}}, {"id": "example_matrix_coded", "unit": "mm", "floating_point_matrix_coded": {"code": "float64", columns="3", rows="2", "value": "AAAAAAAA8D8AAAAAAAAQQAAAAAAAAABAAAAAAAAAFEAAAAAAAAAIQAAAAAAAABhA62wRNhgQS0AAAAAAAAAAANgPsyG1MXDA"}}, {"id": "element_structure", "array_of_integer_arrays": [[108,2,1,107,7],[0,1,0],[0,7,0,1]]}, ]
Aufbau der Relationen
Relationen verbinden Komponenten zu Baugruppen. Eine Relation besteht aus einem „relation“ Objekt, welcher mehrere „ref“ Objekte enthält. In einer Relation dürfen nicht mehrere "ref" Objekte mit der gleichen Rolle vorkommen. Es ist also z.B. nicht erlaubt mehrere "part" Elemente in der gleichen assembly Relation zu verwenden. Für jedes "part" muss eine eigene Relation erstellt werden.
Merkmal | Beschreibung | Details | |
---|---|---|---|
Teil der REXS-Datei | id | Eindeutiger Bezeichner der Relation in der konkrete Modellinstanz Datentyp: Integer | |
type | Typ der Relation, z.B. „assembly“ Folgt der Namenskonvention Datentyp: String | ||
order | Manche Relationen (z.B. "ordered_assembly_relation") zwischen zwei Komponenten verfügen zusätzlich über eine Reihenfolge. Diese wird durch die "order" festgelegt. Dadurch ist es z.B. möglich die einzelnen Lagerreihen eines Wälzlagers eindeutig zuzuordnen. Datentyp: Integer Die kleinste "order" ist immer =1 und wird in 1er-Schritten inkrementiert. |
Merkmal | Beschreibung | Details | |
---|---|---|---|
Teil der REXS-Datei | id | ID einer Komponente in der Relation | |
role | Rolle der Komponente in der Relation (z.B. Stufe) | ||
Optional in REXS-Datei | hint | Hinweis zur besseren Lesbarkeit der Relation, z.B. Typ der referenzierten Komponente, max. 40 Zeichen |
Modellierungsrichtlinie Quasistatisch
Unvollständige Relationen sind unzulässig. Jede Relation muss also alle für diesen Relationstyp zur Verfügung stehenden Rollen genau einmal enthalten.
Modellierungsrichtlinie Quasistatisch
Das Modell muss zusammenhängend sein, jede Komponente muss also über das Relationen-Netzwerk mit der gear_unit (indirekt) verbunden sein. Insbesondere sind Komponenten die in keiner Relation vorkommen nicht zulässig.
Relationen - XML-Syntax
Eine Relation in der XML-Datei besteht aus einem „relation“-Tag, welcher mehrere „ref“-Tags enthält.
Beispiel Relationen REXS-Datei | XML-Syntax
<relations> <relation id="15" type="ordered_assembly" order="1"> <ref id="8" role="assembly" hint="bearing"/> <ref id="16" role="part" hint="bearing_row"/> </relation> <relation id="23" type="stage"> <ref id="3" role="stage" hint="cylindrical_stage"/> <ref id="7" role="gear_1" hint="cylindrical_gear"/> <ref id="9" role="gear_2" hint="cylindrical_gear"/> </relation> </relations>
Relationen - JSON-Syntax
Das "relations" Array enthält eine Liste von JSON Objekten. Jedes dieser Objekte enthält die Namen-Wert-Paare "id" (Id der Relation), "type" (Relationstyp), "order" (bei entsprechenden Relations-typen) und das "refs" Array. Dieses enthält eine Liste von Objekten mit den Namen-Wert-Paaren "role" (Rolle der Komponente in der Relation) "id" (Id der Komponente in der Relation), "hint" (optionale Ergänzung zur besseren Lesbarkeit).
Beispiel Relationen REXS-Datei | JSON-Syntax
"relations": [ {"id":15, "type":"ordered_assembly", "order":1, "refs": [ {"id":8, "role":"assembly", "hint":"bearing"}, {"id":16, "role":"part", "hint":"bearing_row"} ] }, {"id":23, "type":"stage", "refs": [ {"id":3, "role":"stage", "hint":"cylindrical_stage"}, {"id":7, "role":"gear_1", "hint":"cylindrical_gear"}, {"id":9, "role":"gear_2", "hint":"cylindrical_gear"} ] }, ]
Relationstypen
Relationstyp | Komponenten / Rollen | ||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
assembly | Verbindet eine Hauptkomponente K1 mit einer Unterkomponente K2
Beispiel XML-Syntax <relation id="33" type="assembly"> <ref id="5" role="assembly" hint="shaft"/> <ref id="32" role="part" hint="external_load"/> </relation> | ||||||||||||
ordered_assembly | Verbindet eine Hauptkomponente K1 mit einer Unterkomponente K2 unter Eingabe der Reihenfolge der Unterkomponente. Die Angabe „order“ ist vom Typ Integer und gibt die Reihenfolge an. Die kleinste "order" ist immer =1 und wird in 1er-Schritten inkrementiert.
Beispiel XML-Syntax <relation id="15" type="ordered_assembly" order="1"> <ref id="8" role="assembly" hint="bearing"/> <ref id="16" role="part" hint="bearing_row"/> </relation> <relation id="16" type="ordered_assembly" order="2"> <ref id="8" role="assembly" hint="bearing"/> <ref id="17" role="part" hint="bearing_row"/> </relation> | ||||||||||||
stage | Verbindet eine Stufenkomponente S mit den zwei Zahnrädern R1, R2.
Beispiel XML-Syntax <relation id="23" type="stage"> <ref id="3" role="stage" hint="cylindrical_stage"/> <ref id="7" role="gear_1" hint="cylindrical_gear"/> <ref id="9" role="gear_2" hint="cylindrical_gear"/> </relation> | ||||||||||||
stage_gear_data | Diese Relation dient zur Abbildung der stufen-bezogenen Raddaten. Sie verbindet eine Stufenkomponente S mit einem Rad R und einer Stufenraddaten-Komponente „stage_gear_data“.
Beispiel XML-Syntax <relation id="23" type="stage_gear_data"> <ref id="3" role="stage" hint="cylindrical_stage"/> <ref id="7" role="gear" hint="cylindrical_gear"/> <ref id="9" role="stage_data" hint="stage_gear_data"/> </relation> | ||||||||||||
side | Verbindet z.B. ein Lager M mit zwei Komponenten: eine Komponente IP auf der Innenseite des Lagers, eine Komponente OP auf der Außenseite des Lagers.
Beispiel XML-Syntax <relation id="22" type="side"> <ref id="11" role="assembly" hint="concept_bearing"/> <ref id="17" role="inner_part" hint="shaft"/> <ref id="2" role="outer_part" hint="gear_casing"/> </relation> | ||||||||||||
flank | Wird verwendet, einem Zahnrad R eine linke (C1) und rechte (C2) Zahnflanke zuzuordnen. Die rechte (bzw. linke) Flanke ist diejenige Flanke, die man in Blickrichtung an einem nach oben gerichteten Zahn an dessen rechter (bzw. linker) Seite sieht. Die Blickrichtung ist für jeden Zahnradtyp gesondert zu spezifizieren.
Beispiel XML-Syntax <relation id="67" type="flank"> <ref id="8" role="gear" hint="bevel_gear"/> <ref id="13" role="left" hint="bevel_gear_flank"/> <ref id="14" role="right" hint="bevel_gear_flank"/> </relation> | ||||||||||||
reference | Wird verwendet, um Komponenten wie Werkstoffe oder Schmierstoffe einer Komponente zuzuordnen.
Beispiel XML-Syntax <relation id="40" type="reference"> <ref id="10" role="origin" hint="cylindrical_gear"/> <ref id="15" role="referenced" hint="material"/> </relation> | ||||||||||||
manufacturing_step | Wird verwendet, um einer Zahnradflanke F einen Bearbeitungsschritt mit dem Werkzeug T unter Berücksichtigung der Fertigungseinstellungen M zuzuordnen. Dabei gibt die „order" die Bearbeitungsreihenfolge an. Die Angabe „order“ ist vom Typ Integer. Die kleinste "order" ist immer =1 und wird in 1er-Schritten inkrementiert. Der Relations-Typ manufacturing_step wurde mit REXS 1.3 eingeführt. Er ersetzt die ordered_reference-Relation die bis REXS 1.2 ein Zahnrad und ein Werkzeug verband.
Beispiel XML-Syntax <relation id="41" type="manufacturing_step" order="1"> <ref id="10" role="workpiece" hint="cylindrical_gear_flank"/> <ref id="15" role="tool" hint="rack_shaped_tool"/> <ref id="16" role="manufacturing_settings" hint="cylindrical_gear_manufacturing_settings"/> </relation> | ||||||||||||
planet_shaft | Kennzeichnung der Planetenwelle C2 in einer Planetenstufe C1.
Beispiel XML-Syntax <relation id="42" type="planet_shaft"> <ref id="3" role="planetary_stage" hint="planetary_stage"/> <ref id="8" role="shaft" hint="shaft"/> </relation> | ||||||||||||
central_shaft | Kennzeichnung der Zentralwelle C2 in einer Planetenstufe C1.
Beispiel XML-Syntax <relation id="43" type="central_shaft"> <ref id="3" role="planetary_stage" hint="planetary_stage"/> <ref id="9" role="shaft" hint="shaft"/> </relation> | ||||||||||||
planet_carrier_shaft | Kennzeichnung der Stegwelle C2 in einer Planetenstufe C1.
Beispiel XML-Syntax <relation id="44" type="planet_carrier_shaft"> <ref id="3" role="planetary_stage" hint="planetary_stage"/> <ref id="10" role="shaft" hint="shaft"/> </relation> | ||||||||||||
planet_pin | Kennzeichnung des Bolzen C2 in einer Planetenstufe C1.
Beispiel XML-Syntax <relation id="45" type="planet_pin"> <ref id="3" role="planetary_stage" hint="planetary_stage"/> <ref id="11" role="shaft" hint="shaft"/> </relation> |
"load_spectrum" Objekt
Das Lastkollektiv wird durch ein Mastermodell (enthält die Daten und Relationen, die unverändert bleiben) und mehrere Submodelle (enthalten nur die variierten Daten) abgebildet.
Jeder Lastfall entspricht einem Submodell. Daher wird die Bezeichnung „load_case“ für ein Submodell gewählt.
Die Lastfälle eines Lastkollektivs werden in einem „load_spectrum“ zusammengefasst.
In einem load_case (Submodell) stehen nur die in dem Lastkollektiv variierten Daten. Es gilt:
Die entsprechenden Attribute werden, wie im Mastermodell, in Komponenten strukturiert.
Die Zuordnung zwischen einer Komponente im Mastermodell und einer Komponente im Submodell erfolgt über die (eindeutige) Komponenten-Id.
Alle Submodelle müssen die gleiche Menge von Attributen enthalten.
Attribute, die in den Submodellen angegeben werden, dürfen im Mastermodell nicht noch einmal belegt sein.
Das Mastermodell wird also erst durch die Zusammenführung mit einem Submodell zu einem vollständigen, berechenbaren Modell.
Über Lastkollektive akkumulierte Werte werden in einem separaten Submodell namens „accumulation“ des Lastkollektivs abgelegt.
Zunächst ist nur ein Lastkollektiv pro Modell zulässig.
Für Details zur Modellierungssystematik siehe auch Lastkollektive.
"load_spectrum" Objekt - XML-Syntax
Das "load_spectrum"-Tag ist ein optionaler Bestandteil des REXS-XML-Modells. Es besitzt eine (numerische) Kennung ("id") und umschließt ein oder mehrere "load_case"-Tags sowie das "accumulation"-Tag. Diese umschließen wiederum eine Liste von "component"-Tags.
Beispiel Lastkollektiv | XML-Syntax
<model> <relations> <components> <component id="1"> <component id="4"> <component id="6"> <!-- further components --> </components> <load_spectrum id="1"> <load_case id="1"> <load_case id="2"> <load_case id="3"> <component id="4"> <component id="6"> </load_case> <accumulation> <component id="4"> <component id="6"> </accumulation> </load_spectrum> </model>
"load_spectrum" Objekt - JSON-Syntax
Das "load_spectrum" Objekt enthält die Namen-Wert-Paare "id" (Id des Lastkollektivs), "accumulation" (Submodell für akkumulierte Werte des Kollektivs), sowie das "load_cases" Array. Das "accumulation" Objekt enthält ein "components" Array. Das "load_cases" Array enthält eine Liste von JSON Objekten die jeweils eine "id" sowie ein "components" Array beinhalten.
Beispiel Lastkollektiv | JSON-Syntax
"load_spectrum": { "id": 1, "load_cases": [ { "id": 1, "components": [ { "id": 1, "attributes": [...]}, { ... }, ... ] }, { "id": 2, "components": [ { "id": 2, "attributes": [...]}, { ... }, ... ] }, ... ] "accumulation": { "components": [ { "id": 2, "attributes": [...]}, { ... }, ... ] } }
Beispiel Modell - XML-Syntax
Beispiel Modell | XML-Syntax
<?xml version="1.0" encoding="UTF-8" standalone="no"?> <model applicationId="FVA Workbench" applicationVersion="7.0" date="2021-11-23T13:52:44+01:00" version="1.4"> <relations> <relation id="45" type="assembly"> <ref hint="shaft" id="42" role="assembly"/> <ref hint="shaft_section" id="78" role="part"/> </relation> <relation id="53" type="side"> <ref hint="shaft" id="6" role="inner_part"/> <ref hint="shaft" id="42" role="outer_part"/> <ref hint="rolling_bearing_with_detailed_geometry" id="86" role="assembly"/> </relation> ... </relations> <components> <component id="44" name="Cylindrical gear [44]" type="cylindrical_gear"> <attribute id="example_string" unit="none">30203-A</attribute> <attribute id="example_floating_point_unit" unit="mum">20.0</attribute> <attribute id="example_floating_point_without_unit" unit="none">0.3</attribute> <attribute id="example_integer" unit="none">3</attribute> <attribute id="example_enum" unit="none">method_b</attribute> <attribute id="example_boolean" unit="none">false</attribute> <attribute id="example_floating_point_array" unit="mm"> <array><c>155.0</c><c>0.0</c><c>-190.0</c></array> </attribute> <attribute id="example_floating_point_matrix" unit="mm"> <matrix> <r><c>1.0</c><c>0.0</c><c>0.0</c></r> <r><c>0.0</c><c>1.0</c><c>0.0</c></r> <r><c>0.0</c><c>0.0</c><c>1.0</c></r> </matrix> </attribute> <attribute id="example_floating_point_array_coded" unit="mm"> <array code="float64">62wRNhgQS0AAAAAAAAAAANgPsyG1MXDA</array> </attribute> <attribute id="example_array_of_arrays" unit="none"> <array_of_arrays> <array><c>108</c><c>2</c><c>1</c><c>107</c></array> <array><c>109</c><c>3</c><c>2</c><c>108</c></array> <array><c>8</c><c>114</c><c>115</c></array> </array_of_arrays> </attribute> </component> <component id="45" name="Cylindrical gear [45]" type="cylindrical_gear"> ... </component> </components> <load_spectrum id="1"> <load_case id="1"> <load_case id="2"> <load_case id="3"> <component id="4"> <attribute id="example" unit="mm">20.0</attribute> ... </component> </load_case> <accumulation> <component id="4">...</component> </accumulation> </load_spectrum> </model>
Beispiel Modell - JSON-Syntax
Beispiel Modell | JSON-Syntax
{ "model": { "applicationId": "Bearinx", "applicationVersion": "12.0.8823", "date": "2021-07-01T12:18:38+01:00", "version": "1.3", "relations": [ { "id": 48, "type": "assembly", "refs": [ {"hint": "gear_unit","id": 1,"role": "assembly"}, {"hint": "gear_casing","id": 2,"role": "part"} ] }, { "id": 49, "type": "side", "refs": [ {"hint": "concept_bearing","id": 40,"role": "assembly"}, {"hint": "shaft","id": 13,"role": "inner_part"}, {"hint": "gear_casing","id": 2,"role": "outer_part"} ] } ... ] "components": [ { "id": 1, "name": "Transmission unit", "type": "gear_unit", "attributes": [ {"id": "example_string", "string": "30203-A"}, {"id": "example_floating_point_unit", "unit": "mm", "floating_point": 2.0}, {"id": "example_floating_point_without_unit", "unit": "none", "floating_point": 0.1}, {"id": "example_integer", "integer": 3}, {"id": "example_boolean", "boolean": false}, {"id": "example_enum", "enum": "both_directions" }, {"id": "example_floating_point_array", "unit": "mm","floating_point_array": [1.0,0.0,0.0]}, {"id": "example_floating_point_matrix", "unit": "mm", "floating_point_matrix": [[1.0,0.0,0.0], [0.0,1.0,0.0], [0.0,0.0,1.0]] }, {"id": "example_array_coded", "unit": "mm", "floating_point_array_coded": {"code": "float64", "value": "62wRNhgQS0AAAAAAAAAAANgPsyG1MXDA"}}, {"id": "example_array_of_arrays", "array_of_integer_arrays": [[108,2,1,107,7],[0,1,0],[0,7,0,1]]}, ] } { "id": 2, "name": "Input shaft", "type": "shaft", "attributes": [ ... ] } ... ] "load_spectrum": { "id": 1, "load_cases": [ { "id": 2, "components": [ { "id": 2, "attributes": [ ... ] }, { ... }, ... ] }, { ... } ] "accumulation": { "components": [ { "id": 2, "attributes": [ ... ] }, { ... }, ... ] } } } }