Skip to content
Snippets Groups Projects
Commit 0c1c9596 authored by Meck, Tobias's avatar Meck, Tobias :speech_balloon:
Browse files

Update notebooks and calculation_rules 

Small changes (spelling, layout etc.)
parent 2629e2f7
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
ausarbeitung.ipynb
+ 53
− 46
View file @ 0c1c9596
%% Cell type:markdown id:c9328cd1 tags:
# FAIRe Qualitäts-KPIs
Name:
Autor:
Datum:
%% Cell type:markdown id:1c5d41dc tags:
## Forschungsfrage
Formulieren Sie eine oder mehrere Forschungsfrage zu der Lerneinheit:
Formulieren Sie eine oder mehrere Forschungsfragen zu der Lerneinheit:
%% Cell type:markdown id:14e306b5 tags:
%% Cell type:markdown id:de070039 tags:
## Erstes Fahrzeug
%% Cell type:markdown id:531d890a tags:
### Hypothese
Formulieren Sie eine Hypothese zu diesem ersten Versuch:
### Versuchsziel
Formulieren Sie ein Versuchsziel für diesen ersten Versuch:
%% Cell type:markdown id:30ddd8dc tags:
%% Cell type:markdown id:50dd9ff3 tags:
### Versuchsaufbau
Bauen Sie ein erstes Fahrzeug aus den gegebenen LEGO-Teilen in der CAD-Software LeoCAD auf.
Hierbei gelten die folgenden Rahmenbedingungen:
- Das Fahrzeug muss aus Baugruppen, Bauteilen und Komponenten bestehen.
- Es muss mindestens vier Räder besitzen
- Es muss sich durch den elektrischen Antrieb fortbewegen können.
- Die Verwendung eines Getriebes zwischen Motor und Antriebsachse(n) ist verpflichtend.
- Die Farbe von mindestens einem Teil soll sich von der in LeoCAD hinterlegten Standardfarbe unterscheiden.
- Es sind nur die gegebenen LEGO-Teile zu verwenden.
- Es sind nur die LEGO-Teile zu verwenden, welche sich in den JSON-Dateien bzw. in
der zur Verfügung gestellten Teilebibliothek befinden.
%% Cell type:markdown id:0ebba2d8 tags:
Fügen Sie eine Abbildung des fertigen Autos in LeoCAD hinzu (*Hinweise: Ein Bild lässt sich mit \!\[Bildbeschreibung](Pfad_zum_Bild) hinzufügen. Achten Sie darauf, das Bild später auch in Git hinzuzufügen*):
Fügen Sie eine Abbildung des fertigen Autos in LeoCAD hinzu (*Hinweise: Ein Bild lässt sich mit \!\[Bildbeschreibung](/Pfad/zum/Bild) hinzufügen. Achten Sie darauf, das Bild später auch in Git hinzuzufügen*):
%% Cell type:markdown id:935c200c tags:
%% Cell type:markdown id:05a8eb21 tags:
Beschreiben Sie kurz und präzise Ihr Fahrzeug:
%% Cell type:markdown id:df7f1d01 tags:
%% Cell type:markdown id:e622f83b tags:
Bauen Sie das Fahrzeug nun in unserem Software-Framework zusammen. Insanziieren Sie die LEGO-Teile und lesen Sie dabei auch die Eigenschaften ein. Ergänzen Sie zusätzliche Eigenschaften, wie z.B. die Farbe. Referenzieren Sie die Teile aufeinander und erstellen Sie auf diese Weise sinnvolle Bauteile, Baugruppen und das
Bauen Sie das Fahrzeug nun in unserem Software-Framework zusammen. Instanziieren Sie die LEGO-Teile und lesen Sie dabei auch die Eigenschaften ein. Ergänzen Sie zusätzliche Eigenschaften, wie z.B. die Farbe. Referenzieren Sie die Teile aufeinander und erstellen Sie auf diese Weise sinnvolle Bauteile, Baugruppen und das
Gesamtsystem. Nutzen Sie die hierfür bereitgestellten Klassendefinitionen und Methoden. Achten Sie auf eine gute Code-Dokumentation. Sie können sich für die Bearbeitung an den zur Verfügung gestellten Code-Zellen orientieren, können hiervon jedoch auch abweichen.
*Hinweise: Achten Sie auf die Unterschiede zum Minimalbeispiel. Eine direkte Kopie ist nicht möglich. Achten Sie außerdem darauf, ein Teil (eindeutig identifiziert durch seine UUID) nicht an mehreren Stellen zu verbauen*
%% Cell type:code id:690da270 tags:
``` python
import json
import pprint
from functions import calculation_rules
from functions.classes import *
```
%% Cell type:code id:ccaf3043 tags:
``` python
# initialize componentens
# initialize components
```
%% Cell type:code id:36f981df tags:
``` python
# set properties
```
%% Cell type:code id:da2d141c tags:
``` python
# aggregate components
```
%% Cell type:markdown id:c1fef7f0 tags:
### Analyse
Bestimmen Sie die Qualität Ihres Fahrzeugs mittels KPIs.
Die Qualität des Fahrzeugs ist mit mindestens einem KPI je Qualitätsdimension (Aufwand, Verfügbarkeit, Akzeptanz) zu bestimmen. Enwickeln Sie zunächst sinnvolle KPIs, welche mit den gegebenen Daten umsetzbar sind. Halten Sie die Berechnungsvorschriften im Jupyter Notebook fest. Implementieren Sie deren Berechnung für das Gesamtsystem "Fahrzeug" mittels einzelner Funktionen im Skript `calculation_rules`. Sie können zusätzlich Ihre Methoden auch auf die niedrigeren Aggregationsebenen anwenden.
%% Cell type:markdown id:d5f02096 tags:
Beschreiben Sie den jeweiligen KPI und geben Sie seine Berechnungsvorschrift an:
%% Cell type:markdown id:a793bce8 tags:
$$
a = \frac{b}{c} + d
$$
%% Cell type:markdown id:9a21b4ac tags:
%% Cell type:markdown id:e300a005 tags:
%% Cell type:markdown id:2aad773a tags:
Halten Sie die berechneten Werte für die KPIs im Notebook
fest:
%% Cell type:code id:59eabafc tags:
``` python
# calculate the KPIs for your car
```
%% Cell type:code id:c774b381 tags:
``` python
# print your KPIs
```
%% Cell type:markdown id:b89e8fb9 tags:
Exportieren Sie schließlich ihr entworfenes Fahrzeug inklusive der entwickelten KPI:
Exportieren Sie schließlich Ihr entworfenes Fahrzeug inklusive der entwickelten KPIs:
%% Cell type:code id:d518275f tags:
``` python
# export car and its properties
```
%% Cell type:markdown id:89c75440 tags:
## Zweites Fahrzeug
%% Cell type:markdown id:f8a2e1b0 tags:
### Hypothese
### Versuchsziel
%% Cell type:markdown id:80407e7f tags:
Setzen Sie sich ein Ziel, welche Qualitätsdimensionen in einem zweiten Fahrzeug verbessert werden sollen und bauen
Sie darauf aufbauend ein zweites Fahrzeug aus den gegebenen LEGO-Teilen auf.
Die Anforderungen an das Fahrzeug sind identisch zum ersten. Wählen Sie die Einzelteile und deren Zusammenspiel entsprechend Ihrer Zielstellung aus.
%% Cell type:markdown id:f4c620ee tags:
Formulieren Sie eine Hypothese zu diesem Versuch:
Formulieren Sie ein Versuchsziel für diesen Versuch. Beschreiben Sie unter anderem, welche Verbesserung Sie vornehmen möchten:
%% Cell type:markdown id:e3dc7e29 tags:
%% Cell type:markdown id:3cef0828 tags:
Beschreiben Sie, welche Verbesserung Sie vornehmen:
%% Cell type:markdown id:00c9d739 tags:
%% Cell type:markdown id:73c454f2 tags:
### Versuchsaufbau
%% Cell type:markdown id:2b381a60 tags:
Fügen Sie eine Abbildung des fertigen Autos in LeoCAD hinzu:
%% Cell type:markdown id:2b6e7f12 tags:
%% Cell type:markdown id:23c19009 tags:
Beschreiben Sie kurz und präzise den Aufbau des zweiten Fahrzeugs:
%% Cell type:markdown id:a08bf9cf tags:
%% Cell type:markdown id:14011b6f tags:
Erstellen Sie das Fahrzeug in unserem Softwareframework:
%% Cell type:code id:c35de753 tags:
``` python
# initialize componentens
# initialize components
```
%% Cell type:code id:0b7336fb tags:
``` python
# set properties
```
%% Cell type:code id:fb445ea0 tags:
``` python
# aggregate components
```
%% Cell type:markdown id:89e54480 tags:
### Analyse
Bestimmen Sie die KPIs des zweiten Fahrzeuges
Bestimmen Sie die KPIs des zweiten Fahrzeugs
%% Cell type:code id:762a1e93 tags:
``` python
# calculate the KPIs for your car
```
%% Cell type:code id:1ed67328 tags:
``` python
# print your KPIs
```
%% Cell type:markdown id:0f11b370 tags:
Exportieren Sie ihr Fahrzeug inklusive der KPIs:
Exportieren Sie Ihr Fahrzeug inklusive der KPIs:
%% Cell type:code id:05d9d6f7 tags:
``` python
# export car and its properties
```
%% Cell type:markdown id:e413cd84 tags:
## Bewertung
## Diskussion
### Ergebnisse
Stellen Sie die entwickelten KPIs beider Fahrzeuge gegenüber und wählen Sie hierfür unter anderem eine geeignete
grafische Darstellung. Stellen Sie dabei insbesondere sicher, dass die Datengrundlage ersichtlich ist. Halten Sie
auch die Plotbefehle im Notebook fest:
%% Cell type:code id:b0f93e22 tags:
``` python
# plot the data, save diagramm as svg-file
```
%% Cell type:markdown id:6044de27 tags:
Interpretieren Sie ihre Ergebnisse. Vergleichen Sie die KPIs ihrer Autos. Konnten Sie ihre gewünschte Verbesserung erzielen? Welche Schlüsse ziehen Sie aus den Ergebnissen für die Qualität der beiden
Interpretieren Sie Ihre Ergebnisse. Vergleichen Sie die KPIs Ihrer Autos. Konnten Sie Ihre gewünschte Verbesserung erzielen? Welche Schlüsse ziehen Sie aus den Ergebnissen für die Qualität der beiden
Fahrzeuge?
%% Cell type:markdown id:0ca884b1 tags:
%% Cell type:markdown id:4f117169 tags:
Diskutieren Sie, inwieweit Ihre entickelten KPIs die im Skript erläuterten FAIR-Prinzipien erfüllen:
Diskutieren Sie, inwieweit Ihre entwickelten KPIs die im Skript erläuterten FAIR-Prinzipien erfüllen:
%% Cell type:markdown id:f8ed82d2 tags:
%% Cell type:markdown id:bfed164a tags:
## Fazit
%% Cell type:markdown id:5d440f87 tags:
Ziehen Sie ein persönliches Fazit. Was haben Sie Neues gelernt?
%% Cell type:markdown id:b4151784 tags:
......
functions/calculation_rules.py
+ 13
− 20
View file @ 0c1c9596
......@@ -2,42 +2,35 @@
File consists of several functions for the calculation rules of FAIR Quality KPIs
"""
from functions.classes import *
def test_function():
"""Test function to check module functionality"""
print("You called the test function.")
def kpi_sum(*args):
def kpi_mass(system: LegoAssembly)->float:
"""
Calculates the sum of one or more integers or lists.
Calculates the total mass of the system
Args:
*args: One or more integers or lists.
system (LegoAssembly): LegoAssembly object that represents the system
Returns:
total (int): The sum of all given integers and/or the sum
of all items in all given lists.
total_mass (float): Sum of masses of all components in the system in g
Raises:
TypeError: If an argument with unsupported type is passed
(i.e. anything other than int or list).
(i.e. anything other than LegoAssembly).
"""
total = 0
for arg in args:
if isinstance(arg, int): # Check if argument is an integer
total += arg
elif isinstance(arg, list): # Check if argument is a list
total += sum(arg)
else:
raise TypeError(
f"Unsupported type {type(arg)} passed to kpi_sum()")
return total
# if arguments are handed over not as a list: sum(list(args))
if not isinstance(system, LegoAssembly):
raise TypeError(f"Unsupported type {type(system)} passed to kpi_mass()")
total_mass = 0
for c in system.get_component_list(-1):
total_mass += c.properties["mass [g]"]
return total_mass # alternative: sum(c.properties["mass [g]"] for c in system.get_component_list(-1))
# Add new functions for calculating some real complicated metrics
# Add new functions for calculating metrics
if __name__ == "__main__":
......
minimalbeispiel.ipynb
+ 148
− 39
View file @ 0c1c9596
%% Cell type:markdown id:c9328cd1 tags:
# FAIRe Qualitäts-KPI
# FAIRe Qualitäts-KPIs
%% Cell type:markdown id:2ee8746d tags:
## Einführung
FAIR Quality KPIs schaffen eine transparente und nachvollziehbare Entscheidungsgrundlage. In dieser Lerneinheit sollen sie die Methodik erlernen, indem sie LEGO Autos zusammenbauen, deren Quality KPIs bestimmen und miteinander vergleichen.
FAIRe Qualitäts-KPIs schaffen eine transparente und nachvollziehbare Entscheidungsgrundlage. In dieser Lerneinheit sollen sie die Methodik erlernen, indem sie LEGO-Autos zusammenbauen, deren Quality KPIs bestimmen und miteinander vergleichen.
### Werkzeug für den Zusammenbau
Der Zusammenbau der Autos erfolgt virtuell. Als Werkzeug steht Ihnen das Modul `classes` zur Verfügung. In diesem sind unterschiedliche Klassen und Methoden implementiert (Objektorientierung). Sie erzeugen jeweils Objekte der Klassen. Ein Objekt ist dabei die virtuelle Abbildung eines realen Bauteiles. Die Eigenschaften des Bauteiles werden über die Eigenschaften des Objektes abgebildet.
### Berechnung der Quality KPIs
KPIs (Key Performance Indikatoren) sind Kenngrößen des Systems. Sie werden über Berechnungsvorschriften bestimmt. Diese Berechnungsvorschriften sind von Ihnen als python-Funktionen im Modul `calculation_rules` zu implementieren.
### Datenblätter
Für den Zusammenbau stehen Ihnen verschiedene Bauteile in unterschiedlichen Ausführungen zur Verfügung. Sie nutzen die Datenblätter, die als `json-Dateien` zur Verfügung gestellt werden, um Ihre Autos zusammenzubauen.
%% Cell type:markdown id:1c702114 tags:
## Eigene Module und Minimalbeispiel
Für die Ausarbeitung nutzen wir zwei eigene Module (Python-Dateien), die im Ordner `functions` gespeichert sind.
Das Modul `calculation_rules` erweitern Sie während der Ausarbeitung. Um die Änderungen zu nutzen, müssen Sie das Notebook neu starten.
Im Modul `classes` befinden sich die komplette Klassen und Funktionen zur Verwendung.
Mit einem Minimalbeispiel wird Ihnen gezeigt, wie sie die Module nutzen.
%% Cell type:markdown id:670118b3 tags:
#### Versuchsaufbau:
Die folgende Abbildung zeugt den Versuchsaufbau für das Tretrollerbeispiel in LeoCAD. Die transparenten Bauteile Sind dabei nicht Teil des hier erläuterten Zusammenbaus, können aber mit dem zur Verfügung gestellten Baukasten ergänzt werden:
Die folgende Abbildung zeigt den Versuchsaufbau des Minimalbeispiels in LeoCAD. Die transparenten Bauteile sind dabei nicht Teil des hier erläuterten Zusammenbaus, können aber mit dem zur Verfügung gestellten Baukasten ergänzt werden:
%% Cell type:markdown id:2f969ed9 tags:
![Tretroller in LeoCAD](figures/leocad_screenshot_cut.png)
%% Cell type:markdown id:6d3310be tags:
### Modul classes
Enthält `LegoComponent, LegoAssembly, AggregationLayer, KPIEncoder` und die Funktion `print_assembly_tree`.
`LegoComponent` bildet einzelne Komponenten ab, während `LegoAssembly` zusammengesetzte Aggregationsebenen abdeckt, also Bauteil, Baugruppe und System. Zur Unterscheidung dient die Klasse Aggregationlayer, diese ist für `LegoComponent` immer `Component` (Komponente), muss für `LegoAssembly` entsprechend auf `SYSTEM`(System) , `ASSEMBLY`(Baugruppe) oder `SUBASSEMBLY`(Bauteil) gesetzt werden.
`LegoComponent` bildet einzelne Komponenten ab, während `LegoAssembly` zusammengesetzte Aggregationsebenen abdeckt, also Bauteil, Baugruppe und System. Zur Unterscheidung dient die Klasse `AggregationLayer`, diese ist für `LegoComponent` immer `Component` (Komponente), muss für `LegoAssembly` entsprechend auf `SYSTEM` (System) , `ASSEMBLY` (Baugruppe) oder `SUBASSEMBLY` (Bauteil) gesetzt werden.
Wir bauen aus Achse, Rahmen und Reifen einen Tretroller zusammen.
%% Cell type:code id:b2778dee tags:
``` python
# import modules
import json
import pprint
from functions import calculation_rules
# Importing all modules one by one to provide an overview
# The next commented line would provide the same result in one line
# from functions.classes import *
from functions.classes import LegoComponent
from functions.classes import LegoAssembly
from functions.classes import AggregationLayer
from functions.classes import KPIEncoder
from functions.classes import print_assembly_tree
# When you are writing code yourself later, you might want to copy
# these imports to avoid rerunning the full notebook after restart
```
%% Cell type:code id:0b1f9aff tags:
``` python
# Create the wheels and axles as single components first
# Look up the specific item you want from the provided json files,
# we can load the full file into a dict
with open("datasheets/axles.json") as json_file:
axles = json.load(json_file)
# Pick a specific axle via its 'item number'
print(axles["32073"])
# Create the component with the dict:
front_axle = LegoComponent("front axle", axles["32073"])
# Both label and the data dict are optional parameters.
# You can view, add or edit the properties just any dict:
# You can view, add or edit properties:
print(front_axle.properties["label"])
front_axle.properties["color"] = "grey"
# Create the second axle
back_axle = LegoComponent()
back_axle.properties["label"] = "back axle"
back_axle.properties.update(axles["32073"])
# Do not use = here, otherwise you'd overwrite existing properties.
# Instead use update to have all entries added to properties
back_axle.properties["color"] = "grey"
# Viewing dicts in one line is not easy to read,
# a better output comes with pretty print (pprint):
pprint.pprint(back_axle.properties)
```
%% Output
{'item number': 32073, 'item description': 'Axle 5 studs', 'category': 'axle', 'price [Euro]': 0.001, 'mass [g]': 0.66, 'delivery time [days]': 3, 'data source': 'https://www.bricklink.com/v2/catalog/catalogitem.page?P=32073#T=S&O={%22iconly%22:0}', 'dimension [studs]': 5}
front axle
{'category': 'axle',
'color': 'grey',
'data source': 'https://www.bricklink.com/v2/catalog/catalogitem.page?P=32073#T=S&O={%22iconly%22:0}',
'delivery time [days]': 3,
'dimension [studs]': 5,
'item description': 'Axle 5 studs',
'item number': 32073,
'label': 'back axle',
'mass [g]': 0.66,
'price [Euro]': 0.001}
%% Cell type:code id:b4a8e8c8 tags:
``` python
# Now wheels
with open("datasheets/wheels.json") as json_file:
wheels = json.load(json_file)
# Adding the color here already as dict, and the surface as key-value argument.
# Multiple of both parameters are supported, but only in this order.
# front_wheel = LegoComponent(
# 'front wheel', wheels['2903c02'], {'color':'yellow'},winter='true')
front_wheel = LegoComponent(
"front wheel", wheels["2903c02"], surface="rough", paint="glossy"
)
pprint.pprint(front_wheel.properties)
# We included a clone function to both Lego classes, so you can easily
# create duplicate objects. Passing the new label is optional
back_wheel = front_wheel.clone("back wheel")
```
%% Output
{'category': 'wheel',
'data source': 'https://www.bricklink.com/v2/catalog/catalogitem.page?P=2903c02#T=C',
'delivery time [days]': 5,
'diameter [mm]': 81.6,
'item description': 'wheel 81,6',
'item number': '2903c02',
'label': 'front wheel',
'mass [g]': 30.0,
'paint': 'glossy',
'price [Euro]': 1.31,
'related items': 2902,
'surface': 'rough'}
%% Cell type:code id:25bd06c5 tags:
``` python
# Create subassemblies and add the wheels and axles
# The AggregationLayer must be used, passing the label
# or additional properties is optional
front_wheel_assembly = LegoAssembly(
AggregationLayer.SUBASSEMBLY,
"front wheel assembly",
assembly_method="stick together like lego blocks",
)
# Add LegoComponents to the LegoAssembly, single or as list
front_wheel_assembly.add([front_wheel, front_axle])
# You can access the components of an assembly like this:
print(front_wheel_assembly.components[1].properties["label"])
# Assemblies can be cloned as well (including their children),
# but don't forget to adjust labels or you might be stuck with
# a 'front wheel' in your 'back wheel assembly'
# Stick together back wheel parts
back_wheel_assembly = LegoAssembly(
AggregationLayer.SUBASSEMBLY, "back wheel assembly"
)
back_wheel_assembly.add([back_wheel, back_axle])
```
%% Output
front axle
%% Cell type:code id:2b6648e1 tags:
``` python
# Create frame component and assemble the system
with open("datasheets/frame.json") as json_file:
frame = json.load(json_file)
scooter_frame = LegoComponent("scooter frame", frame["3703"], {"color": "red"})
# The scooter is our system level assembly, you can choose the AggregationLayer
# But the hiercarchy (SYSTEM > ASSEMBLY > SUBASSEMBLY) must be in order.
# Components can be added to all LegoAssembly objects
scooter = LegoAssembly(
AggregationLayer.SYSTEM,
"scooter",
manufacturer="FST",
comment="Faster! Harder! Scooter!",
)
# add frame and subassemblies
scooter.add([scooter_frame, front_wheel_assembly, back_wheel_assembly])
```
%% Cell type:code id:71324895 tags:
``` python
# Look at the assembly
# We can get all LegoComponents from this assembly.
# Without parameter 'max_depth' only direct children will be listed.
scooter.get_component_list(5)
# If parameter 'max_depth' is set to 0, only direct children will be listed:
print(scooter.get_component_list(max_depth=0))
# If it is set to -1 (default), all LegoComponents are listed:
print(scooter.get_component_list())
```
%% Output
[LegoComponent scooter frame [a90b291e-696c-41c7-b9b8-43d34724b460]]
[LegoComponent scooter frame [a90b291e-696c-41c7-b9b8-43d34724b460], LegoComponent front wheel [b03ce5b5-9c6c-4315-a67b-902c729c3d7b], LegoComponent front axle [64771daf-733a-4a2a-8520-9fa94259e50e], LegoComponent back wheel [8fcb7db9-6fec-4e70-b274-0c4fe403550b], LegoComponent back axle [2ce57b96-64b8-48b1-aac8-b0731adaa93b]]
%% Cell type:markdown id:001f1c77 tags:
### Modul calculation_rules
Um für unser System "Tretroller" ein KPI für das Gesamtgewicht zu erzeugen, wurde in `functions.calculation_rules` die Funktion `kpi_sum` definiert. Zusammen mit den Hilfsfunktionen der Klasse können wir nun das KPI Gewicht für das System hinzufügen. Die Massen der einzelnen Komponenten sind in den Datenblättern unter `mass [g]` enthalten.
Um für unser System "Tretroller" einen KPI zu erzeugen, wird die Masse des Systems betrachtet. Die Masse der einzelnen Komponenten ist in den Datenblättern unter `mass [g]` enthalten.
%% Cell type:code id:7b60d0fb tags:
``` python
# test the import
calculation_rules.test_function()
```
%% Output
You called the test function.
%% Cell type:code id:fe4edad6 tags:
``` python
# Add mass to assemblies
total_mass = calculation_rules.kpi_mass(scooter)
# List all components' mass
combined_weight = 0
for c in scooter.get_component_list(-1):
combined_weight += c.properties["mass [g]"]
print("Gesamtgewicht: ", combined_weight, "g")
print("Gesamtmasse: ", total_mass, "g")
# Add KPI to system
scooter.properties["mass [g]"] = combined_weight
scooter.properties["mass [g]"] = total_mass
# We can also add the mass to the subassemblies.
# children() returns a dict with a list of added
# components and assemblies.
for a in scooter.children()["assemblies"]:
a_mass = 0
for c in a.get_component_list(-1):
a_mass += c.properties["mass [g]"]
a.properties["mass [g]"] = a_mass
```
%% Output
Gesamtmasse: 67.19 g
%% Cell type:code id:c26b36c8 tags:
``` python
scooter.get_component_list(-1)
```
%% Output
[LegoComponent scooter frame [a90b291e-696c-41c7-b9b8-43d34724b460],
LegoComponent front wheel [b03ce5b5-9c6c-4315-a67b-902c729c3d7b],
LegoComponent front axle [64771daf-733a-4a2a-8520-9fa94259e50e],
LegoComponent back wheel [8fcb7db9-6fec-4e70-b274-0c4fe403550b],
LegoComponent back axle [2ce57b96-64b8-48b1-aac8-b0731adaa93b]]
%% Cell type:code id:4d56419f tags:
``` python
# Look at the full assembly with KPI
# Print the full assembly with all levels
print_assembly_tree(scooter)
```
%% Output
LegoAssembly scooter [86fdda66-adb2-48c0-b6f8-f6c59d488662]
├── LegoAssembly front wheel assembly [e02a87d2-cb0b-4695-b237-9ca17f9611da]
│ ├── LegoComponent front wheel [b03ce5b5-9c6c-4315-a67b-902c729c3d7b]
│ └── LegoComponent front axle [64771daf-733a-4a2a-8520-9fa94259e50e]
├── LegoAssembly back wheel assembly [db5db4c5-36c3-4b90-88eb-299c46a30049]
│ ├── LegoComponent back wheel [8fcb7db9-6fec-4e70-b274-0c4fe403550b]
│ └── LegoComponent back axle [2ce57b96-64b8-48b1-aac8-b0731adaa93b]
└── LegoComponent scooter frame [a90b291e-696c-41c7-b9b8-43d34724b460]
%% Cell type:code id:b31416d3 tags:
``` python
# Dump to json file with to_dict() and KPIEncoder
with open("scooter.json", "w") as fp:
json.dump(scooter.to_dict(), fp, cls=KPIEncoder)
json.dump(scooter.to_dict(), fp, cls=KPIEncoder, indent=4)
# full view is too big for Juypter (try it)
# pprint.pprint(scooter.to_dict())
```
%% Cell type:markdown id:53793ae8 tags:
In dieser exportierten json-Datei ('scooter.json') sind die Werte maschinen- und menschenlesbar hinterlegt.
Zusammen mit der Berechnungsvorschrift in `calculation_rules` ist auch die Entstehung des KPI nachvollziehbar und wiederverwendbar dokumentiert und damit 'FAIR'.
%% Cell type:markdown id:92c77051 tags:
#### Zusätzliche Details
%% Cell type:code id:b91fed73 tags:
``` python
# Each child knows its parent
first_child = scooter.children()["assemblies"][0]
print("Child:", first_child)
print("Parent:", first_child.parent)
# Also we can access the "top" parent
latest_child = first_child.children()["components"][0]
print("Top parent: ", latest_child.get_root_assembly())
# Each part created has a unique identifier (the long number in [])
# Don't try add the identical part again.
# Don't try to add the identical part again.
```
%% Output
Child: LegoAssembly front wheel assembly [e02a87d2-cb0b-4695-b237-9ca17f9611da]
Parent: LegoAssembly scooter [86fdda66-adb2-48c0-b6f8-f6c59d488662]
Top parent: LegoAssembly scooter [86fdda66-adb2-48c0-b6f8-f6c59d488662]
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment