pyedb 0.48.0__py3-none-any.whl → 0.50.0__py3-none-any.whl

pyedb/grpc/database/layers/stackup_layer.py

@@ -204,6 +204,18 @@ class StackupLayer(GrpcStackupLayer):
         """
         self.negative = value
 
+    @property
+    def is_stackup_layer(self):
+        """Testing if layer is stackup layer.
+
+        Returns
+        -------
+        `True` if layer type is "signal" or "dielectric".
+        """
+        if self.type in ["signal", "dielectric", "via", "wirebond"]:
+            return True
+        return False
+
     @property
     def material(self):
         """Material.
@@ -229,7 +241,8 @@ class StackupLayer(GrpcStackupLayer):
             Material conductivity value.
         """
         if self.material in self._pedb.materials.materials:
-            return self._pedb.materials[self.material].conductivity
+            condcutivity = self._pedb.materials[self.material].conductivity
+            return condcutivity if condcutivity else 0.0
         return None
 
     @property
@@ -242,7 +255,8 @@ class StackupLayer(GrpcStackupLayer):
             Material permittivity value.
         """
         if self.material in self._pedb.materials.materials:
-            return self._pedb.materials[self.material].permittivity
+            permittivity = self._pedb.materials[self.material].permittivity
+            return permittivity if permittivity else 0.0
         return None
 
     @property
@@ -255,7 +269,8 @@ class StackupLayer(GrpcStackupLayer):
             Material loss tangent value.
         """
         if self.material in self._pedb.materials.materials:
-            return self._pedb.materials[self.material].loss_tangent
+            loss_tangent = self._pedb.materials[self.material].loss_tangent
+            return loss_tangent if loss_tangent else 0.0
         return None
 
     @property
@@ -270,7 +285,7 @@ class StackupLayer(GrpcStackupLayer):
         if self.type == "signal":
             return self.get_fill_material()
         else:
-            return
+            return None
 
     @dielectric_fill.setter
     def dielectric_fill(self, name):
@@ -327,9 +342,9 @@ class StackupLayer(GrpcStackupLayer):
             if len(top_roughness_model) == 2:
                 return top_roughness_model[0].value
             else:
-                return None
+                return 0.0
         except:
-            return None
+            return 0.0
 
     @top_hallhuray_nodule_radius.setter
     def top_hallhuray_nodule_radius(self, value):
@@ -355,9 +370,9 @@ class StackupLayer(GrpcStackupLayer):
             if len(top_roughness_model) == 2:
                 return top_roughness_model[1].value
             else:
-                return None
+                return 0.0
         except:
-            return None
+            return 0.0
 
     @top_hallhuray_surface_ratio.setter
     def top_hallhuray_surface_ratio(self, value):
@@ -383,9 +398,9 @@ class StackupLayer(GrpcStackupLayer):
             if len(bottom_roughness_model) == 2:
                 return round(bottom_roughness_model[0].value, 9)
             else:
-                return None
+                return 0.0
         except:
-            return None
+            return 0.0
 
     @bottom_hallhuray_nodule_radius.setter
     def bottom_hallhuray_nodule_radius(self, value):
@@ -411,9 +426,9 @@ class StackupLayer(GrpcStackupLayer):
             if len(bottom_roughness_model) == 2:
                 return bottom_roughness_model[1].value
             else:
-                return None
+                return 0.0
         except:
-            return None
+            return 0.0
 
     @bottom_hallhuray_surface_ratio.setter
     def bottom_hallhuray_surface_ratio(self, value):
@@ -439,9 +454,9 @@ class StackupLayer(GrpcStackupLayer):
             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
+            return 0.0
         except:
-            return None
+            return 0.0
 
     @side_hallhuray_nodule_radius.setter
     def side_hallhuray_nodule_radius(self, value):
@@ -466,9 +481,9 @@ class StackupLayer(GrpcStackupLayer):
             side_roughness_model = self.get_roughness_model(GrpcRoughnessRegion.SIDE)
             if len(side_roughness_model) == 2:
                 return side_roughness_model[1].value
-            return None
+            return 0.0
         except:
-            return None
+            return 0.0
 
     @side_hallhuray_surface_ratio.setter
     def side_hallhuray_surface_ratio(self, value):
@@ -494,9 +509,9 @@ class StackupLayer(GrpcStackupLayer):
             if isinstance(top_roughness_model, GrpcValue):
                 return top_roughness_model.value
             else:
-                return None
+                return 0.0
         except:
-            return None
+            return 0.0
 
     @top_groisse_roughness.setter
     def top_groisse_roughness(self, value):
@@ -522,9 +537,9 @@ class StackupLayer(GrpcStackupLayer):
             if isinstance(bottom_roughness_model, GrpcValue):
                 return bottom_roughness_model.value
             else:
-                return None
+                return 0.0
         except:
-            return None
+            return 0.0
 
     @bottom_groisse_roughness.setter
     def bottom_groisse_roughness(self, value):
@@ -550,9 +565,9 @@ class StackupLayer(GrpcStackupLayer):
             if isinstance(side_roughness_model, GrpcValue):
                 return side_roughness_model.value
             else:
-                return None
+                return 0.0
         except:
-            return None
+            return 0.0
 
     @side_groisse_roughness.setter
     def side_groisse_roughness(self, value):
@@ -605,6 +620,13 @@ class StackupLayer(GrpcStackupLayer):
             else:
                 model = GrpcValue(groisse_roughness)
             self.set_roughness_model(model, r)
+        if [
+            self.get_roughness_model(GrpcRoughnessRegion.TOP),
+            self.get_roughness_model(GrpcRoughnessRegion.BOTTOM),
+            self.get_roughness_model(GrpcRoughnessRegion.SIDE),
+        ]:
+            return True
+        return False
 
     @property
     def properties(self):
@@ -649,3 +671,78 @@ class StackupLayer(GrpcStackupLayer):
         data["roughness"] = roughness
         data["etching"] = {"enabled": self.etch_factor_enabled, "factor": self.etch_factor}
         return data
+
+    def _json_format(self):
+        dict_out = {
+            "color": self.color,
+            "dielectric_fill": self.dielectric_fill,
+            "etch_factor": self.etch_factor,
+            "material": self.material,
+            "loss_tangent": self.loss_tangent,
+            "permittivity": self.permittivity,
+            "conductivity": self.conductivity,
+            "zones": self.zones,
+            "transparency": self.transparency,
+            "name": self.name,
+            "roughness_enabled": self.roughness_enabled,
+            "thickness": self.thickness,
+            "lower_elevation": self.lower_elevation,
+            "upper_elevation": self.upper_elevation,
+            "type": self.type,
+            "top_hallhuray_nodule_radius": self.top_hallhuray_nodule_radius,
+            "top_hallhuray_surface_ratio": self.top_hallhuray_surface_ratio,
+            "side_hallhuray_nodule_radius": self.side_hallhuray_nodule_radius,
+            "side_hallhuray_surface_ratio": self.side_hallhuray_surface_ratio,
+            "bottom_hallhuray_nodule_radius": self.bottom_hallhuray_nodule_radius,
+            "bottom_hallhuray_surface_ratio": self.bottom_hallhuray_surface_ratio,
+        }
+        return dict_out
+
+    def _load_layer(self, layer):
+        if layer:
+            self.color = layer["color"]
+            self.type = layer["type"]
+            if isinstance(layer["material"], str):
+                self.material = layer["material"]
+            else:
+                material_data = layer["material"]
+                if material_data is not None:
+                    material_name = layer["material"]["name"]
+                    self._pedb.materials.add_material(material_name, **material_data)
+                    self.material = material_name
+            if layer["dielectric_fill"]:
+                if isinstance(layer["dielectric_fill"], str):
+                    self.dielectric_fill = layer["dielectric_fill"]
+                else:
+                    dielectric_data = layer["dielectric_fill"]
+                    if dielectric_data is not None:
+                        self._pedb.materials.add_material(**dielectric_data)
+                    self.dielectric_fill = layer["dielectric_fill"]["name"]
+            self.thickness = layer["thickness"]
+            self.etch_factor = layer["etch_factor"]
+            self.roughness_enabled = layer["roughness_enabled"]
+            if self.roughness_enabled:
+                self.top_hallhuray_nodule_radius = layer["top_hallhuray_nodule_radius"]
+                self.top_hallhuray_surface_ratio = layer["top_hallhuray_surface_ratio"]
+                self.assign_roughness_model(
+                    "huray",
+                    layer["top_hallhuray_nodule_radius"],
+                    layer["top_hallhuray_surface_ratio"],
+                    apply_on_surface="top",
+                )
+                self.bottom_hallhuray_nodule_radius = layer["bottom_hallhuray_nodule_radius"]
+                self.bottom_hallhuray_surface_ratio = layer["bottom_hallhuray_surface_ratio"]
+                self.assign_roughness_model(
+                    "huray",
+                    layer["bottom_hallhuray_nodule_radius"],
+                    layer["bottom_hallhuray_surface_ratio"],
+                    apply_on_surface="bottom",
+                )
+                self.side_hallhuray_nodule_radius = layer["side_hallhuray_nodule_radius"]
+                self.side_hallhuray_surface_ratio = layer["side_hallhuray_surface_ratio"]
+                self.assign_roughness_model(
+                    "huray",
+                    layer["side_hallhuray_nodule_radius"],
+                    layer["side_hallhuray_surface_ratio"],
+                    apply_on_surface="side",
+                )

pyedb/grpc/database/layout_validation.py

@@ -37,7 +37,7 @@ class LayoutValidation:
         self._pedb = pedb
         self._layout_instance = self._pedb.layout_instance
 
-    def dc_shorts(self, net_list=None, fix=False):
+    def dc_shorts(self, net_list=None, fix=False) -> list[list[str, str]]:
         """Find DC shorts on layout.
 
         Parameters
@@ -130,7 +130,7 @@ class LayoutValidation:
         clean_disjoints_less_than=0.0,
         order_by_area=False,
         keep_disjoint_pins=False,
-    ):
+    ) -> list[str]:
         """Find and fix disjoint nets from a given netlist.
 
         Parameters
@@ -263,7 +263,7 @@ class LayoutValidation:
 
         return new_nets
 
-    def fix_self_intersections(self, net_list=None):
+    def fix_self_intersections(self, net_list=None) -> bool:
         """Find and fix self intersections from a given netlist.
 
         Parameters
@@ -306,7 +306,7 @@ class LayoutValidation:
         self._pedb._logger.info("Found {} illegal net names.".format(len(renamed_nets)))
         return
 
-    def illegal_rlc_values(self, fix=False):
+    def illegal_rlc_values(self, fix=False) -> list[str]:
         """Find and fix RLC illegal values."""
         inductors = self._pedb.components.inductors
 
@@ -318,7 +318,7 @@ class LayoutValidation:
                 if fix:
                     v.rlc_values = [0, 1, 0]
         self._pedb._logger.info(f"Found {len(temp)} inductors have no value.")
-        return
+        return temp
 
     def padstacks_no_name(self, fix=False):
         pds = self._pedb.layout.padstack_instances

pyedb/grpc/database/primitive/path.py

@@ -62,7 +62,7 @@ class Path(GrpcPath, Primitive):
         """
         center_line_arcs = self._edb_object.cast().center_line.arc_data
         path_length = 0.0
-        for arc in center_line_arcs[: int(len(center_line_arcs) / 2)]:
+        for arc in center_line_arcs:
             path_length += arc.length
         end_cap_style = self.get_end_cap_style()
         if end_cap_style:

pyedb/grpc/database/source_excitations.py

@@ -154,6 +154,45 @@ class SourceExcitation:
                 )
         return True
 
+    def create_port(self, terminal, ref_terminal=None, is_circuit_port=False, name=None):
+        """Create a port.
+
+        Parameters
+        ----------
+        terminal : class:`pyedb.dotnet.database.edb_data.terminals.EdgeTerminal`,
+            class:`pyedb.grpc.database.terminals.PadstackInstanceTerminal`,
+            class:`pyedb.grpc.database.terminals.PointTerminal`,
+            class:`pyedb.grpc.database.terminals.PinGroupTerminal`,
+            Positive terminal of the port.
+        ref_terminal : class:`pyedb.grpc.database.terminals.EdgeTerminal`,
+            class:`pyedb.grpc.database.terminals.PadstackInstanceTerminal`,
+            class:`pyedb.grpc.database.terminals.PointTerminal`,
+            class:`pyedb.grpc.database.terminals.PinGroupTerminal`,
+            optional
+            Negative terminal of the port.
+        is_circuit_port : bool, optional
+            Whether it is a circuit port. The default is ``False``.
+        name: str, optional
+            Name of the created port. The default is None, a random name is generated.
+        Returns
+        -------
+        list: [:class:`GapPort <pyedb.grpc.database.ports.ports.GapPort`>,
+            :class:`WavePort <pyedb.grpc.database.ports.ports.WavePort>`].
+        """
+
+        from ansys.edb.core.terminal.terminal import BoundaryType as GrpcBoundaryType
+
+        if terminal.boundary_type == "port":
+            terminal.boundary_type = GrpcBoundaryType.PORT
+        terminal.is_circuit_port = is_circuit_port
+        if ref_terminal:
+            if ref_terminal.boundary_type == "port":
+                ref_terminal.boundary_type = GrpcBoundaryType.PORT
+            terminal.reference_terminal = ref_terminal
+        if name:
+            terminal.name = name
+        return self._pedb.ports[terminal.name]
+
     def create_port_on_pins(
         self,
         refdes,
@@ -2098,6 +2137,30 @@ class SourceExcitation:
         terms = [term for term in self._pedb.layout.terminals]
         return len([i for i in terms if not i.is_reference_terminal])
 
+    def get_point_terminal(self, name, net_name, location, layer) -> PointTerminal:
+        """Place terminal between two points.
+
+        Parameters
+        ----------
+        name : str,
+            Name of the terminal.
+        net_name : str
+            Name of the net.
+        location : list
+            Location of the terminal.
+        layer : str,
+            Layer of the terminal.
+
+        Returns
+        -------
+        :class:`PointTerminal <pyedb.grpc.database.terminal.point_terminal.PointTerminal>`
+        """
+        from pyedb.grpc.database.terminal.point_terminal import PointTerminal
+
+        return PointTerminal.create(
+            layout=self._pedb.active_layout, name=name, net=net_name, layer=layer, point=location
+        )
+
     def create_rlc_boundary_on_pins(self, positive_pin=None, negative_pin=None, rvalue=0.0, lvalue=0.0, cvalue=0.0):
         """Create hfss rlc boundary on pins.
 
@@ -2328,6 +2391,37 @@ class SourceExcitation:
                     return terms
             return False
 
+    def create_current_source(self, terminal, ref_terminal):
+        """Create a current source.
+
+        Parameters
+        ----------
+        terminal : :class:`EdgeTerminal <pyedb.grpc.database.terminals.EdgeTerminal>`,
+            :class:`PadstackInstanceTerminal <pyedb.grpc.database.terminals.PadstackInstanceTerminal>`,
+            :class:`PointTerminal <pyedb.grpc.database.terminals.PointTerminal>`,
+            :class:`PinGroupTerminal <pyedb.grpc.database.terminals.PinGroupTerminal>`,
+            Positive terminal of the source.
+        ref_terminal : :class:`EdgeTerminal <pyedb.grpc.database.terminals.EdgeTerminal>`,
+            :class:`pyedb.grpc.database.terminals.PadstackInstanceTerminal`,
+            :class:`PadstackInstanceTerminal <pyedb.grpc.database.terminals.PointTerminal>`,
+            :class:`PinGroupTerminal <pyedb.grpc.database.terminals.PinGroupTerminal>`,
+            Negative terminal of the source.
+
+        Returns
+        -------
+        :class:`ExcitationSources <legacy.database.edb_data.ports.ExcitationSources>`
+        """
+        from pyedb.grpc.database.terminal.terminal import Terminal
+
+        term = Terminal(self._pedb, terminal)
+        term.boundary_type = "current_source"
+
+        ref_term = Terminal(self._pedb, ref_terminal)
+        ref_term.boundary_type = "current_source"
+
+        term.ref_terminal = ref_terminal
+        return term
+
     def create_current_source_on_pin_group(
         self, pos_pin_group_name, neg_pin_group_name, magnitude=1, phase=0, name=None
     ):
@@ -2368,6 +2462,37 @@ class SourceExcitation:
         pos_terminal.reference_terminal = neg_terminal
         return True
 
+    def create_voltage_source(self, terminal, ref_terminal):
+        """Create a voltage source.
+
+        Parameters
+        ----------
+        terminal : :class:`EdgeTerminal <pyedb.grpc.database.terminals.EdgeTerminal>`,
+            :class:`PadstackInstanceTerminal <pyedb.grpc.database.terminals.PadstackInstanceTerminal>`,
+            :class:`PointTerminal <pyedb.grpc.database.terminals.PointTerminal>`,
+            :class:`PinGroupTerminal <pyedb.grpc.database.terminals.PinGroupTerminal>`,
+            Positive terminal of the source.
+        ref_terminal : :class:`EdgeTerminal <pyedb.grpc.database.terminals.EdgeTerminal>`,
+            :class:`pyedb.grpc.database.terminals.PadstackInstanceTerminal`,
+            :class:`PadstackInstanceTerminal <pyedb.grpc.database.terminals.PointTerminal>`,
+            :class:`PinGroupTerminal <pyedb.grpc.database.terminals.PinGroupTerminal>`,
+            Negative terminal of the source.
+
+        Returns
+        -------
+        class:`ExcitationSources <legacy.database.edb_data.ports.ExcitationSources>`
+        """
+        from pyedb.grpc.database.terminal.terminal import Terminal
+
+        term = Terminal(self._pedb, terminal)
+        term.boundary_type = "voltage_source"
+
+        ref_term = Terminal(self._pedb, ref_terminal)
+        ref_term.boundary_type = "voltage_source"
+
+        term.ref_terminal = ref_terminal
+        return term
+
     def create_voltage_source_on_pin_group(
         self, pos_pin_group_name, neg_pin_group_name, magnitude=1, phase=0, name=None, impedance=0.001
     ):
@@ -2408,6 +2533,37 @@ class SourceExcitation:
         pos_terminal.reference_terminal = neg_terminal
         return True
 
+    def create_voltage_probe(self, terminal, ref_terminal):
+        """Create a voltage probe.
+
+        Parameters
+        ----------
+        terminal : :class:`EdgeTerminal <pyedb.grpc.database.terminals.EdgeTerminal>`,
+            :class:`PadstackInstanceTerminal <pyedb.grpc.database.terminals.PadstackInstanceTerminal>`,
+            :class:`PointTerminal <pyedb.grpc.database.terminals.PointTerminal>`,
+            :class:`PinGroupTerminal <pyedb.grpc.database.terminals.PinGroupTerminal>`,
+            Positive terminal of the port.
+        ref_terminal : :class:`EdgeTerminal <pyedb.grpc.database.terminals.EdgeTerminal>`,
+            :class:`pyedb.grpc.database.terminals.PadstackInstanceTerminal`,
+            :class:`PadstackInstanceTerminal <pyedb.grpc.database.terminals.PointTerminal>`,
+            :class:`PinGroupTerminal <pyedb.grpc.database.terminals.PinGroupTerminal>`,
+            Negative terminal of the probe.
+
+        Returns
+        -------
+        :class:`Terminal <pyedb.dotnet.database.edb_data.terminals.Terminal>`
+        """
+        from pyedb.grpc.database.terminal.terminal import Terminal
+
+        term = Terminal(self._pedb, terminal)
+        term.boundary_type = "voltage_probe"
+
+        ref_term = Terminal(self._pedb, ref_terminal)
+        ref_term.boundary_type = "voltage_probe"
+
+        term.ref_terminal = ref_terminal
+        return term
+
     def create_voltage_probe_on_pin_group(self, probe_name, pos_pin_group_name, neg_pin_group_name, impedance=1000000):
         """Create voltage probe between two pin groups.
 

pyedb/grpc/database/stackup.py

@@ -49,7 +49,6 @@ from ansys.edb.core.layer.layer_collection import LayerCollection as GrpcLayerCo
 from ansys.edb.core.layer.layer_collection import LayerTypeSet as GrpcLayerTypeSet
 from ansys.edb.core.layer.stackup_layer import StackupLayer as GrpcStackupLayer
 from ansys.edb.core.layout.mcad_model import McadModel as GrpcMcadModel
-from ansys.edb.core.utility.transform3d import Transform3D as GrpcTransform3D
 from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.generic.general_methods import ET, generate_unique_name
@@ -312,6 +311,14 @@ class Stackup(LayerCollection):
         super().__init__(pedb, edb_object)
         self._pedb = pedb
 
+    def __getitem__(self, item):
+        if item in self.non_stackup_layers:
+            return Layer(self._pedb, self.find_by_name(item))
+        elif item in self.layers:
+            return StackupLayer(self._pedb, self.find_by_name(item))
+        else:
+            return None
+
     @property
     def _logger(self):
         return self._pedb.logger
@@ -479,11 +486,16 @@ class Stackup(LayerCollection):
 
     @mode.setter
     def mode(self, value):
-        if value == 0 or value == GrpcLayerCollectionMode.LAMINATE or value == "laminate":
+        if value == 0 or value == GrpcLayerCollectionMode.LAMINATE or value == "laminate" or value == "Laminate":
             super(LayerCollection, self.__class__).mode.__set__(self, GrpcLayerCollectionMode.LAMINATE)
-        elif value == 1 or value == GrpcLayerCollectionMode.OVERLAPPING or value == "overlapping":
+        elif (
+            value == 1
+            or value == GrpcLayerCollectionMode.OVERLAPPING
+            or value == "overlapping"
+            or value == "Overlapping"
+        ):
             super(LayerCollection, self.__class__).mode.__set__(self, GrpcLayerCollectionMode.OVERLAPPING)
-        elif value == 2 or value == GrpcLayerCollectionMode.MULTIZONE or value == "multizone":
+        elif value == 2 or value == GrpcLayerCollectionMode.MULTIZONE or value == "multizone" or value == "MultiZone":
             super(LayerCollection, self.__class__).mode.__set__(self, GrpcLayerCollectionMode.MULTIZONE)
         self.update_layout()
 
@@ -696,6 +708,7 @@ class Stackup(LayerCollection):
         else:
             new_layer = self._create_nonstackup_layer(layer_name, layer_type)
             self._set_layout_stackup(new_layer, "non_stackup")
+            return self.non_stackup_layers[layer_name]
         return self.layers[layer_name]
 
     def remove_layer(self, name):
@@ -819,9 +832,6 @@ class Stackup(LayerCollection):
         layers_out = {}
         for k, v in self.layers.items():
             data = v._json_format()
-            # FIXME: Update the API to avoid providing following information to our users
-            del data["pedb"]
-            del data["edb_object"]
             layers_out[k] = data
             if v.material in self._pedb.materials.materials:
                 layer_material = self._pedb.materials.materials[v.material]
@@ -1039,10 +1049,14 @@ class Stackup(LayerCollection):
         return round(thickness, 7)
 
     def _get_solder_height(self, layer_name):
+        height = 0.0
         for _, val in self._pedb.components.instances.items():
-            if val.solder_ball_height and val.placement_layer == layer_name:
-                return val.solder_ball_height
-        return 0
+            try:
+                if val.solder_ball_height and val.placement_layer == layer_name:
+                    height = val.solder_ball_height
+            except:
+                pass
+        return height
 
     def _remove_solder_pec(self, layer_name):
         for _, val in self._pedb.components.instances.items():
@@ -1052,7 +1066,7 @@ class Stackup(LayerCollection):
                 port_property.reference_size_auto = False
                 port_property.reference_size = (GrpcValue(0.0), GrpcValue(0.0))
                 comp_prop.port_property = port_property
-                val.edbcomponent.component_property = comp_prop
+                val.component_property = comp_prop
 
     def adjust_solder_dielectrics(self):
         """Adjust the stack-up by adding or modifying dielectric layers that contains Solder Balls.
@@ -1260,7 +1274,7 @@ class Stackup(LayerCollection):
         _offset_y = GrpcValue(offset_y)
 
         if edb_cell.name not in self._pedb.cell_names:
-            list_cells = self._pedb.copy_cells(edb_cell.api_object)
+            list_cells = self._pedb.copy_cells(edb_cell)
             edb_cell = list_cells[0]
         self._pedb.layout.cell.is_blackbox = True
         cell_inst2 = GrpcCellInstance.create(
@@ -1271,9 +1285,9 @@ class Stackup(LayerCollection):
         stackup_source = self._pedb.layout.layer_collection
 
         if place_on_top:
-            cell_inst2.placement_layer = stackup_target.Layers(GrpcLayerTypeSet.SIGNAL_LAYER_SET)[0]
+            cell_inst2.placement_layer = list(LayerCollection(self._pedb, stackup_target).layers.values())[0]
         else:
-            cell_inst2.placement_layer = stackup_target.Layers(GrpcLayerTypeSet.SIGNAL_LAYER_SET)[-1]
+            cell_inst2.placement_layer = list(LayerCollection(self._pedb, stackup_target).layers.values())[-1]
         cell_inst2.placement_3d = True
         res = stackup_target.get_top_bottom_stackup_layers(GrpcLayerTypeSet.SIGNAL_LAYER_SET)
         target_top_elevation = res[1]
@@ -1301,7 +1315,13 @@ class Stackup(LayerCollection):
         point_loc = GrpcPoint3DData(zero_data, zero_data, zero_data)
         point_from = GrpcPoint3DData(one_data, zero_data, zero_data)
         point_to = GrpcPoint3DData(math.cos(_angle), -1 * math.sin(_angle), zero_data)
-        cell_inst2.transform3d = GrpcTransform3D(point_loc, point_from, point_to, rotation, point3d_t)  # TODO check
+        transform = cell_inst2.transform3d.create_from_one_axis_to_another(from_axis=point_from, to_axis=point_to)
+        cell_inst2.transform3d = transform
+        transform = cell_inst2.transform3d.create_from_axis_and_angle(axis=point_loc, angle=angle)
+        cell_inst2.transform3d = transform
+        transform = cell_inst2.transform3d.create_from_offset(offset=point3d_t)
+        cell_inst2.transform3d = transform
+        # TODO check if component is properly placed.
         return True
 
     def place_instance(
@@ -1392,7 +1412,7 @@ class Stackup(LayerCollection):
         _offset_y = GrpcValue(offset_y)
 
         if edb_cell.name not in self._pedb.cell_names:
-            list_cells = self._pedb.copy_cells(edb_cell.api_object)
+            list_cells = self._pedb.copy_cells(edb_cell)
             edb_cell = list_cells[0]
         for cell in self._pedb.active_db.top_circuit_cells:
             if cell.name == edb_cell.name:
@@ -1444,7 +1464,13 @@ class Stackup(LayerCollection):
         point_loc = GrpcPoint3DData(zero_data, zero_data, zero_data)
         point_from = GrpcPoint3DData(one_data, zero_data, zero_data)
         point_to = GrpcPoint3DData(math.cos(_angle), -1 * math.sin(_angle), zero_data)
-        cell_inst2.transform3d = (point_loc, point_from, point_to, rotation, point3d_t)  # TODO check
+        transform = cell_inst2.transform3d.create_from_axis_and_angle(axis=point_loc, angle=angle)
+        cell_inst2.transform3d = transform
+        transform = cell_inst2.transform3d.create_from_one_axis_to_another(point_from, point_to)
+        cell_inst2.transform3d = transform
+        transform = cell_inst2.transform3d.create_from_offset(point3d_t)
+        cell_inst2.transform3d = transform
+        # TODO check is position is correct.
         return cell_inst2
 
     def place_a3dcomp_3d_placement(
@@ -1455,7 +1481,7 @@ class Stackup(LayerCollection):
         offset_y=0.0,
         offset_z=0.0,
         place_on_top=True,
-    ):
+    ) -> bool:
         """Place a 3D Component into current layout.
          3D Component ports are not visible via EDB. They will be visible after the EDB has been opened in Ansys
          Electronics Desktop as a project.
@@ -1492,14 +1518,11 @@ class Stackup(LayerCollection):
         ...                                   offset_y="2mm", flipped_stackup=False, place_on_top=True,
         ...                                   )
         """
-        zero_data = GrpcValue(0.0)
-        one_data = GrpcValue(1.0)
-        local_origin = GrpcPoint3DData(0.0, 0.0, 0.0)
         rotation_axis_from = GrpcPoint3DData(1.0, 0.0, 0.0)
         _angle = angle * math.pi / 180.0
         rotation_axis_to = GrpcPoint3DData(math.cos(_angle), -1 * math.sin(_angle), 0.0)
 
-        stackup_target = GrpcLayerCollection(self._pedb.layout.layer_collection)
+        stackup_target = LayerCollection(self._pedb, self._pedb.layout.layer_collection)
         res = stackup_target.get_top_bottom_stackup_layers(GrpcLayerTypeSet.SIGNAL_LAYER_SET)
         target_top_elevation = res[1]
         target_bottom_elevation = res[3]
@@ -1521,9 +1544,12 @@ class Stackup(LayerCollection):
             return False
 
         mcad_model.cell_instance.placement_3d = True
-        mcad_model.cell_instance.transform3d = GrpcTransform3D(
-            local_origin, rotation_axis_from, rotation_axis_to, flip_angle, location
+        transform_rotation = mcad_model.cell_instance.transform3d.create_from_axis_and_angle(
+            axis=rotation_axis_from, angle=flip_angle.value
         )
+        mcad_model.cell_instance.transform3d = transform_rotation
+        transform_translation = mcad_model.cell_instance.transform3d.create_from_offset(offset=location)
+        mcad_model.cell_instance.transform3d = transform_translation
         return True
 
     def residual_copper_area_per_layer(self):