lpbf-map 0.1.0__py3-none-any.whl

lpbf_map/__init__.py

@@ -0,0 +1,12 @@
+"""
+L-PBF Printability Space
+A predictive analytical modeling library for L-PBF processing maps.
+"""
+
+__version__ = "0.1.0"
+
+from .materials import Material
+from .parameters import ProcessParameters
+from .meltpool import MeltPool
+from .printability import PrintabilitySpace
+from .units import PARAMETER_UNITS, format_parameter_label, get_parameter_formatting

lpbf_map/database/Al6061.json

@@ -0,0 +1,10 @@
+{
+    "name": "Al6061",
+    "density": 2700,
+    "specific_heat": 834.32,
+    "thermal_conductivity": 331.84,
+    "boiling_temperature": 2350,
+    "melting_temperature": 923,
+    "absorptivity": 0.13,
+    "electrical_resistivity": 4.4e-8
+}

lpbf_map/database/MoNbTaW.json

@@ -0,0 +1,9 @@
+{
+    "name": "MoNbTaW",
+    "density": 13114,
+    "specific_heat": 314.06,
+    "thermal_conductivity": 45.51,
+    "boiling_temperature": 5397.5,
+    "melting_temperature": 3123.5,
+    "absorptivity": 0.40
+}

lpbf_map/database/NiTi_Sheikh.json

@@ -0,0 +1,10 @@
+{
+    "name": "NiTi",
+    "density": 6471,
+    "specific_heat": 571.8,
+    "thermal_conductivity": 29.62,
+    "boiling_temperature": 3033,
+    "melting_temperature": 1583,
+    "absorptivity": 0.56,
+    "electrical_resistivity": 8.2e-8
+}

lpbf_map/database/Ti64.json

@@ -0,0 +1,9 @@
+{
+    "name": "Ti-6Al-4V",
+    "density": 4250,
+    "specific_heat": 745,
+    "thermal_conductivity": 38,
+    "boiling_temperature": 3560,
+    "melting_temperature": 1877,
+    "absorptivity": 0.60
+}

lpbf_map/database/__init__.py

@@ -0,0 +1 @@
+# Database module for material JSON properties

lpbf_map/defects/__init__.py

@@ -0,0 +1,22 @@
+from .base import DefectCriterion, DefectSuite
+from .balling import BallingPlateauRayleighCriterion
+from .keyhole import KeyholeCriterion
+from .lof import LackOfFusionCriterion
+from .balling_yadroitsev import BallingYadroitsevCriterion
+from .keyhole_king import KeyholeKingCriterion
+from .keyhole_gan import KeyholeGanCriterion
+from .keyhole_geometric import KeyholeGeometricCriterion
+from .lof_depth_ratio import LackOfFusionDepthRatioCriterion
+
+__all__ = [
+    "DefectCriterion",
+    "DefectSuite",
+    "BallingPlateauRayleighCriterion",
+    "KeyholeCriterion",
+    "LackOfFusionCriterion",
+    "BallingYadroitsevCriterion",
+    "KeyholeKingCriterion",
+    "KeyholeGanCriterion",
+    "KeyholeGeometricCriterion",
+    "LackOfFusionDepthRatioCriterion"
+]

lpbf_map/defects/balling.py

@@ -0,0 +1,20 @@
+from .base import DefectCriterion
+from typing import Tuple
+from ..meltpool import MeltPool
+
+class BallingPlateauRayleighCriterion(DefectCriterion):
+    """
+    Plateau-Rayleigh capillary instability criterion for Balling.
+    Returns True if the melt track length-to-width ratio exceeds the threshold.
+    """
+    def __init__(self, threshold: float = 2.3):
+        self.threshold = threshold
+        
+    def check(self, melt_pool: MeltPool, idx: Tuple[int, ...]) -> bool:
+        length = float(melt_pool.length[idx] if melt_pool.is_vectorized else melt_pool.length)
+        width = float(melt_pool.width[idx] if melt_pool.is_vectorized else melt_pool.width)
+        
+        if width == 0:
+            return True
+            
+        return (length / width) >= self.threshold

lpbf_map/defects/balling_yadroitsev.py

@@ -0,0 +1,23 @@
+from .base import DefectCriterion
+from typing import Tuple
+from ..meltpool import MeltPool
+
+class BallingYadroitsevCriterion(DefectCriterion):
+    """
+    Yadroitsev criterion for Balling.
+    Returns True if the melt track width is too narrow compared to the layer thickness.
+    """
+    def __init__(self, threshold: float = 1.0):
+        self.threshold = threshold
+        
+    def check(self, melt_pool: MeltPool, idx: Tuple[int, ...]) -> bool:
+        width = float(melt_pool.width[idx] if melt_pool.is_vectorized else melt_pool.width)
+        layer_thickness = melt_pool.get_property('layer_thickness', idx)
+        
+        if layer_thickness is None:
+            return False
+            
+        if width == 0:
+            return True
+            
+        return (width / layer_thickness) < self.threshold

lpbf_map/defects/base.py

@@ -0,0 +1,37 @@
+from abc import ABC, abstractmethod
+from typing import Tuple, Any
+
+class DefectCriterion(ABC):
+    """
+    Abstract base class for a parametric defect.
+    """
+    @abstractmethod
+    def check(self, melt_pool: Any, idx: Tuple[int, ...]) -> bool:
+        """
+        Evaluates whether the defect occurs at the specific N-dimensional grid coordinate.
+        """
+        pass
+
+class DefectSuite:
+    """
+    Container for prioritizing and executing DefectCriteria over a MeltPool.
+    """
+    def __init__(self):
+        self.criteria = []
+        
+    def add(self, priority_id: int, criterion: DefectCriterion):
+        """
+        Registers a defect with a priority ID. Lower ID = higher priority.
+        """
+        self.criteria.append((priority_id, criterion))
+        # Sort by priority ID (lowest first)
+        self.criteria.sort(key=lambda x: x[0])
+        
+    def evaluate(self, melt_pool: Any, idx: Tuple[int, ...]) -> int:
+        """
+        Checks all registered criteria at the given index. Returns the first matching defect ID, or 0 if Safe.
+        """
+        for priority_id, criterion in self.criteria:
+            if criterion.check(melt_pool, idx):
+                return priority_id
+        return 0 # Safe Zone

lpbf_map/defects/keyhole.py

@@ -0,0 +1,18 @@
+from .base import DefectCriterion
+
+class KeyholeCriterion(DefectCriterion):
+    """
+    Geometric Ratio criterion for Keyhole porosity.
+    Returns True if the melt pool is too deep relative to its width (W/D < threshold).
+    """
+    def __init__(self, threshold: float = 2.3):
+        self.threshold = threshold
+        
+    def check(self, melt_pool, idx: tuple) -> bool:
+        width = float(melt_pool.width[idx])
+        depth = float(melt_pool.depth[idx])
+        
+        if depth == 0:
+            return False # No depth means no keyhole
+            
+        return (width / depth) < self.threshold

lpbf_map/defects/keyhole_gan.py

@@ -0,0 +1,30 @@
+import numpy as np
+from typing import Tuple
+
+from .base import DefectCriterion
+from ..meltpool import MeltPool
+
+class KeyholeGanCriterion(DefectCriterion):
+    """
+    Gan universal keyhole criterion based on normalized enthalpy.
+    Returns True if the normalized enthalpy exceeds the empirical threshold of 6.0.
+    """
+    def check(self, melt_pool: MeltPool, idx: Tuple[int, ...]) -> bool:
+        absorptivity = melt_pool.get_property('absorptivity', idx)
+        density = melt_pool.get_property('density', idx)
+        specific_heat = melt_pool.get_property('specific_heat', idx)
+        melting_temperature = melt_pool.get_property('melting_temperature', idx)
+        thermal_diffusivity = melt_pool.get_property('thermal_diffusivity', idx)
+
+        laser_power = melt_pool.get_property('laser_power', idx)
+        scan_speed = melt_pool.get_property('scan_speed', idx)
+        beam_radius = melt_pool.get_property('beam_radius', idx)
+        ambient_temperature = melt_pool.get_property('ambient_temperature', idx)
+
+        normalized_enthalpy = (absorptivity * laser_power) / (
+            (melting_temperature - ambient_temperature)
+            * np.pi * density * specific_heat
+            * np.sqrt(thermal_diffusivity * scan_speed * beam_radius**3)
+        )
+
+        return normalized_enthalpy > 6.0

lpbf_map/defects/keyhole_geometric.py

@@ -0,0 +1,16 @@
+from .base import DefectCriterion
+from typing import Tuple
+from ..meltpool import MeltPool
+
+class KeyholeGeometricCriterion(DefectCriterion):
+    """
+    Geometric Ratio criterion for Keyhole porosity.
+    Returns True if the melt pool is too deep relative to its width (W/D < threshold).
+    """
+    def __init__(self, threshold: float = 2.0):
+        self.threshold = threshold
+        
+    def check(self, melt_pool: MeltPool, idx: Tuple[int, ...]) -> bool:
+        depth = float(melt_pool.depth[idx] if melt_pool.is_vectorized else melt_pool.depth)
+        beam_radius = melt_pool.get_property('beam_radius', idx)
+        return depth > beam_radius * self.threshold

lpbf_map/defects/keyhole_king.py

@@ -0,0 +1,28 @@
+import numpy as np
+from typing import Tuple
+
+from .base import DefectCriterion
+from ..meltpool import MeltPool
+
+class KeyholeKingCriterion(DefectCriterion):
+    """
+    King keyhole criterion based on conduction-to-keyhole transition.
+    """
+    def check(self, melt_pool: MeltPool, idx: Tuple[int, ...]) -> bool:
+        absorptivity = melt_pool.get_property('absorptivity', idx)
+        melting_temperature = melt_pool.get_property('melting_temperature', idx)
+        ambient_temperature = melt_pool.get_property('ambient_temperature', idx)
+        thermal_conductivity = melt_pool.get_property('thermal_conductivity', idx)
+        boiling_temperature = melt_pool.get_property('boiling_temperature', idx)
+        
+        laser_power = melt_pool.get_property('laser_power', idx)
+        beam_radius = melt_pool.get_property('beam_radius', idx)
+
+        threshold_power = (
+            (melting_temperature - ambient_temperature)
+            * np.pi * thermal_conductivity * beam_radius
+            / absorptivity
+        )
+        threshold_power *= (boiling_temperature / melting_temperature)
+
+        return laser_power > threshold_power

lpbf_map/defects/lof.py

@@ -0,0 +1,25 @@
+import numpy as np
+from .base import DefectCriterion
+
+class LackOfFusionCriterion(DefectCriterion):
+    """
+    Geometric Overlap criterion for Lack of Fusion.
+    Returns True if voids form between adjacent tracks.
+    """
+    def check(self, melt_pool, idx: tuple) -> bool:
+        depth = float(melt_pool.depth[idx] if melt_pool.is_vectorized else melt_pool.depth)
+        width = float(melt_pool.width[idx] if melt_pool.is_vectorized else melt_pool.width)
+        
+        layer_thickness = melt_pool.get_property('layer_thickness', idx)
+        hatch_spacing = melt_pool.get_property('hatch_spacing', idx)
+        
+        if layer_thickness is None or hatch_spacing is None:
+            return False
+
+        if depth <= 1e-9 or width <= 1e-9:
+            return True   
+
+        if (hatch_spacing/width)**2 >= 1:
+            return True 
+
+        return layer_thickness > depth * np.sqrt(1 - (hatch_spacing/width)**2)

lpbf_map/defects/lof_depth_ratio.py

@@ -0,0 +1,23 @@
+from .base import DefectCriterion
+from typing import Tuple
+from ..meltpool import MeltPool
+
+class LackOfFusionDepthRatioCriterion(DefectCriterion):
+    """
+    Depth-to-Layer-Thickness Ratio criterion for Lack of Fusion.
+    Returns True if the melt pool depth does not sufficiently penetrate the layer thickness.
+    """
+    def __init__(self, threshold: float = 1.5):
+        self.threshold = threshold
+        
+    def check(self, melt_pool: MeltPool, idx: Tuple[int, ...]) -> bool:
+        depth = float(melt_pool.depth[idx] if melt_pool.is_vectorized else melt_pool.depth)
+        layer_thickness = melt_pool.get_property('layer_thickness', idx)
+        
+        if layer_thickness is None:
+            return False
+            
+        if layer_thickness == 0:
+            return False
+            
+        return (depth / layer_thickness) < self.threshold

lpbf_map/materials.py

@@ -0,0 +1,182 @@
+import json
+from dataclasses import dataclass
+from typing import Optional, Union
+import numpy as np
+import importlib.resources
+
+@dataclass
+class Material:
+    """
+    Represents the thermophysical blueprint of an alloy for L-PBF modeling.
+    Uses strict SI units (kg, m, s, W, K).
+
+    All numeric properties are internally cast to NumPy arrays on initialisation,
+    so that single-value materials and multi-value 'material sweeps' (e.g. a
+    thermal_conductivity sweep) share a unified API and always expose `.shape`.
+    """
+    name: str
+    density: Union[float, np.ndarray]                # rho [kg/m^3]
+    specific_heat: Union[float, np.ndarray]          # C_p [J/(kg*K)]
+    thermal_conductivity: Union[float, np.ndarray]   # k [W/(m*K)]
+    melting_temperature: Union[float, np.ndarray]    # T_m [K]
+    boiling_temperature: Union[float, np.ndarray]    # T_b [K]
+    absorptivity: Union[float, np.ndarray]           # A [dimensionless]
+    thermal_diffusivity: Optional[Union[float, np.ndarray]] = None  # alpha [m^2/s]
+    electrical_resistivity: Optional[Union[float, np.ndarray]] = None  # rho_e [Ohm*m]
+
+    def __post_init__(self):
+        """
+        Casts all numeric properties to NumPy arrays and validates physical limits.
+        Auto-calculates thermal diffusivity if it was not explicitly provided.
+        """
+        # --- NumPy casting: ensures every property exposes .shape uniformly ---
+        self.density = np.asarray(self.density, dtype=float)
+        self.specific_heat = np.asarray(self.specific_heat, dtype=float)
+        self.thermal_conductivity = np.asarray(self.thermal_conductivity, dtype=float)
+        self.melting_temperature = np.asarray(self.melting_temperature, dtype=float)
+        self.boiling_temperature = np.asarray(self.boiling_temperature, dtype=float)
+        self.absorptivity = np.asarray(self.absorptivity, dtype=float)
+        if self.thermal_diffusivity is not None:
+            self.thermal_diffusivity = np.asarray(self.thermal_diffusivity, dtype=float)
+        if self.electrical_resistivity is not None:
+            self.electrical_resistivity = np.asarray(self.electrical_resistivity, dtype=float)
+
+        # --- Physical validation ---
+        if np.any(self.density <= 0):
+            raise ValueError(f"Density must be > 0. Got {self.density}")
+        if np.any(self.specific_heat <= 0):
+            raise ValueError(f"Specific heat must be > 0. Got {self.specific_heat}")
+        if np.any(self.thermal_conductivity <= 0):
+            raise ValueError(f"Thermal conductivity must be > 0. Got {self.thermal_conductivity}")
+
+        # --- Derived property: alpha = k / (rho * C_p) ---
+        if self.thermal_diffusivity is None:
+            self.thermal_diffusivity = self.thermal_conductivity / (self.density * self.specific_heat)
+
+    def calculate_absorptivity(self, wavelength: Union[float, np.ndarray], method: str = 'hagen-rubens') -> None:
+        """
+        Computes and updates `self.absorptivity` from a theoretical model.
+
+        By default uses the Hagen-Rubens approximation, which requires
+        `self.electrical_resistivity` to be set on this Material object.
+
+        Args:
+            wavelength: Laser wavelength in metres (m). Can be a scalar or array
+                        matching the parameter sweep.
+            method:     The analytical model to apply. Currently supported:
+                        - 'hagen-rubens': Simplified Drude model,
+                          A ≈ 0.365 * sqrt(electrical_resistivity / wavelength).
+
+        Raises:
+            ValueError: If `electrical_resistivity` is None when using 'hagen-rubens'.
+            ValueError: If an unsupported method name is given.
+        """
+        method = method.lower()
+        valid_methods = ['hagen_rubens', 'gusarov_smurov', 'boley_hex', 'boley_gaussian', 'boley_bimodal']
+        
+        if method not in valid_methods:
+            raise ValueError(f"Unknown absorptivity method: '{method}'. Supported: {valid_methods}.")
+            
+        if self.electrical_resistivity is None:
+            raise ValueError(
+                f"Method '{method}' requires 'electrical_resistivity' to be set on the Material."
+            )
+            
+        wavelength = np.asarray(wavelength, dtype=float)
+
+        # Base solid absorptivity via Hagen-Rubens
+        As = 0.365 * np.sqrt(self.electrical_resistivity / wavelength)
+        
+        if method == 'hagen_rubens':
+            absorptivity_raw = As
+        elif method == 'gusarov_smurov':
+            absorptivity_raw = (2 * np.sqrt(As)) / (1 + np.sqrt(As))
+        elif method == 'boley_hex':
+            absorptivity_raw = 0.0889 + 2.73 * As - 5.06 * (As**2) + 4.29 * (As**3)
+        elif method == 'boley_gaussian':
+            absorptivity_raw = 0.0413 + 2.89 * As - 5.36 * (As**2) + 4.50 * (As**3)
+        elif method == 'boley_bimodal':
+            absorptivity_raw = 0.104 + 2.39 * As - 3.31 * (As**2) + 2.20 * (As**3)
+
+        # Physical constraint: absorptivity cannot exceed 1.0 (100%)
+        self.absorptivity = np.minimum(absorptivity_raw, 1.0)
+
+    @classmethod
+    def from_library(cls, material_name: str) -> "Material":
+        """
+        Factory method that loads a material from the native PyPI packaged JSON library.
+        
+        Args:
+            material_name: Name of the material file (e.g. 'Ti64' for Ti64.json)
+        """
+        if not material_name.endswith('.json'):
+            filename = f"{material_name}.json"
+        else:
+            filename = material_name
+            
+        try:
+            # Using importlib.resources to guarantee resolution even when pip-installed
+            with importlib.resources.open_text('lpbf_map.database', filename) as f:
+                data = json.load(f)
+                
+            return cls(
+                name=data.get("name", material_name),
+                density=data.get("density", data.get("rho")),
+                specific_heat=data.get("specific_heat", data.get("C_p")),
+                thermal_conductivity=data.get("thermal_conductivity", data.get("k")),
+                melting_temperature=data.get("melting_temperature", data.get("T_m")),
+                boiling_temperature=data.get("boiling_temperature", data.get("T_b")), 
+                absorptivity=data.get("absorptivity", data.get("A")),
+                thermal_diffusivity=data.get("thermal_diffusivity", data.get("alpha")),
+                electrical_resistivity=data.get("electrical_resistivity", data.get("rho_e"))
+            )
+        except FileNotFoundError:
+            raise FileNotFoundError(f"Material {filename} not found in native database.")
+        except KeyError as e:
+            raise ValueError(f"Material JSON {filename} is missing required field: {e}")
+
+    @classmethod
+    def from_dict(cls, data: dict, name: str = "Custom") -> "Material":
+        """
+        Helper method to create a material from an existing dictionary of old keys.
+        """
+        return cls(
+            name=name,
+            density=data.get("density", data.get("rho")),
+            specific_heat=data.get("specific_heat", data.get("C_p")),
+            thermal_conductivity=data.get("thermal_conductivity", data.get("k")),
+            melting_temperature=data.get("melting_temperature", data.get("T_m")),
+            boiling_temperature=data.get("boiling_temperature", data.get("T_b")),
+            absorptivity=data.get("absorptivity", data.get("A")),
+            thermal_diffusivity=data.get("thermal_diffusivity", data.get("alpha")),
+            electrical_resistivity=data.get("electrical_resistivity", data.get("rho_e"))
+        )
+
+    def plot_absorptivity_models(self, wavelengths: np.ndarray = None, save_path: str = None):
+        """
+        Evaluates and plots all 5 mathematical models of absorptivity over a range of wavelengths.
+        """
+        import matplotlib.pyplot as plt
+        if wavelengths is None:
+            wavelengths = np.linspace(0.5e-6, 2.0e-6, 50)
+            
+        models = ['hagen_rubens', 'gusarov_smurov', 'boley_hex', 'boley_gaussian', 'boley_bimodal']
+        labels = ['Hagen-Rubens', 'Gusarov-Smurov', 'Boley (Hexagonal)', 'Boley (Gaussian)', 'Boley (Bimodal)']
+        
+        fig, ax = plt.subplots(figsize=(8, 5))
+        cmap = plt.cm.inferno
+        colors = [cmap(i) for i in np.linspace(0.15, 0.85, len(models))]
+        for m, lbl, color in zip(models, labels, colors):
+            self.calculate_absorptivity(wavelengths, method=m)
+            ax.plot(wavelengths * 1e9, self.absorptivity * 100, label=lbl, linewidth=2, color=color)
+            
+        ax.set_title(f"Absorptivity Models for {self.name}", fontsize=14, fontweight='bold')
+        ax.set_xlabel("Wavelength (nm)", fontsize=12)
+        ax.set_ylabel("Absorptivity (%)", fontsize=12)
+        ax.grid(True, linestyle='--', alpha=0.7)
+        ax.legend()
+        plt.tight_layout()
+        
+        if save_path:
+            plt.savefig(save_path, dpi=300, bbox_inches='tight')
+        return fig, ax