pyedb 0.50.1__py3-none-any.whl → 0.51.2__py3-none-any.whl

pyedb/dotnet/edb.py

@@ -25,6 +25,7 @@
 This module is implicitly loaded in HFSS 3D Layout when launched.
 
 """
+from datetime import datetime
 from itertools import combinations
 import os
 from pathlib import Path
@@ -91,6 +92,7 @@ from pyedb.dotnet.database.utilities.siwave_simulation_setup import (
     SiwaveDCSimulationSetup,
     SiwaveSimulationSetup,
 )
+from pyedb.edb_logger import pyedb_logger
 from pyedb.generic.constants import AEDT_UNITS, SolverType, unit_converter
 from pyedb.generic.general_methods import (
     generate_unique_name,
@@ -195,6 +197,10 @@ class Edb(Database):
         layer_filter: str = None,
         remove_existing_aedt: bool = False,
     ):
+        self._logger = pyedb_logger
+        now = datetime.now()
+        self.logger.info(f"Star initializing Edb {now.time()}")
+
         if isinstance(edbpath, Path):
             edbpath = str(edbpath)
 
@@ -290,7 +296,7 @@ class Edb(Database):
                 self._logger.add_file_logger(self.log_name, "Edb")
             self.open_edb()
         if self.active_cell:
-            self.logger.info("EDB initialized.")
+            self.logger.info(f"EDB initialized.Time lapse {datetime.now() - now}")
         else:
             raise AttributeError("Failed to initialize DLLs.")
 

pyedb/generic/design_types.py

@@ -37,79 +37,200 @@ def Edb(
 ):
     """Provides the EDB application interface.
 
-    This module inherits all objects that belong to EDB.
-
-    Parameters
-    ----------
-    edbpath : str, optional
-        Full path to the ``aedb`` folder. The variable can also contain
-        the path to a layout to import. Allowed formats are BRD,
-        XML (IPC2581), GDS, and DXF. The default is ``None``.
-        For GDS import, the Ansys control file (also XML) should have the same
-        name as the GDS file. Only the file extension differs.
-    cellname : str, optional
-        Name of the cell to select. The default is ``None``.
-    isreadonly : bool, optional
-        Whether to open EBD in read-only mode when it is
-        owned by HFSS 3D Layout. The default is ``False``.
-    edbversion : str, optional
-        Version of EDB to use. The default is ``"2021.2"``.
-    isaedtowned : bool, optional
-        Whether to launch EDB from HFSS 3D Layout. The
-        default is ``False``.
-    oproject : optional
-        Reference to the AEDT project object.
-    student_version : bool, optional
-        Whether to open the AEDT student version. The default is ``False.``
-    technology_file : str, optional
-        Full path to technology file to be converted to xml before importing or xml. Supported by GDS format only.
-    grpc : bool, optional
-        Whether to enable gRPC. Default value is ``False``.
-
-    Returns
-    -------
-    :class:`Edb <pyedb.dotnet.edb.Edb>` or :class:`Edb <pyedb.grpc.edb.Edb>`
-
-    Note
-    ----
-    PyEDB gRPC will be released starting ANSYS release 2025R2. For legacy purpose, the gRPC will not be activated by
-    default. However, PyEDB gRPC will be the lon term supported version. The legacy PyEDB .NET will be deprecated and
-    at some point all new features will only be implemented in PyEDB gRPC. We highly encourage users moving to gRPC
-    starting release 2025R2, we tried keeping gRPC version backward compatible with legace .NET as much as possible and
-    only minor adjustments are required to be compatible.
-
-    Examples
-    --------
-    Create an ``Edb`` object and a new EDB cell.
+        This module inherits all objects that belong to EDB.
+
+        Parameters
+        ----------
+        edbpath : str, optional
+            Full path to the ``aedb`` folder. The variable can also contain
+            the path to a layout to import. Allowed formats are BRD,
+            XML (IPC2581), GDS, and DXF. The default is ``None``.
+            For GDS import, the Ansys control file (also XML) should have the same
+            name as the GDS file. Only the file extension differs.
+        cellname : str, optional
+            Name of the cell to select. The default is ``None``.
+        isreadonly : bool, optional
+            Whether to open EBD in read-only mode when it is
+            owned by HFSS 3D Layout. The default is ``False``.
+        edbversion : str, optional
+            Version of EDB to use. The default is ``"2021.2"``.
+        isaedtowned : bool, optional
+            Whether to launch EDB from HFSS 3D Layout. The
+            default is ``False``.
+        oproject : optional
+            Reference to the AEDT project object.
+        student_version : bool, optional
+            Whether to open the AEDT student version. The default is ``False.``
+        technology_file : str, optional
+            Full path to technology file to be converted to xml before importing or xml. Supported by GDS format only.
+        grpc : bool, optional
+            Whether to enable gRPC. Default value is ``False``.
+
+        Returns
+        -------
+        :class:`Edb <pyedb.dotnet.edb.Edb>` or :class:`Edb <pyedb.grpc.edb.Edb>`
+
+        Note
+        ----
+        PyEDB gRPC will be released starting ANSYS release 2025R2. For legacy purpose, the gRPC will not be activated by
+        default. However, PyEDB gRPC will be the lon term supported version. The legacy PyEDB .NET will be deprecated
+        and at some point all new features will only be implemented in PyEDB gRPC. We highly encourage users moving to
+        gRPC starting release 2025R2, we tried keeping gRPC version backward compatible with legace .NET as much as
+        possible and only minor adjustments are required to be compatible.
+
+        Examples
+        --------
+        1. Creating and Opening an EDB Database
 
     >>> from pyedb import Edb
-    >>> app = Edb()
 
-    Add a new variable named "s1" to the ``Edb`` instance.
+        # Create a new EDB instance
+    >>> edb = Edb()
+
+        # Open an existing AEDB database
+    >>> edb = Edb(edbpath="my_project.aedb")
+
+        # Import a board file (BRD, XML, GDS, etc.)
+    >>> edb = Edb(edbpath="my_board.brd")
+
+        2. Cutout Operation
+
+        # Simple cutout with signal and reference nets
+    >>> edb.cutout(
+    >>>    signal_list=["PCIe", "USB"],
+    >>>    reference_list=["GND"]
+    >>>    )
+
+        # Advanced cutout with custom parameters
+    >>> edb.cutout(
+    >>>    signal_list=["DDR"],
+    >>>    reference_list=["GND"],
+    >>>    extent_type="ConvexHull",
+    >>>    expansion_size=0.002,
+    >>>    use_round_corner=True,
+    >>>    output_aedb_path="cutout.aedb",
+    >>>    remove_single_pin_components=True
+    >>>    )
+
+        3. Exporting Designs
+
+        # Export to IPC2581 format
+    >>> edb.export_to_ipc2581("output.xml", units="millimeter")
+
+        # Export to HFSS project
+    >>> edb.export_hfss("hfss_output")
+
+        # Export to Q3D project
+    >>> edb.export_q3d("q3d_output", net_list=["PowerNet"])
+
+        # Export to Maxwell project
+    >>> edb.export_maxwell("maxwell_output")
+
+        4. Simulation Setup
+
+        # Create SIwave SYZ setup
+    >>> syz_setup = edb.create_siwave_syz_setup(
+    >>> name="GHz_Setup",
+    >>> start_freq="1GHz",
+    >>> stop_freq="10GHz"
+    >>> )
+
+        # Create SIwave DC setup
+    >>> dc_setup = edb.create_siwave_dc_setup(
+    >>> name="DC_Analysis",
+    >>> use_dc_point=True
+    >>> )
+
+        # Solve with SIwave
+    >>> edb.solve_siwave()
+
+        5. Database Management
+
+        # Save database
+    >>> edb.save()
+
+        # Save as new database
+    >>> edb.save_as("new_project.aedb")
+
+        # Close database
+    >>> edb.close()
+
+        6. Stackup and Material Operations
+
+        # Access stackup layers
+    >>> for layer_name, layer in edb.stackup.layers.items():
+    >>> print(f"Layer: {layer_name}, Thickness: {layer.thickness}")
+
+        # Add new material
+    >>> edb.materials.add_material("MyMaterial", permittivity=4.3, loss_tangent=0.02)
+
+        # Change layer thickness
+    >>> edb.stackup["TopLayer"].thickness = "0.035mm"
+
+        7. Port Creation
+
+        # Create wave port between two pins
+    >>> wave_port = edb.source_excitation.create_port(
+    >>> positive_terminal=pin1,
+    >>> negative_terminal=pin2,
+    >>> port_type="Wave"
+    >>> )
+
+        # Create lumped port
+    >>> lumped_port = edb.source_excitation.create_port(
+    >>> positive_terminal=via_terminal,
+    >>> port_type="Lumped"
+    >>> )
+
+        8. Component Management
+
+        # Delete components by type
+    >>> edb.components.delete_component(["R1", "C2"])
+
+        # Set component properties
+    >>> edb.components["U1"].set_property("Value", "10nH")
+
+        9. Parametrization
+
+        # Auto-parametrize design elements
+    >>> params = edb.auto_parametrize_design(
+    >>> traces=True,
+    >>> pads=True,
+    >>> antipads=True,
+    >>> use_relative_variables=True
+    >>> )
+    >>> print("Created parameters:", params)
 
-    >>> app['s1'] = "0.25 mm"
-    >>> app['s1'].tofloat
-    >>> 0.00025
-    >>> app['s1'].tostring
-    >>> "0.25mm"
+        10. Design Statistics
 
-    or add a new parameter with description:
+        # Get layout statistics with area calculation
+    >>> stats = edb.get_statistics(compute_area=True)
+    >>> print(f"Total nets: {stats.net_count}")
+    >>> print(f"Total components: {stats.component_count}")
 
-    >>> app['s2'] = ["20um", "Spacing between traces"]
-    >>> app['s2'].value
-    >>> 1.9999999999999998e-05
-    >>> app['s2'].description
-    >>> 'Spacing between traces'
+        11. Layout Validation
 
+        # Run DRC check
+    >>> drc_errors = edb.layout_validation.run_drc()
+    >>> print(f"Found {len(drc_errors)} DRC violations")
 
-    Create an ``Edb`` object and open the specified project.
+        12. Differential Pairs
 
-    >>> app = Edb("myfile.aedb")
+        # Create differential pair
+    >>> edb.differential_pairs.create(
+    >>> positive_net="USB_P",
+    >>> negative_net="USB_N",
+    >>> name="USB_DP"
+    >>> )
 
-    Create an ``Edb`` object from GDS and control files.
-    The XML control file resides in the same directory as the GDS file: (myfile.xml).
+        13. Workflow Automation
 
-    >>> app = Edb("/path/to/file/myfile.gds")
+        # Define and run workflow
+    >>> workflow = edb.workflow
+    >>> workflow.add_task("Import", file_path="input.brd")
+    >>> workflow.add_task("Cutout", signal_nets=["PCIe"])
+    >>> workflow.add_task("Export", format="IPC2581")
+    >>> workflow.run()
 
     """
 

pyedb/grpc/database/components.py

@@ -2159,3 +2159,113 @@ class Components(object):
             pin.name for pin in list(self.instances[reference_designator].pins.values()) if pin.net_name == net_name
         ]
         return self.create_pin_group(reference_designator, pins, group_name)
+
+    def deactivate_rlc_component(self, component=None, create_circuit_port=False, pec_boundary=False):
+        """Deactivate RLC component with a possibility to convert it to a circuit port.
+
+        Parameters
+        ----------
+        component : str
+            Reference designator of the RLC component.
+
+        create_circuit_port : bool, optional
+            Whether to replace the deactivated RLC component with a circuit port. The default
+            is ``False``.
+        pec_boundary : bool, optional
+            Whether to define the PEC boundary, The default is ``False``. If set to ``True``,
+            a perfect short is created between the pin and impedance is ignored. This
+            parameter is only supported on a port created between two pins, such as
+            when there is no pin group.
+
+        Returns
+        -------
+        bool
+            ``True`` when successful, ``False`` when failed.
+
+        Examples
+        --------
+        >>> from pyedb import Edb
+        >>> edb_file = r'C:\my_edb_file.aedb'
+        >>> edb = Edb(edb_file)
+        >>> for cmp in list(edb.components.instances.keys()):
+        >>>     edb.components.deactivate_rlc_component(component=cmp, create_circuit_port=False)
+        >>> edb.save_edb()
+        >>> edb.close_edb()
+        """
+        if not component:
+            return False
+        if isinstance(component, str):
+            component = self.instances[component]
+            if not component:
+                self._logger.error("component %s not found.", component)
+                return False
+        if component.type in ["other", "ic", "io"]:
+            self._logger.info(f"Component {component.refdes} passed to deactivate is not an RLC.")
+            return False
+        component.is_enabled = False
+        return self._pedb.source_excitation.add_port_on_rlc_component(
+            component=component.refdes, circuit_ports=create_circuit_port, pec_boundary=pec_boundary
+        )
+
+    def replace_rlc_by_gap_boundaries(self, component=None):
+        """Replace RLC component by RLC gap boundaries. These boundary types are compatible with 3D modeler export.
+        Only 2 pins RLC components are supported in this command.
+
+        Parameters
+        ----------
+        component : str
+            Reference designator of the RLC component.
+
+        Returns
+        -------
+        bool
+        ``True`` when succeed, ``False`` if it failed.
+
+        Examples
+        --------
+        >>> from pyedb import Edb
+        >>> edb = Edb(edb_file)
+        >>>  for refdes, cmp in edb.components.capacitors.items():
+        >>>     edb.components.replace_rlc_by_gap_boundaries(refdes)
+        >>> edb.save_edb()
+        >>> edb.close_edb()
+        """
+        if not component:
+            return False
+        if isinstance(component, str):
+            component = self.instances[component]
+            if not component:
+                self._logger.error("component %s not found.", component)
+                return False
+        if component.type in ["other", "ic", "io"]:
+            self._logger.info(f"Component {component.refdes} skipped to deactivate is not an RLC.")
+            return False
+        component.enabled = False
+        return self._pedb.source_excitation.add_rlc_boundary(component.refdes, False)
+
+    def add_rlc_boundary(self, component=None, circuit_type=True):
+        """Add RLC gap boundary on component and replace it with a circuit port.
+        The circuit port supports only 2-pin components.
+
+        . deprecated:: pyedb 0.28.0
+        Use :func:`pyedb.grpc.core.excitations.add_rlc_boundary` instead.
+
+        Parameters
+        ----------
+        component : str
+            Reference designator of the RLC component.
+        circuit_type : bool
+            When ``True`` circuit type are defined, if ``False`` gap type will be used instead (compatible with HFSS 3D
+            modeler). Default value is ``True``.
+
+        Returns
+        -------
+        bool
+            ``True`` when successful, ``False`` when failed.
+        """
+        warnings.warn(
+            "`add_rlc_boundary` is deprecated and is now located here "
+            "`pyedb.grpc.core.excitations.add_rlc_boundary` instead.",
+            DeprecationWarning,
+        )
+        return self._pedb.source_excitation.add_rlc_boundary(self, component=component, circuit_type=circuit_type)

pyedb/grpc/database/control_file.py

@@ -35,23 +35,156 @@ from pyedb.misc.misc import list_installed_ansysem
 def convert_technology_file(tech_file, edbversion=None, control_file=None):
     """Convert a technology file to EDB control file (XML).
 
-    Parameters
-    ----------
-    tech_file : str
-        Full path to technology file.
-    edbversion : str, optional
-        EDB version to use. If ``None``, uses latest available version.
-    control_file : str, optional
-        Output control file path. If ``None``, uses same path and name as ``tech_file``.
-
-    Returns
-    -------
-    str or bool
-        Full path to created control file if successful, ``False`` otherwise.
-
-    Notes
-    -----
-    This function is only supported on Linux systems.
+        Parameters
+        ----------
+        tech_file : str
+            Full path to technology file.
+        edbversion : str, optional
+            EDB version to use. If ``None``, uses latest available version.
+        control_file : str, optional
+            Output control file path. If ``None``, uses same path and name as ``tech_file``.
+
+        Returns
+        -------
+        str or bool
+            Full path to created control file if successful, ``False`` otherwise.
+
+        Notes
+        -----
+        This function is only supported on Linux systems.
+
+        Example
+        -------
+        # Example 1: Converting a technology file to control file
+    >>> converted_file = convert_technology_file(
+    >>> tech_file="/path/to/tech.t",
+    >>> edbversion="2025.2",
+    >>> control_file="/path/to/output.xml"
+    >>> )
+    >>> if converted_file:
+    >>> print(f"Converted to: {converted_file}")
+
+        # Example 2: Creating a material
+    >>> from pyedb import ControlFileMaterial
+    >>> material = ControlFileMaterial(
+    >>> "Copper",
+    >>> {"Permittivity": 1.0, "Conductivity": 5.8e7}
+    >>> )
+
+        # Example 3: Creating a dielectric layer
+    >>> from pyedb import ControlFileDielectric
+    >>> dielectric = ControlFileDielectric(
+    >>> "Core",
+    >>> {"Thickness": "0.2mm", "Material": "FR4"}
+    >>> )
+
+        # Example 4: Creating a signal layer
+    >>> from pyedb import ControlFileLayer
+    >>> signal_layer = ControlFileLayer(
+    >>> "TopLayer",
+    >>> {"Type": "signal", "Material": "Copper", "Thickness": "0.035mm"}
+    >>> )
+
+        # Example 5: Creating a via layer
+    >>> from pyedb import ControlFileVia
+    >>> via_layer = ControlFileVia(
+    >>> "Via1",
+    >>> {"StartLayer": "TopLayer", "StopLayer": "BottomLayer"}
+    >>> )
+    >>> via_layer.create_via_group = True
+    >>> via_layer.tolerance = "0.1mm"
+
+        # Example 6: Managing stackup
+    >>> from pyedb import ControlFileStackup
+    >>> stackup = ControlFileStackup(units="mm")
+    >>> stackup.add_material("FR4", permittivity=4.4, dielectric_loss_tg=0.02)
+    >>> stackup.add_layer("L1", elevation=0, material="Copper", thickness=0.035)
+    >>> stackup.add_dielectric("Diel1", material="FR4", thickness=0.2)
+    >>> stackup.add_via("Via1", start_layer="L1", stop_layer="L2")
+
+        # Example 7: Configuring import options
+    >>> from pyedb import ControlFileImportOptions
+    >>> import_ops = ControlFileImportOptions()
+    >>> import_ops.auto_close = True
+    >>> import_ops.defeature_tolerance = 0.001
+
+        # Example 8: Setting up simulation extents
+    >>> from pyedb import ControlExtent
+    >>> extent = ControlExtent(
+    >>> type="Conforming",
+    >>> diel_hactor=0.3,
+    >>> airbox_hfactor=0.5
+    >>> )
+
+        # Example 9: Creating circuit ports
+    >>> from pyedb import ControlCircuitPt
+    >>> port = ControlCircuitPt("Port1", 0, 0, "TopLayer", 1, 0, "TopLayer", 50)
+
+        # Example 10: Managing components
+    >>> from pyedb import ControlFileComponent
+    >>> comp = ControlFileComponent()
+    >>> comp.refdes = "U1"
+    >>> comp.add_pin("Pin1", 0.5, 0.5, "TopLayer")
+    >>> comp.add_port("Port1", 50, "Pin1", refpin="GND")
+
+        # Example 11: Component management
+    >>> from pyedb import ControlFileComponents
+    >>> components = ControlFileComponents()
+    >>> ic = components.add_component("U1", "BGA", "IC", die_type="Flip chip")
+    >>> ic.add_pin("A1", 1.0, 1.0, "TopLayer")
+
+         # Example 12: Boundary setup
+    >>> from pyedb import ControlFileBoundaries
+    >>> boundaries = ControlFileBoundaries()
+    >>> boundaries.add_port("Port1", 0, 0, "L1", 1, 0, "L1", 50)
+    >>> boundaries.add_extent(diel_hactor=0.3)
+
+        # Example 13: Frequency sweep configuration
+    >>> from pyedb import ControlFileSweep
+    >>> sweep = ControlFileSweep(
+    >>> "Sweep1", "1GHz", "10GHz", "0.1GHz",
+    >>> "Interpolating", "LinearStep", True
+    >>> )
+
+        # Example 14: Mesh operation setup
+    >>> from pyedb import ControlFileMeshOp
+    >>> mesh_op = ControlFileMeshOp(
+    >>> "FineMesh", "Region1", "MeshOperationSkinDepth",
+    >>> {"Net1": "TopLayer"}
+    >>> )
+    >>> mesh_op.skin_depth = "1um"
+
+        # Example 15: Simulation setup configuration
+    >>> from pyedb import ControlFileSetup
+    >>> setup = ControlFileSetup("SimSetup1")
+    >>> setup.frequency = "5GHz"
+    >>> setup.add_sweep("Sweep1", "1GHz", "10GHz", "0.5GHz")
+    >>> setup.add_mesh_operation("Mesh1", "Chip", "MeshOperationLength", {"PWR": "Top"})
+
+        # Example 16: Setup management
+    >>> from pyedb import ControlFileSetups
+    >>> setups = ControlFileSetups()
+    >>> sim_setup = setups.add_setup("MySetup", "10GHz")
+    >>> sim_setup.add_sweep("Swp1", "1GHz", "20GHz", 100, step_type="LinearCount")
+
+        # Example 17: Main control file creation
+    >>> from pyedb import ControlFile
+
+        # Create from scratch
+    >>> ctrl = ControlFile()
+    >>> ctrl.stackup.add_material("Copper", conductivity=5.8e7)
+    >>> ctrl.stackup.add_layer("Signal", thickness=0.035, material="Copper")
+    >>> ctrl.boundaries.add_port("Input", 0, 0, "Signal", 1, 0, "Signal", 50)
+    >>> ctrl.write_xml("/path/to/control.xml")
+
+        # Parse existing file
+    >>> ctrl = ControlFile(xml_input="/path/to/existing.xml")
+
+        # Convert technology file
+    >>> ctrl = ControlFile(tecnhology="/path/to/tech.t")
+
+        # Apply layer mapping
+    >>> ctrl.parse_layer_map("/path/to/layer_map.txt")
     """
     if is_linux:  # pragma: no cover
         if not edbversion:

pyedb/grpc/database/definitions.py

@@ -34,12 +34,30 @@ class Definitions:
 
     @property
     def component(self) -> dict[str, ComponentDef]:
-        """Component definitions"""
+        """Component definitions
+
+        Examples
+        --------
+        >>> from pyedb import Edb
+        >>> edb = Edb()
+        >>> component_defs = edb.definitions.component
+        >>> for name, comp_def in component_defs.items():
+        ...     print(f"Component: {name}, Part: {comp_def.part}")
+        """
         return {l.name: ComponentDef(self._pedb, l) for l in self._pedb.active_db.component_defs}
 
     @property
     def package(self) -> dict[str, PackageDef]:
-        """Package definitions."""
+        """Package definitions.
+
+        Examples
+        --------
+        >>> from pyedb import Edb
+        >>> edb = Edb()
+        >>> package_defs = edb.definitions.package
+        >>> for name, pkg_def in package_defs.items():
+        ...     print(f"Package: {name}, Boundary: {pkg_def.exterior_boundary}")
+        """
         return {l.name: PackageDef(self._pedb, l) for l in self._pedb.active_db.package_defs}
 
     def add_package_def(self, name, component_part_name=None, boundary_points=None) -> Union[PackageDef, bool]:
@@ -57,6 +75,22 @@ class Definitions:
         Returns
         -------
         PackageDef object.
+
+        Examples
+        --------
+        >>> from pyedb import Edb
+        >>> edb = Edb()
+
+        Example 1: Create package using component's bounding box
+        >>> comp_def = edb.definitions.add_package_def("QFP64", "QFP64_COMPONENT")
+        >>> if comp_def:  # Check if created successfully
+        ...     print(f"Created package: {comp_def.name}")
+
+        Example 2: Create package with custom boundary
+        >>> boundary = [[0, 0], [10e-3, 0], [10e-3, 10e-3], [0, 10e-3]]
+        >>> custom_pkg = edb.definitions.add_package_def("CustomIC", boundary_points=boundary)
+        >>> if custom_pkg:
+        ...     print(f"Custom package boundary: {custom_pkg.exterior_boundary}")
         """
         if not name in self.package:
             package_def = PackageDef.create(self._pedb.active_db, name=name)

pyedb/grpc/database/hfss.py

@@ -200,6 +200,12 @@ class Hfss(object):
         -------
         dict
             Dictionary mapping net names to smallest trace widths.
+
+        Examples
+        --------
+        >>> widths = edb.hfss.get_trace_width_for_traces_with_ports()
+        >>> for net_name, width in widths.items():
+        ...     print(f"Net '{net_name}': Smallest width = {width}")
         """
         nets = {}
         for net in self._pedb.excitations_nets:
@@ -925,6 +931,15 @@ class Hfss(object):
         -------
         list
             [min_x, min_y, max_x, max_y] coordinates.
+
+        Examples
+        --------
+        >>> bbox = edb.hfss.get_layout_bounding_box()
+        >>> print(f"Layout Bounding Box: {bbox}")
+        >>>
+        >>> # With custom parameters
+        >>> custom_layout = edb.layouts["MyLayout"]
+        >>> bbox = edb.hfss.get_layout_bounding_box(custom_layout, 5)
         """
         if not layout:
             layout = self._active_layout