OBPAnalyser 0.0.1__tar.gz

obpanalyser-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Anton Wiberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

obpanalyser-0.0.1/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: OBPAnalyser
+Version: 0.0.1
+Summary: A package for analysation of open beam files (OBP and OBF).
+Author-email: Anton Wiberg <wiberg.anton@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/wiberganton/OBAnalyser
+Project-URL: Repository, https://github.com/wiberganton/OBAnalyser
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: obplib
+Requires-Dist: numpy
+Requires-Dist: py3mf_slicer
+Requires-Dist: matplotlib
+Requires-Dist: scipy
+Requires-Dist: pandas
+Requires-Dist: pyyaml
+Dynamic: license-file
+
+# OBAnalyser
+This package is used to analyse obf and obp file and make it possible to make heat build compensations

obpanalyser-0.0.1/README.md

@@ -0,0 +1,2 @@
+# OBAnalyser
+This package is used to analyse obf and obp file and make it possible to make heat build compensations

obpanalyser-0.0.1/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "OBPAnalyser"
+version = "0.0.1"
+authors = [{ name = "Anton Wiberg", email = "wiberg.anton@gmail.com" }]
+description = "A package for analysation of open beam files (OBP and OBF)."
+readme = "README.md"
+requires-python = ">=3.7"
+license = { text = "MIT" }
+dependencies = [
+    "obplib",
+    "numpy",
+    "py3mf_slicer",
+    "matplotlib",
+    "scipy",
+    "pandas",
+    "pyyaml"
+]
+
+[project.urls]
+Homepage = "https://github.com/wiberganton/OBAnalyser"
+Repository = "https://github.com/wiberganton/OBAnalyser"

obpanalyser-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

obpanalyser-0.0.1/src/OBPAnalyser.egg-info/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: OBPAnalyser
+Version: 0.0.1
+Summary: A package for analysation of open beam files (OBP and OBF).
+Author-email: Anton Wiberg <wiberg.anton@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/wiberganton/OBAnalyser
+Project-URL: Repository, https://github.com/wiberganton/OBAnalyser
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: obplib
+Requires-Dist: numpy
+Requires-Dist: py3mf_slicer
+Requires-Dist: matplotlib
+Requires-Dist: scipy
+Requires-Dist: pandas
+Requires-Dist: pyyaml
+Dynamic: license-file
+
+# OBAnalyser
+This package is used to analyse obf and obp file and make it possible to make heat build compensations

obpanalyser-0.0.1/src/OBPAnalyser.egg-info/SOURCES.txt

@@ -0,0 +1,26 @@
+LICENSE
+README.md
+pyproject.toml
+src/__init__.py
+src/config.py
+src/OBPAnalyser.egg-info/PKG-INFO
+src/OBPAnalyser.egg-info/SOURCES.txt
+src/OBPAnalyser.egg-info/dependency_links.txt
+src/OBPAnalyser.egg-info/requires.txt
+src/OBPAnalyser.egg-info/top_level.txt
+src/obanalyser/__init__.py
+src/obanalyser/analyse_build.py
+src/obanalyser/analyse_obp.py
+src/obanalyser/compensate_build.py
+src/obanalyser/data_classes.py
+src/obanalyser/extract_obp_elements.py
+src/obanalyser/get_3mf_data.py
+src/obanalyser/get_build_order.py
+src/obanalyser/heat_model_lumped.py
+src/obanalyser/plotters/plot_csv.py
+src/obanalyser/plotters/plot_temp.py
+tests/test_3mf.py
+tests/test_build_compensation.py
+tests/test_build_input.py
+tests/test_export_csv.py
+tests/test_heat_model.py

obpanalyser-0.0.1/src/OBPAnalyser.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

obpanalyser-0.0.1/src/OBPAnalyser.egg-info/requires.txt

@@ -0,0 +1,7 @@
+obplib
+numpy
+py3mf_slicer
+matplotlib
+scipy
+pandas
+pyyaml

obpanalyser-0.0.1/src/OBPAnalyser.egg-info/top_level.txt

@@ -0,0 +1,3 @@
+__init__
+config
+obanalyser

obpanalyser-0.0.1/src/config.py

@@ -0,0 +1,28 @@
+import math
+
+class Config:
+    def __init__(self):
+        # Parameters for build simulation
+        self.transition_time = 8.5 #time [s] for recoter and transition between layers
+        self.time_step = 50 # ref number for time step [us]
+        self.length_step = 500 # ref length step [um]
+        # Geometrical build setup
+        self.build_plate_diameter = 0.1 # diameter of build plate [m]
+        self.build_plate_thickness = 0.015 # thickness of build plate [m]
+        self.build_plate_density = 7990 # density of the material in the build plate [kg/m3]
+        # Heat parameters
+        self.environment_temp_wall = 100 # temp of the wall in the build chamber [C]
+        self.environment_temp_piston = 30 # temp of the wall in the build chamber [C]
+        self.radiation_emissivity = 0.8 # emissitivity constant for the radiation
+        self.thermal_conductivity = 16.0 # W/m·K
+        self.conduction_area_lumped = 0.005 # Area of the conductive material (m2)
+        self.conduction_length_lumped = 0.05 # Height which the conductivity happens (m)
+        # Parameters for build material
+        self.build_material_density = 7990 # density of the material in the build material (solid) [kg/m3]
+        self.build_material_heat_capacity = 500 # Specific Heat Capacity of the material in the build material (solid) [J/kg·K]
+        self.powder_material_density = 0.5 # relative density of the powder compared to bulk properties [-]
+        self.powder_material_heat_capacity = 1 # relative heat capacity of the powder compared to bulk properties [-]
+        # Parameters for heat simulation
+        self.beam_efficiency = 0.95 # Efficiency of the beam
+
+config = Config()

obpanalyser-0.0.1/src/obanalyser/analyse_build.py

@@ -0,0 +1,45 @@
+import json
+import yaml
+import os
+
+from src.obanalyser import get_build_order
+from src.obanalyser import analyse_obp
+from src.obanalyser.data_classes import LayerInfo, BuildInfo
+
+def analyse_build(build_file_path):
+    """
+    Reads an build_info file from an obf folder or yaml file with build info
+    Returns an analyse_data_classes.BuildInfo object with basic information about the build
+    """
+    build_sequence = get_build_order.get_layer_execution_sequence(build_file_path)
+    layer_info = get_build_order.get_other_layer_info(build_file_path)
+    layers = []
+    
+    for i in range(len(layer_info)):
+        obp_info = analyse_obp.analyse_obp_files(build_sequence[i])
+        layer_info_object = LayerInfo(
+            layer_index = i,
+            layer_height = layer_info[i][1],
+            recoate_time = layer_info[i][0],
+            files = obp_info
+        )
+        layers.append(layer_info_object)
+    
+    if build_file_path.endswith(".json"):
+        with open(build_file_path) as f:
+            data = json.load(f)
+        #print("data ", data)
+        start_temp = float(data["startHeat"]["targetTemperature"])
+    elif build_file_path.endswith((".yaml", ".yml")):
+        with open(build_file_path, 'r') as f:
+            data = yaml.safe_load(f)
+        start_temp = float(data["build"]["start_heat"]["target_temperature"])
+    else:
+        print("Not supported file type in build input")
+    
+    build_info = BuildInfo(
+        start_temp = start_temp,
+        layers = layers
+    )
+    
+    return build_info

obpanalyser-0.0.1/src/obanalyser/analyse_obp.py

@@ -0,0 +1,53 @@
+import obplib as obp
+
+from src.obanalyser.data_classes import FileStats
+
+def analyse_obp_files(obp_files):
+    data = []
+    for file in obp_files:
+        data.append(analyse_obp_file(file))
+    return data
+
+def analyse_obp_file(obp_file):
+    # input is (string with obp_path, number of repetitions)
+    # returns an data_classes.FileStats object
+    return analyse_obp_elements(obp.read_obp(obp_file[0]), nmb_repetitions=obp_file[1])
+
+def analyse_obp_elements(obp_elements, nmb_repetitions=1):
+    t = 0  # s
+    energy = 0  # J
+    nmb_spots = 0  # n
+    line_length = 0  # um
+
+    for element in obp_elements:
+        if not isinstance(element, list):
+            element = [element]
+        for lst_el in element:
+            if isinstance(lst_el, obp.TimedPoints):
+                dwellTimes = fill_zeros_with_last_nonzero(lst_el.dwellTimes)
+                energy += lst_el.bp.power * sum(dwellTimes) / 1e9
+                nmb_spots += len(dwellTimes)
+                t += sum(dwellTimes) / 1e9
+            elif isinstance(lst_el, (obp.Line, obp.Curve)):
+                t += lst_el.get_segment_duration()
+                energy += lst_el.bp.power * lst_el.get_segment_duration()
+                line_length += lst_el.get_segment_length()
+
+    data = FileStats(
+        time = t,
+        energy = energy,
+        nmb_spots = nmb_spots,
+        line_length = line_length,
+        nmb_repetitions = nmb_repetitions
+    )
+    return data
+
+def fill_zeros_with_last_nonzero(data):
+    # use for replacing zeroes in dwell time calculation
+    result = []
+    last_value = None
+    for value in data:
+        if value != 0:
+            last_value = value
+        result.append(last_value if last_value is not None else 0)
+    return result

obpanalyser-0.0.1/src/obanalyser/compensate_build.py

@@ -0,0 +1,68 @@
+import json
+import copy
+from pathlib import Path
+
+import src.obanalyser.analyse_build as analyse_build
+import src.obanalyser.analyse_obp as analyse_obp
+import src.obanalyser.heat_model_lumped as heat_model_lumped
+import src.obanalyser.plotters.plot_temp as plot_temp
+
+def lumped_heat_model_compensation(build_info_path, thermal_mass, obp_path_heating, obp_path_cooling):
+    """
+    input:  build_info_path is a string with path to the build info in json format
+            thermal mass is a list with thermal masses for each layer [mass_layer1, mass_layer2, ..]
+            obp_path_heating is a string with a link to the file which is used to add additional energy
+            obp_path_cooling is a string with a link to the file which is used to cool of the build
+    return: new_build a json format with compensated heat_balance
+    """
+    # Get correct paths for the new build file
+    base_dir = Path(build_info_path).parent
+    obp_path_heating_rel = str(Path(obp_path_heating).relative_to(base_dir))
+    obp_path_cooling_rel = str(Path(obp_path_cooling).relative_to(base_dir))
+
+    temp_tolerance = 3 # degrees C
+    build = analyse_build.analyse_build(build_info_path) #data_classes.BuildInfo
+    start_temp = build.start_temp + 273.15 #degrees Kelvin
+    heating_info = analyse_obp.analyse_obp_file((obp_path_heating,1)) #data_classes.FileStats
+    cooling_info = analyse_obp.analyse_obp_file((obp_path_cooling,1)) #data_classes.FileStats
+    with open(build_info_path) as f:
+        new_build = json.load(f)
+    for i, layer in enumerate(build.layers):
+        temp = heat_model_lumped.build_temp(build, thermal_mass, up_to_layer=i)
+        layer_temp = temp[-1][1]
+        if layer_temp < start_temp-temp_tolerance:
+            ii = 0
+            while layer_temp < start_temp-temp_tolerance:
+                build.layers[i].files.append(copy.deepcopy(heating_info))
+                temp = heat_model_lumped.build_temp(build, thermal_mass, up_to_layer=i)
+                layer_temp = temp[-1][1]
+                ii += 1
+            new_build = add_heat_balance(new_build, i, obp_path_heating_rel, ii)
+        elif layer_temp > start_temp+temp_tolerance:
+            ii = 0
+            while layer_temp > start_temp+temp_tolerance:
+                build.layers[i].files.append(copy.deepcopy(cooling_info))
+                temp = heat_model_lumped.build_temp(build, thermal_mass, up_to_layer=i)
+                layer_temp = temp[-1][1]
+                ii += 1
+            new_build = add_heat_balance(new_build, i, obp_path_cooling_rel, ii)
+    return new_build
+
+def add_heat_balance(build, layer_index, file_path, repetitions):
+    # Get the layers list
+    layers = build["layers"]
+    # Ensure the layer index is valid
+    if layer_index >= len(layers):
+        raise IndexError(f"Layer index {layer_index} is out of range.")
+    layer = layers[layer_index]
+    # Create the heatBalance entry
+    new_entry = {
+        "file": file_path,
+        "repetitions": repetitions
+    }
+    # Add or update heatBalance
+    if "heatBalance" in layer:
+        layer["heatBalance"].append(new_entry)
+    else:
+        layer["heatBalance"] = [new_entry]
+    return build

obpanalyser-0.0.1/src/obanalyser/data_classes.py

@@ -0,0 +1,59 @@
+from dataclasses import dataclass, asdict
+from typing import List
+import json
+
+@dataclass
+class FileStats:
+    nmb_repetitions: int #n
+    time: float #s
+    energy: float #J
+    nmb_spots: int #n
+    line_length: float #m
+
+@dataclass
+class LayerInfo:
+    layer_index: int
+    layer_height: float #mm
+    recoate_time: float #s
+    files: List[FileStats]
+
+    def get_layer_time(self):
+        return sum(file.time * file.nmb_repetitions for file in self.files) + self.recoate_time
+    def get_layer_energy(self):
+        return sum(file.energy * file.nmb_repetitions for file in self.files)
+    
+@dataclass
+class BuildInfo:
+    layers: List[LayerInfo]
+    start_temp: float #degress C
+
+    def get_total_duration(self):
+        total = 0.0
+        for layer in self.layers:
+            total += layer.get_layer_time()
+        return total
+
+    def to_json(self, file_path: str):
+        """Serialize the BuildInfo object to a JSON file."""
+        with open(file_path, "w") as f:
+            json.dump(asdict(self), f, indent=4)
+
+    @staticmethod
+    def from_json(file_path: str) -> 'BuildInfo':
+        """Deserialize a JSON file into a BuildInfo object."""
+        with open(file_path, "r") as f:
+            data = json.load(f)
+        
+        layers = [
+            LayerInfo(
+                layer_index=l['layer_index'],
+                layer_height=l['layer_height'],
+                recoate_time=l['recoate_time'],
+                files=[FileStats(**fs) for fs in l['files']]
+            )
+            for l in data['layers']
+        ]
+        return BuildInfo(
+            layers=layers,
+            start_temp=data['start_temp']
+        )

obpanalyser-0.0.1/src/obanalyser/extract_obp_elements.py

@@ -0,0 +1,194 @@
+import obplib as obp
+import numpy as np
+import csv
+import copy
+import pandas as pd
+import os
+
+from src.config import config
+from src.obanalyser.analyse_obp import fill_zeros_with_last_nonzero
+import src.obanalyser.plotters.plot_csv as plot_csv
+
+def extract_multiple_files(obp_files, out_file, t0=0, plot_info=False):
+    """
+    input:  obp_files is a list with obp files on the form [[(path1_layer1, rep),(path2_layer1, rep)],[(path1_layer2, rep),(path2_layer2, rep)]]
+            if the path = "" a delay of rep seconds is inserted
+    """
+    element_data = []
+    t = t0
+    for layer in obp_files:
+        for path, rep in layer:
+            if path == "":
+                element_data.extend(get_delay_elements(rep, t0=t))
+                t += rep
+            else:
+                for i in range(rep):
+                    local_data, t_local = extract_from_obp_file(path, start_time=t)
+                    element_data.extend(local_data)
+                    t = t_local
+    with open(out_file, 'w', newline='') as csvfile:
+        fieldnames = element_data[0].keys()  # Automatically get column names from the first dict
+        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+        writer.writeheader()   # Write column names
+        writer.writerows(element_data) # Write all rows
+    split_csv_files(out_file)
+    if plot_info:
+        plot_csv.plot_xy_path(out_file)
+        plot_csv.plot_power_vs_time(out_file)
+
+
+def extract_from_obp_file(obp_path, start_time = 0):
+    """
+    input:  obp_path string with path to obp file
+            start_time is in seconds when the first element is executed
+    return: list with point wise obp data on the form [{x,y,spot_size,power,time}]
+    """
+    elements = obp.read_obp(obp_path)
+    element_data = []
+    t = start_time
+    for element in elements:
+        if not isinstance(element, list):
+            element = [element]
+        for lst_el in element:
+            if isinstance(lst_el, obp.TimedPoints):    
+                dwellTimes = fill_zeros_with_last_nonzero(lst_el.dwellTimes)
+                local_t = t
+                for i, point in enumerate(lst_el.points):
+                    local_t += dwellTimes[i] / 1e9
+                    element_data.append({
+                        "x": point.x / 1000,
+                        "y": point.y / 1000,
+                        "spot_size": lst_el.bp.spot_size,
+                        "power": lst_el.bp.power,
+                        "time": local_t
+                    })
+                t += sum(dwellTimes) / 1e9
+            elif isinstance(lst_el, obp.Line):
+                line_points = calc_line_point_approximation(lst_el, t0=t)
+                element_data.extend(line_points)
+                t += lst_el.get_segment_duration()
+            elif isinstance(lst_el, obp.Curve):
+                line_points = calc_curve_point_approximation(lst_el, t0=t)
+                element_data.extend(line_points)
+                t += lst_el.get_segment_duration()
+    return (element_data, t)
+
+
+def calc_line_point_approximation(line, t0=0):
+    segment_length = line.get_segment_length()
+    points = [] # list of spots {x[mm], y[mm], spot_size[um], power[W], time[s]}
+    step = 0
+    while step <= segment_length:
+        speed = line.Speed
+        dx = line.P2.x - line.P1.x
+        dy = line.P2.y - line.P1.y
+        if step > 0:
+            dx *= step / segment_length
+            dy *= step / segment_length
+        else:
+            dx = 0
+            dy = 0
+        points.append({
+            "x": (line.P1.x+dx)/1000,
+            "y": (line.P1.y+dy)/1000,
+            "spot_size": line.bp.spot_size,
+            "power": line.bp.power,
+            "time": t0+step/speed
+        })
+        step += config.length_step
+    return points
+def calc_curve_point_approximation(line, t0=0):
+    segment_length = line.get_segment_length()
+    segment_duration = line.get_segment_duration()
+    points = [] # list of spots {x[mm], y[mm], spot_size[um], power[W], time[s]}
+    steps = np.linspace(0, 1, int(segment_length/config.length_step)+1)
+
+    P1 = np.array([line.P1.x, line.P1.y])
+    P2 = np.array([line.P2.x, line.P2.y])
+    P3 = np.array([line.P3.x, line.P3.y])
+    P4 = np.array([line.P4.x, line.P4.y])
+
+    for step in steps:
+        points.append({
+            "x": float(line._bez(P1, P2, P3, P4, step)[0]/1000),
+            "y": float(line._bez(P1, P2, P3, P4, step)[1]/1000),
+            "spot_size": line.bp.spot_size,
+            "power": line.bp.power,
+            "time": t0+step*segment_duration
+        })
+    return points
+
+
+def get_delay_elements(t, t0=0):
+    elements = [
+        {
+            "x": 0,
+            "y": 0,
+            "spot_size": 1000,
+            "power": 0,
+            "time": t0
+        },
+        {
+            "x": 0,
+            "y": 0,
+            "spot_size": 1000,
+            "power": 0,
+            "time": t0+t
+        }
+    ]
+    return elements
+
+def split_csv_files(input_csv):
+    def save_time_xy(input_csv, output_csv):
+        df = pd.read_csv(input_csv)
+        df[['time', 'x', 'y']].to_csv(output_csv, index=False)
+        print(f"Saved: {output_csv}")
+
+    def save_time_spot_size_changes(input_csv, output_csv):
+        df = pd.read_csv(input_csv)
+        records = []
+        # Always start with the first row
+        first_row = df.iloc[0]
+        records.append({'time': first_row['time'], 'spot_size': first_row['spot_size']})
+        for i in range(1, len(df)):
+            prev_row = df.iloc[i - 1]
+            curr_row = df.iloc[i]
+            if curr_row['spot_size'] != prev_row['spot_size']:
+                # Add the change point with the previous value
+                records.append({'time': curr_row['time'], 'spot_size': prev_row['spot_size']})
+                # Add the change point with the new value
+                records.append({'time': curr_row['time'], 'spot_size': curr_row['spot_size']})
+        # Add final value explicitly
+        last_row = df.iloc[-1]
+        records.append({'time': last_row['time'], 'spot_size': last_row['spot_size']})
+        # Save to CSV
+        changes_df = pd.DataFrame(records)
+        changes_df.to_csv(output_csv, index=False)
+        print(f"Saved: {output_csv}")
+
+    def save_time_power_changes(input_csv, output_csv):
+        df = pd.read_csv(input_csv)
+        records = []
+        # Always start with the first row
+        first_row = df.iloc[0]
+        records.append({'time': first_row['time'], 'power': first_row['power']})
+        for i in range(1, len(df)):
+            prev_row = df.iloc[i - 1]
+            curr_row = df.iloc[i]
+            if curr_row['power'] != prev_row['power']:
+                # Add the change point with the previous value
+                records.append({'time': curr_row['time'], 'power': prev_row['power']})
+                # Add the change point with the new value
+                records.append({'time': curr_row['time'], 'power': curr_row['power']})
+        # Add final value explicitly
+        last_row = df.iloc[-1]
+        records.append({'time': last_row['time'], 'power': last_row['power']})
+        # Save to CSV
+        changes_df = pd.DataFrame(records)
+        changes_df.to_csv(output_csv, index=False)
+        print(f"Saved: {output_csv}")
+        
+    base = os.path.splitext(input_csv)[0]
+    save_time_xy(input_csv, base + r"_time_xy.csv")
+    save_time_spot_size_changes(input_csv, base + r"_time_spot_size.csv")
+    save_time_power_changes(input_csv, base + r"_time_power.csv")

obpanalyser-0.0.1/src/obanalyser/get_3mf_data.py

@@ -0,0 +1,46 @@
+import math 
+
+import py3mf_slicer
+import py3mf_slicer.get_items
+
+from src.config import config
+
+def analyse_3mf(model):
+    layer_height = py3mf_slicer.get_items.get_layer_height(model)
+    numb_mesh_objects = py3mf_slicer.get_items.get_number_of_mesh_objects(model)
+    part_areas, total_areas = get_3mf_areas(model)
+    plate_radius = config.build_plate_diameter/2
+    plate_thickness = config.build_plate_thickness
+    plate_mass = plate_radius**2*math.pi*plate_thickness*config.build_plate_density
+    powder_area = (config.build_plate_diameter/2)**2*math.pi
+    density_part = config.build_material_density
+    density_powder = density_part*config.powder_material_density
+    c_part = config.build_material_heat_capacity
+    c_plate = c_part*config.powder_material_heat_capacity
+    current_mass = plate_mass*c_plate
+    thermal_mass = []
+    for area in total_areas:
+        layer_part_area = area/1000000
+        layer_powder_area = powder_area-layer_part_area
+        current_mass = current_mass + layer_part_area*layer_height/1000*c_part*density_part + layer_powder_area*layer_height/1000*c_part*density_powder+c_part*1.08
+        thermal_mass.append(current_mass)
+    return thermal_mass
+
+
+def get_3mf_areas(model):
+    nmb_layers = py3mf_slicer.get_items.get_number_layers(model)
+    max_layer = max(nmb_layers)
+    part_areas = []
+    total_areas = []
+    for layer in range(max_layer):
+        layer_areas = []
+        shapely_slice = py3mf_slicer.get_items.get_shapely_slice(model, layer)
+        for shape in shapely_slice:
+            if shape is not None:
+                layer_areas.append(shape.area)
+            else:
+                layer_areas.append(0)
+        part_areas.append(layer_areas)
+        total_areas.append(sum(layer_areas))
+    return (part_areas, total_areas)
+

obpanalyser-0.0.1/src/obanalyser/get_build_order.py

@@ -0,0 +1,141 @@
+import json
+import yaml
+import os
+
+from src.config import config
+
+def get_layer_execution_sequence(path):
+    """
+    Reads an build_info file from an obf folder or yaml file with build info
+    Returns the sequense of which obp files should be run
+    """
+    if path.endswith(".json"):
+        return get_layer_execution_sequence_obf(path)
+    elif path.endswith((".yaml", ".yml")):
+        return get_layer_execution_sequence_boss(path)
+    else:
+        print("Not supported file type in build input")
+        return None
+
+def get_layer_execution_sequence_obf(path):
+    with open(path) as f:
+        data = json.load(f)
+    # Extract the base directory from the input path
+    base_dir = os.path.dirname(path)
+    layer_defaults = data.get("layerDefaults", {})
+    default_spatter_safe = layer_defaults.get("spatterSafe", [])
+    default_jump_safe = layer_defaults.get("jumpSafe", [])
+    default_heat_balance = layer_defaults.get("heatBalance", [])
+    sequence_per_layer = []
+
+    for layer in data.get("layers", []):
+        layer_sequence = []
+
+        jump_safe_ops = layer.get("jumpSafe", default_jump_safe)
+        spatter_safe_ops = layer.get("spatterSafe", default_spatter_safe)
+        melt_ops = layer.get("melt", [])
+        heat_balance_ops = layer.get("heatBalance", default_heat_balance)
+
+        for op in jump_safe_ops:
+            full_path = os.path.join(base_dir, op["file"])
+            layer_sequence.append((full_path, op["repetitions"]))
+
+        for op in spatter_safe_ops:
+            full_path = os.path.join(base_dir, op["file"])
+            layer_sequence.append((full_path, op["repetitions"]))
+
+        for op in melt_ops:
+            full_path = os.path.join(base_dir, op["file"])
+            layer_sequence.append((full_path, op["repetitions"]))
+
+        for op in heat_balance_ops:
+            full_path = os.path.join(base_dir, op["file"])
+            layer_sequence.append((full_path, op["repetitions"]))
+
+        sequence_per_layer.append(layer_sequence)
+
+    return sequence_per_layer
+
+def get_layer_execution_sequence_boss(yaml_path):
+    with open(yaml_path, 'r') as f:
+        data = yaml.safe_load(f)
+
+    build_data = data.get('build', {})
+    preheat = build_data['preheat']
+    postheat = build_data['postheat']
+    layer_sets = build_data['build']['files']
+    total_layers = build_data['build']['layers']
+
+    preheat_file = preheat['file']
+    preheat_reps = preheat['repetitions']
+    postheat_file = postheat['file']
+    postheat_reps = postheat['repetitions']
+
+    sequence_per_layer = []
+
+    for i in range(total_layers):
+        current_layer_set = layer_sets[i % len(layer_sets)]  # repeat layer sets as needed
+        layer_sequence = []
+
+        # Preheat (maps to spatterSafe)
+        layer_sequence.append((preheat_file, preheat_reps))
+
+        # Melt files (each file in the current set, 1 repetition each)
+        for melt_file in current_layer_set:
+            layer_sequence.append((melt_file, 1))
+
+        # Postheat (maps to heatBalance)
+        layer_sequence.append((postheat_file, postheat_reps))
+
+        sequence_per_layer.append(layer_sequence)
+
+    return sequence_per_layer
+
+
+def get_other_layer_info(path):
+    if path.endswith(".json"):
+        return get_other_layer_info_obf(path)
+    elif path.endswith((".yaml", ".yml")):
+        return get_other_layer_info_yaml(path)
+    else:
+        print("Not supported file type in build input")
+        return None
+
+def get_other_layer_info_obf(path):
+    with open(path) as f:
+        data = json.load(f)
+    layer_defaults = data.get("layerDefaults", {}).get("layerFeed", [])
+    layer_data = []
+    for layer in data.get("layers", []):
+        layerfeed = layer.get("layerFeed", layer_defaults)
+        layer_data.append((calc_layerfeed(layerfeed), -float(layerfeed["buildPistonDistance"])))
+    return layer_data
+
+def get_other_layer_info_yaml(path):
+    with open(path, 'r') as f:
+        data = yaml.safe_load(f)
+    layerfeed = data.get('build', {})['layerfeed']
+    layer_height = -float(layerfeed["build_piston_distance"])
+    layer_time = calc_layerfeed(layerfeed)
+    nmb_of_layers = int(data['build']['build']['layers'])
+    return [(layer_time, layer_height)]*nmb_of_layers
+
+def calc_layerfeed(layerfeed):
+    feed_time = config.transition_time
+    advance_speed = layerfeed.get("recoater_advance_speed") or layerfeed.get("recoaterAdvanceSpeed")
+    retract_speed = layerfeed.get("recoater_retract_speed") or layerfeed.get("recoaterRetractSpeed")
+    speed = (advance_speed + retract_speed)/200
+    if "recoater_full_repeats" in layerfeed:
+        full_repeats = layerfeed["recoater_full_repeats"]
+    elif "recoaterFullRepeats" in layerfeed:
+        full_repeats = layerfeed["recoaterFullRepeats"]
+    else:
+        full_repeats = None  # or a default value
+    if "recoater_dwell_time" in layerfeed:
+        dwell_time = layerfeed["recoater_dwell_time"]
+    elif "recoaterDwellTime" in layerfeed:
+        dwell_time = layerfeed["recoaterDwellTime"]
+    else:
+        dwell_time = None  # or a default value
+    new_feed_time = (full_repeats+1)*speed*feed_time+dwell_time
+    return new_feed_time

obpanalyser-0.0.1/src/obanalyser/heat_model_lumped.py

@@ -0,0 +1,75 @@
+import math
+
+from src.config import config
+
+def predict_losses(T_i, t):
+    """
+    input:  T_i is the inital temp (Kelvin)
+            t is the duration (s)
+    return: loss energy (J)
+    """
+    # radiation loss
+    sigma = 5.67e-8  # Stefan-Boltzmann constant
+    epsilon = config.radiation_emissivity    # example emissivity       
+    A_surface = (config.build_plate_diameter/2)**2*math.pi #area in m²
+    T_env = config.environment_temp_wall + 273.15  # environment temp in K
+    Q_rad = epsilon * sigma * A_surface * (T_i**4 - T_env**4) * t
+    
+    # conducation loss
+    delta_T = T_i - config.environment_temp_piston
+    Q_con = config.thermal_conductivity*config.conduction_area_lumped*delta_T/config.conduction_length_lumped
+
+    return Q_rad + Q_con
+
+def layer_temp(layer_info, start_temp, thermal_masses):
+    """
+    inputs: layer_info is a data_classes.LayerInfo object
+            start_temp is the intial temperature in Kelvin
+            thermal_masses is a list of thermal masses for each layer
+            layer is at which layer we want to evaluate
+    return: List with data points [time (s), temp (K)] starting from t=0
+    """
+    layer = layer_info.layer_index
+    data = [[0, start_temp]] # List with data points [time (s), temp (K)]
+    # recoate temp
+    temp_change = predict_temp_change(thermal_masses[layer], -predict_losses(start_temp, layer_info.recoate_time))
+    temp = start_temp + temp_change
+    t = layer_info.recoate_time
+    data.append([t, temp])
+    # loop for files
+    for file in layer_info.files:
+        for _ in range(file.nmb_repetitions):
+            losses = predict_losses(temp, file.time)
+            energy_input = file.energy*config.beam_efficiency
+            temp_change = predict_temp_change(thermal_masses[layer], energy_input-losses)
+            temp += temp_change
+            t += file.time
+            data.append([t, temp])
+    return data
+
+def predict_temp_change(layer_mass, delta_energy):
+    return delta_energy/layer_mass
+
+
+def build_temp(build_info, thermal_masses, up_to_layer=None): 
+    """
+    inputs: build_info is a data_classes.BuildInfo object
+            thermal_masses is a list of thermal masses for each layer
+    return: List with data points [time (s), temp (K)] starting from t=0
+    """
+        
+    start_temp = build_info.start_temp + 273.15
+    data = [[0, start_temp]] # List with data points [time (s), temp (K)]
+    count = 0
+    for layer_info in build_info.layers:
+        layer_data = layer_temp(layer_info, data[-1][1], thermal_masses)
+        for row in layer_data:
+            row[0] += data[-1][0]
+        data.extend(layer_data[1:])
+        if up_to_layer is not None and count >= up_to_layer:
+            #print("build_info ", len(layer_info.files))
+            break
+        count += 1
+    return data
+    
+

obpanalyser-0.0.1/src/obanalyser/plotters/plot_csv.py

@@ -0,0 +1,33 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+
+def plot_power_vs_time(csv_path):
+    # Read the CSV file
+    df = pd.read_csv(csv_path)
+
+    # Plot power vs time
+    plt.figure(figsize=(8, 5))
+    plt.plot(df['time'], df['power'], label='Power', color='blue')
+    plt.xlabel('Time [s]')
+    plt.ylabel('Power [W]')
+    plt.title('Power as a Function of Time')
+    plt.grid(True)
+    plt.legend()
+    plt.tight_layout()
+    plt.show()
+
+def plot_xy_path(csv_path):
+    # Read the CSV file
+    df = pd.read_csv(csv_path)
+
+    # Plot x vs y
+    plt.figure(figsize=(8, 5))
+    plt.plot(df['x'], df['y'], marker='o', linestyle='-', color='green', label='Path')
+    plt.xlabel('X Coordinate')
+    plt.ylabel('Y Coordinate')
+    plt.title('XY Coordinate Path')
+    plt.grid(True)
+    plt.axis('equal')  # Ensures aspect ratio is equal for X and Y
+    plt.legend()
+    plt.tight_layout()
+    plt.show()

obpanalyser-0.0.1/src/obanalyser/plotters/plot_temp.py

@@ -0,0 +1,17 @@
+
+import matplotlib.pyplot as plt
+
+def plot_lump_temp(temperatures):
+    """
+    input: temperatures as list on the form [time (s), temp (K)]
+    """
+    # Split the list into two separate lists for x and y
+    x = [row[0] for row in temperatures]
+    y = [row[1] for row in temperatures]
+
+    # Plot
+    plt.plot(x, y, marker='o')
+    plt.xlabel("time (s)")
+    plt.ylabel("temperature (K)")
+    plt.grid(True)
+    plt.show()

obpanalyser-0.0.1/tests/test_3mf.py

@@ -0,0 +1,24 @@
+import unittest
+import py3mf_slicer.load
+import py3mf_slicer.slice
+
+from src.obanalyser import get_3mf_data
+
+
+class TestMain(unittest.TestCase):
+    def test_main(self):
+        geometries = [
+            r'tests\input\geometries\test_geometry1.stl', 
+            r'tests\input\geometries\test_geometry2.stl', 
+            r'tests\input\geometries\test_geometry3.stl']
+        model = py3mf_slicer.load.load_files(geometries)
+        self.assertIsNotNone(model, "Model failed to load")
+        # Step 2: Slice the model
+        sliced_model = py3mf_slicer.slice.slice_model(model, 1)
+        self.assertIsNotNone(sliced_model, "sliced 3mf model failed")
+        thermal_mass = get_3mf_data.analyse_3mf(sliced_model)
+        self.assertIsNotNone(thermal_mass, "obp analyse failed")
+        print("test_3mf works!")
+
+if __name__ == "__main__":
+    unittest.main()

obpanalyser-0.0.1/tests/test_build_compensation.py

@@ -0,0 +1,46 @@
+import unittest
+import py3mf_slicer
+import json
+
+import src.obanalyser.analyse_build as analyse_build
+import src.obanalyser.analyse_obp as analyse_obp
+import src.obanalyser.get_3mf_data as get_3mf_data
+import src.obanalyser.compensate_build as compensate_build
+import src.obanalyser.heat_model_lumped as heat_model_lumped
+from src.obanalyser.plotters.plot_temp import plot_lump_temp
+
+
+class TestMain(unittest.TestCase):
+    def test_main(self):
+        # prepare 3mf file
+        geometries = [
+            r"tests\input\cubes_test\geometry\part1.stl", 
+            r"tests\input\cubes_test\geometry\part2.stl",  
+            r"tests\input\cubes_test\geometry\part3.stl", 
+            r"tests\input\cubes_test\geometry\part4.stl"]
+        model = py3mf_slicer.load.load_files(geometries)
+        sliced_model = py3mf_slicer.slice.slice_model(model, 0.1)
+        thermal_mass = get_3mf_data.analyse_3mf(sliced_model)
+        # build info
+        path = r"tests/input/cubes_test/buildInfo.json"
+        output_path = r"tests/input/cubes_test/newbuildInfo.json"
+        build = analyse_build.analyse_build(path)
+        data = heat_model_lumped.build_temp(build, thermal_mass)
+        #print("not compensated data: ")
+        #plot_lump_temp(data)
+        
+        # build compensation
+        obp_path_heating = r"tests/input/cubes_test/obp/heat_compensation.obp"
+        obp_path_cooling = r"tests/input/cubes_test/obp/PostMelt_IdleScan.obp"
+        new_build = compensate_build.lumped_heat_model_compensation(path, thermal_mass, obp_path_heating, obp_path_cooling)
+        with open(output_path, "w") as json_file:
+            json.dump(new_build, json_file, indent=4)
+        new_build_object = analyse_build.analyse_build(output_path)
+        data = heat_model_lumped.build_temp(new_build_object, thermal_mass)
+        #print("compensated data: ")
+        #plot_lump_temp(data)
+if __name__ == "__main__":
+    unittest.main()
+
+
+

obpanalyser-0.0.1/tests/test_build_input.py

@@ -0,0 +1,17 @@
+import unittest
+import src.obanalyser.analyse_build as analyse_build
+
+class TestMain(unittest.TestCase):
+    def test_main(self):
+        # build info
+        path = r"tests\input\test_input1\buildInfo.json"
+        build = analyse_build.analyse_build(path)
+        build.to_json(r"tests\output\build_info.json")
+        
+        #plot_csv_file.plot_csv(out)
+        print("test_build_input works")
+if __name__ == "__main__":
+    unittest.main()
+
+
+

obpanalyser-0.0.1/tests/test_export_csv.py

@@ -0,0 +1,18 @@
+import unittest
+import csv
+
+import src.obanalyser.extract_obp_elements as extract_obp_elements
+import src.obanalyser.plotters.plot_csv as plot_csv
+
+class TestMain(unittest.TestCase):
+    def test_main(self):
+        path1 = r"C:\Users\antwi87\Downloads\OneDrive_1_23-05-2025\TEEM02_R_Plate.obp"
+        path2 = r"C:\Users\antwi87\Downloads\OneDrive_1_23-05-2025\LowCurrentPreheat_PT_V_left_half.obp"
+        path3 = r"C:\Users\antwi87\Downloads\OneDrive_1_23-05-2025\TEEM02_L_Powder.obp"
+
+        paths = [[(path1, 1), ("", 8), (path2, 10), (path3, 1)]]
+        out_file = r"tests\output\test_export_csv.csv"
+        extract_obp_elements.extract_multiple_files(paths, out_file, t0=0, plot_info=False)
+        
+if __name__ == "__main__":
+    unittest.main()

obpanalyser-0.0.1/tests/test_heat_model.py

@@ -0,0 +1,24 @@
+import unittest
+import py3mf_slicer.load
+import py3mf_slicer.slice
+import json
+
+from src.obanalyser import get_3mf_data
+import src.obanalyser.analyse_build as analyse_build
+import src.obanalyser.heat_model_lumped as heat_model_lumped
+from src.obanalyser.plotters.plot_temp import plot_lump_temp
+import src.obanalyser.data_classes as data_classes
+
+
+class TestMain(unittest.TestCase):
+    def test_main(self):
+        build = data_classes.BuildInfo.from_json(r"tests\input\screw_test\build_info.json")
+        with open(r"tests\input\screw_test\thermal_mass.json", 'r') as f:
+            thermal_mass = json.load(f)
+        # thermal model
+        data = heat_model_lumped.build_temp(build, thermal_mass)
+        #plot_lump_temp(data)
+        print("test_heat_model works")
+        
+if __name__ == "__main__":
+    unittest.main()