pyedb 0.43.0__py3-none-any.whl → 0.44.0__py3-none-any.whl

pyedb/grpc/database/definition/component_def.py

@@ -216,3 +216,18 @@ class ComponentDef(GrpcComponentDef):
             n_port_model.reference_file = fpath
             self.add_component_model(n_port_model)
             return n_port_model
+
+    def get_properties(self):
+        data = {}
+        temp = []
+        for i in self.component_pins:
+            temp.append(i.name)
+        data["pin_order"] = temp
+        return data
+
+    def set_properties(self, **kwargs):
+        pin_order = kwargs.get("pin_order")
+        if pin_order:
+            old = {i.name: i for i in self.component_pins}
+            temp = [old[str(i)] for i in pin_order]
+            self.component_pins = temp

pyedb/grpc/database/definition/component_pin.py

@@ -28,5 +28,5 @@ class ComponentPin(GrpcComponentPin):
     """Class managing :class:`ComponentPin <ansys.edb.core.definition.component_pin.ComponentPin>`."""
 
     def __init__(self, pedb, edb_object):
-        super().__init__(edb_object)
+        super().__init__(edb_object.msg)
         self._pedb = pedb

pyedb/grpc/database/definition/materials.py

@@ -587,6 +587,33 @@ class Material(GrpcMaterialDef):
 class Materials(object):
     """Manages EDB methods for material management accessible from `Edb.materials` property."""
 
+    default_conductor_property_values = {
+        "conductivity": 58000000,
+        "dielectric_loss_tangent": 0,
+        "magnetic_loss_tangent": 0,
+        "mass_density": 8933,
+        "permittivity": 1,
+        "permeability": 0.999991,
+        "poisson_ratio": 0.38,
+        "specific_heat": 385,
+        "thermal_conductivity": 400,
+        "youngs_modulus": 120000000000,
+        "thermal_expansion_coefficient": 1.77e-05,
+    }
+    default_dielectric_property_values = {
+        "conductivity": 0,
+        "dielectric_loss_tangent": 0.02,
+        "magnetic_loss_tangent": 0,
+        "mass_density": 1900,
+        "permittivity": 4.4,
+        "permeability": 1,
+        "poisson_ratio": 0.28,
+        "specific_heat": 1150,
+        "thermal_conductivity": 0.294,
+        "youngs_modulus": 11000000000,
+        "thermal_expansion_coefficient": 1.5e-05,
+    }
+
     def __init__(self, edb: Edb):
         self.__edb = edb
         self.__syslib = os.path.join(self.__edb.base_path, "syslib")

pyedb/grpc/database/definition/package_def.py

@@ -26,6 +26,7 @@ from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.edb_logger import pyedb_logger
 from pyedb.grpc.database.utility.heat_sink import HeatSink
+from pyedb.misc.misc import deprecated_property
 
 
 class PackageDef(GrpcPackageDef):
@@ -45,6 +46,11 @@ class PackageDef(GrpcPackageDef):
     """
 
     def __init__(self, pedb, edb_object=None, name=None, component_part_name=None, extent_bounding_box=None):
+        if not edb_object:
+            if name:
+                edb_object = GrpcPackageDef.create(db=pedb.active_db, name=name)
+            else:
+                raise AttributeError("Name must be provided to create and instantiate a PackageDef object.")
         super(GrpcPackageDef, self).__init__(edb_object.msg)
         self._pedb = pedb
         self._edb_object = edb_object
@@ -129,7 +135,6 @@ class PackageDef(GrpcPackageDef):
 
     @therm_cond.setter
     def therm_cond(self, value):
-        self.therm_cond = GrpcValue(value)
         super(PackageDef, self.__class__).thermal_conductivity.__set__(self, GrpcValue(value))
 
     @property
@@ -186,7 +191,20 @@ class PackageDef(GrpcPackageDef):
         :class:`HeatSink <pyedb.grpc.database.utility.heat_sink.HeatSink>`
             HeatSink object.
         """
-        return HeatSink(self._pedb, super().heat_sink)
+        try:
+            return HeatSink(self._pedb, super().heat_sink)
+        except:
+            pass
+
+    @property
+    @deprecated_property
+    def heatsink(self):
+        """Property added for .NET compatibility.
+        . deprecated:: pyedb 0.43.0
+        Use :func:`heat_sink` instead.
+
+        """
+        return self.heat_sink
 
     def set_heatsink(self, fin_base_height, fin_height, fin_orientation, fin_spacing, fin_thickness):
         """Set Heat sink.

pyedb/grpc/database/definition/padstack_def.py

@@ -34,7 +34,7 @@ import ansys.edb.core.geometry.polygon_data
 from ansys.edb.core.geometry.polygon_data import PolygonData as GrpcPolygonData
 from ansys.edb.core.hierarchy.structure3d import MeshClosure as GrpcMeshClosure
 from ansys.edb.core.hierarchy.structure3d import Structure3D as GrpcStructure3D
-from ansys.edb.core.primitive.primitive import Circle as GrpcCircle
+from ansys.edb.core.primitive.circle import Circle as GrpcCircle
 from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.generic.general_methods import generate_unique_name
@@ -577,7 +577,10 @@ class PadstackDef(GrpcPadstackDef):
             Possible returned values are ``"through"``, ``"begin_on_upper_pad"``,
             ``"end_on_lower_pad"``, ``"upper_pad_to_lower_pad"``, and ``"undefined"``.
         """
-        return self.data.hole_range.name.lower()
+        try:
+            return self.data.hole_range.name.lower()
+        except:
+            return None
 
     @hole_range.setter
     def hole_range(self, value):

pyedb/grpc/database/hierarchy/component.py

@@ -42,8 +42,10 @@ from ansys.edb.core.hierarchy.sparameter_model import (
     SParameterModel as GrpcSParameterModel,
 )
 from ansys.edb.core.hierarchy.spice_model import SPICEModel as GrpcSPICEModel
-from ansys.edb.core.primitive.primitive import PadstackInstance as GrpcPadstackInstance
-from ansys.edb.core.terminal.terminals import (
+from ansys.edb.core.primitive.padstack_instance import (
+    PadstackInstance as GrpcPadstackInstance,
+)
+from ansys.edb.core.terminal.padstack_instance_terminal import (
     PadstackInstanceTerminal as GrpcPadstackInstanceTerminal,
 )
 from ansys.edb.core.utility.rlc import Rlc as GrpcRlc

pyedb/grpc/database/hierarchy/pingroup.py

@@ -22,7 +22,7 @@
 
 
 from ansys.edb.core.hierarchy.pin_group import PinGroup as GrpcPinGroup
-from ansys.edb.core.terminal.terminals import BoundaryType as GrpcBoundaryType
+from ansys.edb.core.terminal.terminal import BoundaryType as GrpcBoundaryType
 from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.generic.general_methods import generate_unique_name
@@ -74,9 +74,9 @@ class PinGroup(GrpcPinGroup):
 
         Returns
         -------
-        List[:class:`PadstackInstance <pyedb.grpc.database.primitive.padstack_instance.PadstackInstance>`].
+        Dict[:class:`PadstackInstance <pyedb.grpc.database.primitive.padstack_instance.PadstackInstance>`].
         """
-        return [PadstackInstance(self._pedb, i) for i in super().pins]
+        return {i.name: PadstackInstance(self._pedb, i) for i in super().pins}
 
     @property
     def net(self):
@@ -105,11 +105,15 @@ class PinGroup(GrpcPinGroup):
         """
         return self.net.name
 
-    # @property
-    # def terminal(self):
-    #     """Terminal."""
-    #     term = PinGroupTerminal(self._pedb, self.get_pin_group_terminal())  # TODO check method is missing
-    #     return term if not term.is_null else None
+    @property
+    def terminal(self):
+        """Terminal."""
+        term = self.pin_group_terminal
+        if not term.is_null:
+            term = PinGroupTerminal(self._pedb, term)
+            return term
+        else:
+            return None
 
     def create_terminal(self, name=None):
         """Create a terminal.

pyedb/grpc/database/layers/layer.py

@@ -52,6 +52,34 @@ class Layer(GrpcLayer):
             else:
                 self._pedb.logger.error(f"{k} is not a valid layer attribute")
 
+    @property
+    def properties(self):
+        from ansys.edb.core.layer.stackup_layer import StackupLayer as GrpcStackupLayer
+
+        from pyedb.grpc.database.stackup import StackupLayer
+
+        if isinstance(self.cast(), GrpcStackupLayer):
+            return StackupLayer(self._pedb, self.cast()).properties
+        else:
+            data = {"name": self.name, "type": self.type, "color": self.color}
+            return data
+
+    @properties.setter
+    def properties(self, params):
+        name = params.get("name", "")
+        if name:
+            self.name = name
+        type = params.get("type", "")
+        if type:
+            self.type = type
+        color = params.get("color", "")
+        if color:
+            self.color = color
+
+    @property
+    def type(self):
+        return super().type.name.lower().split("_")[0]
+
     @property
     def _layer_name_mapping_reversed(self):
         return {j: i for i, j in self._layer_name_mapping.items()}

pyedb/grpc/database/layers/stackup_layer.py

@@ -56,13 +56,77 @@ class StackupLayer(GrpcStackupLayer):
         str
             Layer name.
         """
-        return super().type.name.lower()
+        return super().type.name.lower().split("_")[0]
 
     @type.setter
     def type(self, value):
         if value in self._stackup_layer_mapping:
             super(StackupLayer, self.__class__).type.__set__(self, self._stackup_layer_mapping[value])
 
+    def update(self, **kwargs):
+        for k, v in kwargs.items():
+            if k in dir(self):
+                self.__setattr__(k, v)
+            elif k == "roughness":
+                self.roughness_enabled = v["enabled"]
+                if "top" in v:
+                    top_roughness = v["top"]
+                    if top_roughness:
+                        if top_roughness["model"] == "huray":
+                            nodule_radius = top_roughness["nodule_radius"]
+                            surface_ratio = top_roughness["surface_ratio"]
+                            self.assign_roughness_model(
+                                model_type="huray",
+                                huray_radius=nodule_radius,
+                                huray_surface_ratio=surface_ratio,
+                                apply_on_surface="top",
+                            )
+                        elif top_roughness["model"] == "groisse":
+                            roughness = top_roughness["roughness"]
+                            self.assign_roughness_model(
+                                model_type="groisse", groisse_roughness=roughness, apply_on_surface="top"
+                            )
+                    if "bottom" in v:
+                        bottom_roughness = v["bottom"]
+                        if bottom_roughness:
+                            if bottom_roughness["model"] == "huray":
+                                nodule_radius = bottom_roughness["nodule_radius"]
+                                surface_ratio = bottom_roughness["surface_ratio"]
+                                self.assign_roughness_model(
+                                    model_type="huray",
+                                    huray_radius=nodule_radius,
+                                    huray_surface_ratio=surface_ratio,
+                                    apply_on_surface="bottom",
+                                )
+                            elif bottom_roughness["model"] == "groisse":
+                                roughness = bottom_roughness["roughness"]
+                                self.assign_roughness_model(
+                                    model_type="groisse", groisse_roughness=roughness, apply_on_surface="bottom"
+                                )
+                    if "side" in v:
+                        side_roughness = v["side"]
+                        if side_roughness:
+                            if side_roughness["model"] == "huray":
+                                nodule_radius = side_roughness["nodule_radius"]
+                                surface_ratio = side_roughness["surface_ratio"]
+                                self.assign_roughness_model(
+                                    model_type="huray",
+                                    huray_radius=nodule_radius,
+                                    huray_surface_ratio=surface_ratio,
+                                    apply_on_surface="side",
+                                )
+                            elif side_roughness["model"] == "groisse":
+                                roughness = side_roughness["roughness"]
+                                self.assign_roughness_model(
+                                    model_type="groisse", groisse_roughness=roughness, apply_on_surface="side"
+                                )
+
+            elif k == "etching":
+                self.etch_factor_enabled = v["enabled"]
+                self.etch_factor = float(v["factor"])
+            else:
+                self._pedb.logger.error(f"{k} is not a valid layer attribute")
+
     def _create(self, layer_type):
         if layer_type in self._stackup_layer_mapping:
             layer_type = self._stackup_layer_mapping[layer_type]
@@ -99,12 +163,12 @@ class StackupLayer(GrpcStackupLayer):
         str
             Material name.
         """
-        if self.is_stackup_layer:
+        if self.type == "signal":
             return self.get_fill_material()
 
     @fill_material.setter
     def fill_material(self, value):
-        if self.is_stackup_layer:
+        if self.type == "signal":
             self.set_fill_material(value)
 
     @property
@@ -258,16 +322,24 @@ class StackupLayer(GrpcStackupLayer):
         float
             Nodule radius value.
         """
-        top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
-        if top_roughness_model:
-            return top_roughness_model.nodule_radius.value
-        else:
+        try:
+            top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
+            if len(top_roughness_model) == 2:
+                return top_roughness_model[0].value
+            else:
+                return None
+        except:
             return None
 
     @top_hallhuray_nodule_radius.setter
     def top_hallhuray_nodule_radius(self, value):
-        top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
-        top_roughness_model.nodule_radius = GrpcValue(value)
+        try:
+            top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
+            if len(top_roughness_model) == 2:
+                top_roughness_model[0] = GrpcValue(value)
+                self.set_roughness_model(top_roughness_model, GrpcRoughnessRegion.TOP)
+        except:
+            pass
 
     @property
     def top_hallhuray_surface_ratio(self):
@@ -278,16 +350,24 @@ class StackupLayer(GrpcStackupLayer):
         float
             Surface ratio.
         """
-        top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
-        if top_roughness_model:
-            return top_roughness_model.surface_ratio.value
-        else:
+        try:
+            top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
+            if len(top_roughness_model) == 2:
+                return top_roughness_model[1].value
+            else:
+                return None
+        except:
             return None
 
     @top_hallhuray_surface_ratio.setter
     def top_hallhuray_surface_ratio(self, value):
-        top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
-        top_roughness_model.surface_roughness = GrpcValue(value)
+        try:
+            top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
+            if len(top_roughness_model) == 2:
+                top_roughness_model[1] = GrpcValue(value)
+                self.set_roughness_model(top_roughness_model, GrpcRoughnessRegion.TOP)
+        except:
+            pass
 
     @property
     def bottom_hallhuray_nodule_radius(self):
@@ -298,15 +378,24 @@ class StackupLayer(GrpcStackupLayer):
         float
             Nodule radius.
         """
-        bottom_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
-        if bottom_roughness_model:
-            return bottom_roughness_model.nodule_radius.value
-        return None
+        try:
+            bottom_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
+            if len(bottom_roughness_model) == 2:
+                return round(bottom_roughness_model[0].value, 9)
+            else:
+                return None
+        except:
+            return None
 
     @bottom_hallhuray_nodule_radius.setter
     def bottom_hallhuray_nodule_radius(self, value):
-        top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
-        top_roughness_model.nodule_radius = GrpcValue(value)
+        try:
+            bottom_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
+            if len(bottom_roughness_model) == 2:
+                bottom_roughness_model[0] = GrpcValue(value)
+                self.set_roughness_model(bottom_roughness_model, GrpcRoughnessRegion.BOTTOM)
+        except:
+            pass
 
     @property
     def bottom_hallhuray_surface_ratio(self):
@@ -317,15 +406,24 @@ class StackupLayer(GrpcStackupLayer):
         float
             Surface ratio value.
         """
-        bottom_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
-        if bottom_roughness_model:
-            return bottom_roughness_model.surface_ratio.value
-        return None
+        try:
+            bottom_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
+            if len(bottom_roughness_model) == 2:
+                return bottom_roughness_model[1].value
+            else:
+                return None
+        except:
+            return None
 
     @bottom_hallhuray_surface_ratio.setter
     def bottom_hallhuray_surface_ratio(self, value):
-        top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
-        top_roughness_model.surface_ratio = GrpcValue(value)
+        try:
+            bottom_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
+            if len(bottom_roughness_model) == 2:
+                bottom_roughness_model[1] = GrpcValue(value)
+                self.set_roughness_model(bottom_roughness_model, GrpcRoughnessRegion.BOTTOM)
+        except:
+            pass
 
     @property
     def side_hallhuray_nodule_radius(self):
@@ -337,15 +435,23 @@ class StackupLayer(GrpcStackupLayer):
             Nodule radius value.
 
         """
-        side_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
-        if side_roughness_model:
-            return side_roughness_model.nodule_radius.value
-        return None
+        try:
+            side_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
+            if len(side_roughness_model) == 2:
+                return round(side_roughness_model[0].value, 9)
+            return None
+        except:
+            return None
 
     @side_hallhuray_nodule_radius.setter
     def side_hallhuray_nodule_radius(self, value):
-        top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
-        top_roughness_model.nodule_radius = GrpcValue(value)
+        try:
+            side_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
+            if len(side_roughness_model) == 2:
+                side_roughness_model[0] = GrpcValue(value)
+                self.set_roughness_model(side_roughness_model, GrpcRoughnessRegion.SIDE)
+        except:
+            pass
 
     @property
     def side_hallhuray_surface_ratio(self):
@@ -356,16 +462,107 @@ class StackupLayer(GrpcStackupLayer):
         float
             surface ratio.
         """
-        side_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
-        if side_roughness_model:
-            return side_roughness_model.surface_ratio.value
-        else:
+        try:
+            side_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
+            if len(side_roughness_model) == 2:
+                return side_roughness_model[1].value
+            return None
+        except:
             return None
 
     @side_hallhuray_surface_ratio.setter
     def side_hallhuray_surface_ratio(self, value):
-        top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
-        top_roughness_model.surface_ratio = GrpcValue(value)
+        try:
+            side_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
+            if len(side_roughness_model) == 2:
+                side_roughness_model[1] = GrpcValue(value)
+                self.set_roughness_model(side_roughness_model, GrpcRoughnessRegion.SIDE)
+        except:
+            pass
+
+    @property
+    def top_groisse_roughness(self):
+        """Groisse model on layer top.
+
+        Returns
+        -------
+        float
+            Roughness value.
+        """
+        try:
+            top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
+            if isinstance(top_roughness_model, GrpcValue):
+                return top_roughness_model.value
+            else:
+                return None
+        except:
+            return None
+
+    @top_groisse_roughness.setter
+    def top_groisse_roughness(self, value):
+        try:
+            top_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.TOP)
+            if isinstance(top_roughness_model, GrpcValue):
+                top_roughness_model = GrpcValue(value)
+                self.set_roughness_model(top_roughness_model, GrpcRoughnessRegion.TOP)
+        except:
+            pass
+
+    @property
+    def bottom_groisse_roughness(self):
+        """Groisse model on layer bottom.
+
+        Returns
+        -------
+        float
+            Roughness value.
+        """
+        try:
+            bottom_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
+            if isinstance(bottom_roughness_model, GrpcValue):
+                return bottom_roughness_model.value
+            else:
+                return None
+        except:
+            return None
+
+    @bottom_groisse_roughness.setter
+    def bottom_groisse_roughness(self, value):
+        try:
+            bottom_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
+            if isinstance(bottom_roughness_model, GrpcValue):
+                bottom_roughness_model = GrpcValue(value)
+                self.set_roughness_model(bottom_roughness_model, GrpcRoughnessRegion.BOTTOM)
+        except:
+            pass
+
+    @property
+    def side_groisse_roughness(self):
+        """Groisse model on layer bottom.
+
+        Returns
+        -------
+        float
+            Roughness value.
+        """
+        try:
+            side_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
+            if isinstance(side_roughness_model, GrpcValue):
+                return side_roughness_model.value
+            else:
+                return None
+        except:
+            return None
+
+    @side_groisse_roughness.setter
+    def side_groisse_roughness(self, value):
+        try:
+            side_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.BOTTOM)
+            if isinstance(side_roughness_model, GrpcValue):
+                side_roughness_model = GrpcValue(value)
+                self.set_roughness_model(side_roughness_model, GrpcRoughnessRegion.BOTTOM)
+        except Exception as e:
+            self._pedb.logger.error(e)
 
     def assign_roughness_model(
         self,
@@ -400,7 +597,7 @@ class StackupLayer(GrpcStackupLayer):
         elif apply_on_surface == "bottom":
             regions = [GrpcRoughnessRegion.BOTTOM]
         elif apply_on_surface == "side":
-            regions = [GrpcRoughnessRegion.BOTTOM]
+            regions = [GrpcRoughnessRegion.SIDE]
         self.roughness_enabled = True
         for r in regions:
             if model_type == "huray":
@@ -408,3 +605,47 @@ class StackupLayer(GrpcStackupLayer):
             else:
                 model = GrpcValue(groisse_roughness)
             self.set_roughness_model(model, r)
+
+    @property
+    def properties(self):
+        data = {"name": self.name, "type": self.type, "color": self.color}
+        if self.type == "signal" or self.type == "dielectric":
+            data["material"] = self.material
+            data["thickness"] = self.thickness
+        if self.type == "signal":
+            data["fill_material"] = self.fill_material
+        roughness = {"top": {}, "bottom": {}, "side": {}}
+        if self.top_hallhuray_nodule_radius:
+            roughness["top"]["model"] = "huray"
+            roughness["top"]["nodule_radius"] = self.top_hallhuray_nodule_radius
+            roughness["top"]["surface_ratio"] = self.top_hallhuray_surface_ratio
+
+        elif self.top_groisse_roughness:
+            roughness["top"]["model"] = "groisse"
+            roughness["top"]["roughness"] = self.top_groisse_roughness
+
+        if self.bottom_hallhuray_nodule_radius:
+            roughness["bottom"]["model"] = "huray"
+            roughness["bottom"]["nodule_radius"] = self.bottom_hallhuray_nodule_radius
+            roughness["bottom"]["surface_ratio"] = self.bottom_hallhuray_surface_ratio
+
+        elif self.bottom_groisse_roughness:
+            roughness["bottom"]["model"] = "groisse"
+            roughness["bottom"]["roughness"] = self.bottom_groisse_roughness
+
+        if self.side_hallhuray_nodule_radius:
+            roughness["side"]["model"] = "huray"
+            roughness["side"]["nodule_radius"] = self.side_hallhuray_nodule_radius
+            roughness["side"]["surface_ratio"] = self.side_hallhuray_surface_ratio
+
+        elif self.side_groisse_roughness:
+            roughness["side"]["model"] = "groisse"
+            roughness["side"]["roughness"] = self.side_groisse_roughness
+
+        if roughness["top"] or roughness["bottom"] or roughness["side"]:
+            roughness["enabled"] = True
+        else:
+            roughness["enabled"] = False
+        data["roughness"] = roughness
+        data["etching"] = {"enabled": self.etch_factor_enabled, "factor": self.etch_factor}
+        return data