LeoCAD/Scooter.ldr

+0 
+0 Name: New Model.ldr
+0 Author: 
+1 71 180 -48 0 1 0 0 0 1 0 0 0 1 56904.dat
+1 0 180 -48 0 1 0 0 0 1 0 0 0 1 30699.dat
+1 4 260 -57.8657 -50 1 0 0 0 1 0 0 0 1 2730.dat
+1 71 180 -48 -30 0 0 1 0 1 0 -1 0 0 32073.dat
+1 47 180 -48 -30 1 0 0 0 1 0 0 0 1 3713.dat
+1 47 180 -48 -70 1 0 0 0 1 0 0 0 1 3713.dat
+1 71 340 -48 0 1 0 0 0 1 0 0 0 1 56904.dat
+1 0 340 -48 0 1 0 0 0 1 0 0 0 1 30699.dat
+1 71 340 -48 -30 0 0 1 0 1 0 -1 0 0 32073.dat
+1 47 340 -48 -30 1 0 0 0 1 0 0 0 1 3713.dat
+1 47 340 -48 -70 1 0 0 0 1 0 0 0 1 3713.dat
+1 47 220 -128 -70 1 0 0 0 0 1 0 -1 0 40490.dat
+1 47 220 -208 -70 0 0 1 0 1 0 -1 0 0 32073.dat
+1 47 220 -208 -25 -1 0 0 0 1 0 0 0 -1 32123.dat
+1 47 220 -208 -35 -1 0 0 0 1 0 0 0 -1 32123.dat
+1 47 220 -208 -45 -1 0 0 0 1 0 0 0 -1 32123.dat
+1 47 220 -208 -55 -1 0 0 0 1 0 0 0 -1 32123.dat
+1 47 220 -208 -85 -1 0 0 0 1 0 0 0 -1 32123.dat
+1 47 220 -208 -95 -1 0 0 0 1 0 0 0 -1 32123.dat
+1 47 220 -208 -105 -1 0 0 0 1 0 0 0 -1 32123.dat
+1 47 220 -208 -115 -1 0 0 0 1 0 0 0 -1 32123.dat
+1 47 220 -48 -60 0 0 1 0 -1 0 1 0 0 3673.dat

datasheets/frame.json

@@ -131,8 +131,8 @@
         "data source":"https://www.bricklink.com/v2/catalog/catalogitem.page?P=40490",
         "dimension [studs]":"1 x 9"
     },
-    "32525":{
-        "item number":32525,
+    "64290":{
+        "item number":64290,
         "item description":"Technic, Liftarm Thick 1 x 11",
         "category":"frame",
         "price [Euro]":0.02,
@@ -208,6 +208,17 @@
         "data source":"https://www.bricklink.com/v2/catalog/catalogitem.page?P=6536",
         "dimension [studs]":"1x 2 x 1"
     },
+    "14720":{
+        "item number":14720,
+        "item description":"Technic, Liftarm, Modified H-Shape Thick 3 x 5 Perpendicular",
+        "category":"frame",
+        "price [Euro]":0.08,
+        "mass [g]":2.29,
+        "environmental impact [kg CO2e /kg]":11.93,
+        "delivery time [days]":3,
+        "data source":"https://www.bricklink.com/v2/catalog/catalogitem.page?P=14720",
+        "dimension [studs]":"3 x 5 x 1"
+    },
     "48989":{
         "item number":48989,
         "item description":"Technic, Pin Connector Perpendicular 3L with 4 Pins",

functions/classes.py

@@ -57,7 +57,7 @@ class LegoComponent:
                 to None.
             datasheet (dict[str, Any], optional): Metadata describing the component,
                 read from datasheet. Defaults to None.
-            more_properties  tuple of dict, dict
+            more_properties (dict[str, Any])
                 Additional dictionaries representing custom properties.
             kwargs
                 Arbitrary keyword arguments representing custom properties.

minimalbeispiel.ipynb

 %% Cell type:markdown id:c9328cd1 tags:
 
 # FAIRe Qualitäts-KPIs
 
 %% Cell type:markdown id:2ee8746d tags:
 
 ## Einführung
 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 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)
+![Minimalbeispiel aus 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.
 
 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 properties:
 print(front_axle.properties["label"])
-front_axle.properties["color"] = "grey"
+front_axle.properties["color"] = "light bluish 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"
+back_axle.properties["color"] = "light bluish 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}
+    {'item number': 32073, 'item description': 'Axle 5 studs', 'category': 'axle', 'price [Euro]': 0.001, 'mass [g]': 0.66, 'environmental impact [kg CO2e /kg]': 11.03, 'delivery time [days]': 3, 'data source': 'https://www.bricklink.com/v2/catalog/catalogitem.page?P=32073', '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}',
+     'data source': 'https://www.bricklink.com/v2/catalog/catalogitem.page?P=32073',
      'delivery time [days]': 3,
      'dimension [studs]': 5,
+     'environmental impact [kg CO2e /kg]': 11.03,
      '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)
+# A wheel consists of a rim (Felge) and a tire (Reifen)
+with open("datasheets/rims.json") as json_file:
+    rims = json.load(json_file)
+with open("datasheets/tires.json") as json_file:
+    tires = 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)
+front_rim = LegoComponent("front rim", rims["56904"], surface="rough", paint="glossy")
+front_tire = LegoComponent("front tire", tires["30699"], winter=True)
+pprint.pprint(front_rim.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")
+back_rim = front_rim.clone("back rim")
+back_tire = front_tire.clone("back tire")
 ```
 
 %% Output
 
-    {'category': 'wheel',
-     'data source': 'https://www.bricklink.com/v2/catalog/catalogitem.page?P=2903c02#T=C',
+    {'category': 'rim',
+     'data source': 'https://www.bricklink.com/v2/catalog/catalogitem.page?P=56904',
      'delivery time [days]': 5,
-     'diameter [mm]': 81.6,
-     'item description': 'wheel 81,6',
-     'item number': '2903c02',
-     'label': 'front wheel',
-     'mass [g]': 30.0,
+     'diameter [mm]': 30.0,
+     'environmental impact [kg CO2e /kg]': 32.06,
+     'item description': 'Wheel 30mm D. x 14mm',
+     'item number': 56904,
+     'label': 'front rim',
+     'mass [g]': 4.1,
      'paint': 'glossy',
-     'price [Euro]': 1.31,
-     'related items': 2902,
+     'price [Euro]': 0.01,
+     'related items': 30699,
      '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])
+front_wheel_assembly.add([front_rim, front_tire])
 # 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])
+back_wheel_assembly.add([back_rim, back_tire])
+
+# Now combine wheels and axles
+
+front_axle_assembly = LegoAssembly(
+    AggregationLayer.ASSEMBLY, "front axle assembly"
+)
+front_axle_assembly.add([front_wheel_assembly, front_axle])
+
+back_axle_assembly = LegoAssembly(
+    AggregationLayer.ASSEMBLY, "back axle assembly"
+)
+back_axle_assembly.add([back_wheel_assembly, back_axle])
 ```
 
 %% Output
 
-    front axle
+    front tire
+
+    ---------------------------------------------------------------------------
+    KeyboardInterrupt                         Traceback (most recent call last)
+Cell     In[6], line 35
+         30 front_axle_assembly.add([front_wheel_assembly, front_axle])
+         32 back_axle_assembly = LegoAssembly(
+         33     AggregationLayer.ASSEMBLY, "back axle assembly"
+         34 )
+    ---> 35 back_axle_assembly.add([back_axle_assembly, back_axle])
+File     c:\Users\Lamm\Documents\02_Areas\Praktikum_Digitalisierung\01_quality-kpi_dev\functions\classes.py:374, in LegoAssembly.add(self, part)
+        372 elif isinstance(part, list):
+        373     for p in part:
+    --> 374         self.add(p)
+        375 else:
+        376     raise TypeError(
+        377         f"Argument should be of types {LegoAssembly.__name__}, "
+        378         f"{LegoComponent.__name__} or a list of them. "
+        379         f"Got {type(part).__name__} instead."
+        380     )
+File     c:\Users\Lamm\Documents\02_Areas\Praktikum_Digitalisierung\01_quality-kpi_dev\functions\classes.py:369, in LegoAssembly.add(self, part)
+        356 """
+        357 Adds either a Lego component, a subassembly or a (mixed) list of them to the
+        358 current assembly. Uses internal functions add_component() and add_assembly().
+       (...)
+        366         instance, or a (mixed) list of them.
+        367 """
+        368 if isinstance(part, LegoComponent):
+    --> 369     self.add_component(part)
+        370 elif isinstance(part, LegoAssembly):
+        371     self.add_assembly(part)
+File     c:\Users\Lamm\Documents\02_Areas\Praktikum_Digitalisierung\01_quality-kpi_dev\functions\classes.py:310, in LegoAssembly.add_component(self, component)
+        304 if not isinstance(component, LegoComponent):
+        305     raise TypeError(
+        306         f"Argument should be of type {LegoComponent.__name__}, "
+        307         f"got {type(component).__name__} instead."
+        308     )
+    --> 310 if self.get_root_assembly().contains_uuid(component._uuid):
+        311     raise AssertionError(
+        312         f"This assembly or a subassembly already contains "
+        313         f"the component with ID "
+        314         f"{component._uuid}."
+        315     )
+        316 component._parent = self
+File     c:\Users\Lamm\Documents\02_Areas\Praktikum_Digitalisierung\01_quality-kpi_dev\functions\classes.py:439, in LegoAssembly.get_root_assembly(self)
+        431 """
+        432 Returns the root LegoAssembly of the current assembly by recursively
+        433 searching up the tree until the top-most parent (the root) is found.
+       (...)
+        436     The root LegoAssembly of the current LegoAssembly instance.
+        437 """
+        438 current_assembly = self
+    --> 439 while current_assembly._parent is not None:
+        440     current_assembly = current_assembly._parent
+        441 return current_assembly
+    KeyboardInterrupt:
 
 %% 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.
 # 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" 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
 total_mass = calculation_rules.kpi_mass(scooter)
 
 print("Gesamtmasse: ", total_mass, "g")
 # Add KPI to system
 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, 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 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]