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

pyedb/grpc/database/simulation_setup/siwave_simulation_setup.py

@@ -57,7 +57,14 @@ class SiwaveSimulationSetup(GrpcSIWaveSimulationSetup):
             super(SiwaveSimulationSetup, self.__class__).type.__set__(self, GrpcSimulationSetupType.SI_WAVE_DCIR)
 
     def add_sweep(
-        self, name=None, distribution="linear", start_freq="0GHz", stop_freq="20GHz", step="10MHz", discrete=False
+        self,
+        name=None,
+        distribution="linear",
+        start_freq="0GHz",
+        stop_freq="20GHz",
+        step="10MHz",
+        discrete=False,
+        frequency_set=None,
     ):
         """Add a HFSS frequency sweep.
 
@@ -81,39 +88,75 @@ class SiwaveSimulationSetup(GrpcSIWaveSimulationSetup):
             distribution. Must be integer in that case.
         discrete : bool, optional
             Whether the sweep is discrete. The default is ``False``.
+        frequency_set : List, optional
+            Frequency set is a list adding one or more frequency sweeps. If ``frequency_set`` is provided, the other
+            arguments are ignored except ``discrete``. Default value is ``None``.
+            example of frequency_set : [['linear_scale', '50MHz', '200MHz', '10MHz']].
 
         Returns
         -------
         bool
         """
         init_sweep_count = len(self.sweep_data)
-        start_freq = self._pedb.number_with_units(start_freq, "Hz")
-        stop_freq = self._pedb.number_with_units(stop_freq, "Hz")
-        step = str(step)
-        if distribution.lower() == "linear":
-            distribution = "LIN"
-        elif distribution.lower() == "linear_count":
-            distribution = "LINC"
-        elif distribution.lower() == "exponential":
-            distribution = "ESTP"
-        elif distribution.lower() == "decade_count":
-            distribution = "DEC"
-        elif distribution.lower() == "octave_count":
-            distribution = "OCT"
+        if frequency_set:
+            for sweep in frequency_set:
+                if "linear_scale" in sweep:
+                    distribution = "LIN"
+                elif "linear_count" in sweep:
+                    distribution = "LINC"
+                elif "exponential" in sweep:
+                    distribution = "ESTP"
+                elif "log_scale" in sweep:
+                    distribution = "DEC"
+                elif "octave_count" in sweep:
+                    distribution = "OCT"
+                else:
+                    distribution = "LIN"
+                start_freq = self._pedb.number_with_units(sweep[1], "Hz")
+                stop_freq = self._pedb.number_with_units(sweep[2], "Hz")
+                step = str(sweep[3])
+                if not name:
+                    name = f"sweep_{init_sweep_count + 1}"
+                sweep_data = [
+                    SweepData(
+                        self._pedb, name=name, distribution=distribution, start_f=start_freq, end_f=stop_freq, step=step
+                    )
+                ]
+                if discrete:
+                    sweep_data[0].type = sweep_data[0].type.DISCRETE_SWEEP
+                for sweep in self.sweep_data:
+                    sweep_data.append(sweep)
+                self.sweep_data = sweep_data
         else:
-            distribution = "LIN"
-        if not name:
-            name = f"sweep_{init_sweep_count + 1}"
-        sweep_data = [
-            SweepData(self._pedb, name=name, distribution=distribution, start_f=start_freq, end_f=stop_freq, step=step)
-        ]
-        if discrete:
-            sweep_data[0].type = sweep_data[0].type.DISCRETE_SWEEP
-        for sweep in self.sweep_data:
-            sweep_data.append(sweep)
-        self.sweep_data = sweep_data
-        if len(self.sweep_data) == init_sweep_count + 1:
-            return True
-        else:
-            self._pedb.logger.error("Failed to add frequency sweep data")
-            return False
+            start_freq = self._pedb.number_with_units(start_freq, "Hz")
+            stop_freq = self._pedb.number_with_units(stop_freq, "Hz")
+            step = str(step)
+            if distribution.lower() == "linear":
+                distribution = "LIN"
+            elif distribution.lower() == "linear_count":
+                distribution = "LINC"
+            elif distribution.lower() == "exponential":
+                distribution = "ESTP"
+            elif distribution.lower() == "decade_count":
+                distribution = "DEC"
+            elif distribution.lower() == "octave_count":
+                distribution = "OCT"
+            else:
+                distribution = "LIN"
+            if not name:
+                name = f"sweep_{init_sweep_count + 1}"
+            sweep_data = [
+                SweepData(
+                    self._pedb, name=name, distribution=distribution, start_f=start_freq, end_f=stop_freq, step=step
+                )
+            ]
+            if discrete:
+                sweep_data[0].type = sweep_data[0].type.DISCRETE_SWEEP
+            for sweep in self.sweep_data:
+                sweep_data.append(sweep)
+            self.sweep_data = sweep_data
+            if len(self.sweep_data) == init_sweep_count + 1:
+                return True
+            else:
+                self._pedb.logger.error("Failed to add frequency sweep data")
+                return False

pyedb/grpc/database/simulation_setup/sweep_data.py

@@ -20,6 +20,12 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+from ansys.edb.core.simulation_setup.simulation_setup import (
+    Distribution as GrpcDistribution,
+)
+from ansys.edb.core.simulation_setup.simulation_setup import (
+    FrequencyData as GrpcFrequencyData,
+)
 from ansys.edb.core.simulation_setup.simulation_setup import SweepData as GrpcSweepData
 
 
@@ -27,6 +33,11 @@ class SweepData(GrpcSweepData):
     """Frequency sweep data class."""
 
     def __init__(self, pedb, name, distribution, start_f, end_f, step, edb_object=None):
-        super().__init__(name=name, distribution=distribution, start_f=start_f, end_f=end_f, step=step)
+        super().__init__(
+            name=name,
+            frequency_data=GrpcFrequencyData(
+                distribution=GrpcDistribution[distribution], start_f=start_f, end_f=end_f, step=step
+            ),
+        )
         self._edb_object = edb_object
         self._pedb = pedb

pyedb/grpc/database/siwave.py

@@ -28,6 +28,12 @@ import os
 import warnings
 
 from ansys.edb.core.database import ProductIdType as GrpcProductIdType
+from ansys.edb.core.simulation_setup.simulation_setup import (
+    Distribution as GrpcDistribution,
+)
+from ansys.edb.core.simulation_setup.simulation_setup import (
+    FrequencyData as GrpcFrequencyData,
+)
 from ansys.edb.core.simulation_setup.simulation_setup import SweepData as GrpcSweepData
 
 from pyedb.misc.siw_feature_config.xtalk_scan.scan_config import SiwaveScanConfig
@@ -592,7 +598,10 @@ class Siwave(object):
         sweep_name = f"sweep_{len(setup.sweep_data) + 1}"
         sweep_data = [
             GrpcSweepData(
-                name=sweep_name, distribution=distribution, start_f=start_freq, end_f=stop_freq, step=step_freq
+                name=sweep_name,
+                frequency_data=GrpcFrequencyData(
+                    distribution=GrpcDistribution[distribution], start_f=start_freq, end_f=stop_freq, step=step_freq
+                ),
             )
         ]
         if discrete_sweep:

pyedb/grpc/database/source_excitations.py

@@ -225,7 +225,7 @@ class SourceExcitation:
         if refdes and any(refdes.rlc_values):
             return self._pedb.components.deactivate_rlc_component(component=refdes, create_circuit_port=True)
         if not port_name:
-            port_name = f"Port_{pins[0].net_name}_{pins[0].name}"
+            port_name = f"Port_{pins[0].net_name}_{pins[0].component.name}_{pins[0].name}"
 
         if len(pins) > 1 or pingroup_on_single_pin:
             pec_boundary = False
@@ -713,9 +713,19 @@ class SourceExcitation:
         -------
         Edb pin group terminal.
         """
+        from ansys.edb.core.hierarchy.pin_group import PinGroup as GrpcPinGroup
+
+        from pyedb.grpc.database.hierarchy.pingroup import PinGroup
+
         if pingroup.is_null:
             self._logger.error(f"{pingroup} is null")
-        pin = PadstackInstance(self._pedb, pingroup.pins[0])
+        if not pingroup.pins:
+            self._pedb.logger.error("No pins defined on pingroup.")
+            return False
+        if isinstance(pingroup, GrpcPinGroup):
+            pingroup = PinGroup(self._pedb, pingroup)
+        pin = list(pingroup.pins.values())[0]
+        pin = PadstackInstance(self._pedb, pin)
         if term_name is None:
             term_name = f"{pin.component.name}.{pin.name}.{pin.net_name}"
         for t in self._pedb.active_layout.terminals:

pyedb/grpc/database/stackup.py

@@ -138,15 +138,23 @@ class LayerCollection(GrpcLayerCollection):
 
         """
         thickness = GrpcValue(0.0)
+        layer_type_map = {"dielectric": GrpcLayerType.DIELECTRIC_LAYER, "signal": GrpcLayerType.SIGNAL_LAYER}
         if "thickness" in kwargs:
             thickness = GrpcValue(kwargs["thickness"])
         elevation = GrpcValue(0.0)
-        _layer_type = GrpcLayerType.SIGNAL_LAYER
-        if layer_type.lower() == "dielectric":
-            _layer_type = GrpcLayerType.DIELECTRIC_LAYER
+        if "type" in kwargs:
+            _layer_type = layer_type_map[kwargs["type"]]
+        else:
+            _layer_type = layer_type_map[layer_type]
+        if "material" in kwargs:
+            _material = kwargs["material"]
+        else:
+            _material = "copper"
         layer = GrpcStackupLayer.create(
-            name=name, layer_type=_layer_type, thickness=thickness, material="copper", elevation=elevation
+            name=name, layer_type=_layer_type, thickness=thickness, material=_material, elevation=elevation
         )
+        if "fill_material" in kwargs:
+            layer.set_fill_material(kwargs["fill_material"])
         return self._layer_collection.add_layer_bottom(layer)
 
     def add_layer_below(self, name, base_layer_name, layer_type="signal", **kwargs):

pyedb/grpc/database/terminal/edge_terminal.py

@@ -20,6 +20,8 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+import re
+
 from ansys.edb.core.terminal.bundle_terminal import BundleTerminal as GrpcBundleTerminal
 from ansys.edb.core.terminal.edge_terminal import EdgeTerminal as GrpcEdgeTerminal
 
@@ -29,6 +31,65 @@ class EdgeTerminal(GrpcEdgeTerminal):
         super().__init__(edb_object.msg)
         self._pedb = pedb
         self._edb_object = edb_object
+        self._hfss_type = "Gap"
+
+    @property
+    def _edb_properties(self):
+        from ansys.edb.core.database import ProductIdType as GrpcProductIdType
+
+        try:
+            p = self._edb_object.get_product_property(GrpcProductIdType.DESIGNER, 1)
+        except:
+            p = ""
+        return p
+
+    @_edb_properties.setter
+    def _edb_properties(self, value):
+        from ansys.edb.core.database import ProductIdType as GrpcProductIdType
+
+        self._edb_object.set_product_property(GrpcProductIdType.DESIGNER, 1, value)
+
+    @property
+    def is_wave_port(self):
+        if self._hfss_port_property:
+            return True
+        return False
+
+    @property
+    def _hfss_port_property(self):
+        """HFSS port property."""
+        hfss_prop = re.search(r"HFSS\(.*?\)", self._edb_properties)
+        p = {}
+        if hfss_prop:
+            hfss_type = re.search(r"'HFSS Type'='([^']+)'", hfss_prop.group())
+            orientation = re.search(r"'Orientation'='([^']+)'", hfss_prop.group())
+            horizontal_ef = re.search(r"'Horizontal Extent Factor'='([^']+)'", hfss_prop.group())
+            vertical_ef = re.search(r"'Vertical Extent Factor'='([^']+)'", hfss_prop.group())
+            radial_ef = re.search(r"'Radial Extent Factor'='([^']+)'", hfss_prop.group())
+            pec_w = re.search(r"'PEC Launch Width'='([^']+)'", hfss_prop.group())
+
+            p["HFSS Type"] = hfss_type.group(1) if hfss_type else ""
+            p["Orientation"] = orientation.group(1) if orientation else ""
+            p["Horizontal Extent Factor"] = float(horizontal_ef.group(1)) if horizontal_ef else ""
+            p["Vertical Extent Factor"] = float(vertical_ef.group(1)) if vertical_ef else ""
+            p["Radial Extent Factor"] = float(radial_ef.group(1)) if radial_ef else ""
+            p["PEC Launch Width"] = pec_w.group(1) if pec_w else ""
+        else:
+            p["HFSS Type"] = ""
+            p["Orientation"] = ""
+            p["Horizontal Extent Factor"] = ""
+            p["Vertical Extent Factor"] = ""
+            p["Radial Extent Factor"] = ""
+            p["PEC Launch Width"] = ""
+        return p
+
+    @_hfss_port_property.setter
+    def _hfss_port_property(self, value):
+        txt = []
+        for k, v in value.items():
+            txt.append("'{}'='{}'".format(k, v))
+        txt = ",".join(txt)
+        self._edb_properties = "HFSS({})".format(txt)
 
     def couple_ports(self, port):
         """Create a bundle wave port.
@@ -49,3 +110,35 @@ class EdgeTerminal(GrpcEdgeTerminal):
         temp.extend([i for i in port])
         bundle_terminal = GrpcBundleTerminal.create(temp)
         return self._pedb.ports[bundle_terminal.name]
+
+    @property
+    def is_port(self):
+        return True
+
+    @property
+    def ref_terminal(self):
+        """Return refeference terminal.
+
+        ..deprecated:: 0.44.0
+           Use: func:`reference_terminal` property instead.
+
+        """
+        self._pedb.logger.warning("ref_terminal is deprecated, use reference_terminal property instead.")
+        return self.reference_terminal
+
+    @ref_terminal.setter
+    def ref_terminal(self, value):
+        self._pedb.logger.warning("ref_terminal is deprecated, use reference_terminal property instead.")
+        self.reference_terminal = value
+
+    @property
+    def hfss_type(self):
+        return self._hfss_type
+
+    @hfss_type.setter
+    def hfss_type(self, value):
+        self._hfss_type = value
+
+    @property
+    def terminal_type(self):
+        return "EdgeTerminal"

pyedb/grpc/database/terminal/pingroup_terminal.py

@@ -184,12 +184,25 @@ class PinGroupTerminal(GrpcPinGroupTerminal):
 
         """
         self._pedb.logger.warning("ref_terminal property is deprecated, use reference_terminal property instead.")
-        return self.reference_terminal
+        return PinGroupTerminal(self._pedb, self.reference_terminal)
 
     @ref_terminal.setter
     def ref_terminal(self, value):
+        self._pedb.logger.warning("ref_terminal is deprecated, use reference_terminal instead.")
         self.reference_terminal = value
 
     @property
     def hfss_type(self):
         return "circuit"
+
+    @property
+    def is_current_source(self):
+        if self.boundary_type == "current_source":
+            return True
+        return False
+
+    @property
+    def is_voltage_source(self):
+        if self.boundary_type == "voltage_source":
+            return True
+        return False

pyedb/grpc/edb.py

@@ -198,7 +198,6 @@ class Edb(EdbInit):
         use_ppe=False,
         technology_file=None,
         restart_rpc_server=False,
-        kill_all_instances=False,
     ):
         edbversion = get_string_version(edbversion)
         self._clean_variables()
@@ -273,9 +272,9 @@ class Edb(EdbInit):
             self.logger.info("EDB %s was created correctly from %s file.", self.edbpath, edbpath[-2:])
         elif edbpath.endswith("edb.def"):
             self.edbpath = os.path.dirname(edbpath)
-            self.open_edb(restart_rpc_server=restart_rpc_server, kill_all_instances=kill_all_instances)
+            self.open_edb(restart_rpc_server=restart_rpc_server)
         elif not os.path.exists(os.path.join(self.edbpath, "edb.def")):
-            self.create_edb(restart_rpc_server=restart_rpc_server, kill_all_instances=kill_all_instances)
+            self.create_edb(restart_rpc_server=restart_rpc_server)
             self.logger.info("EDB %s created correctly.", self.edbpath)
         elif ".aedb" in edbpath:
             self.edbpath = edbpath
@@ -290,8 +289,7 @@ class Edb(EdbInit):
         return self
 
     def __exit__(self, ex_type, ex_value, ex_traceback):
-        if ex_type:
-            self.edb_exception(ex_value, ex_traceback)
+        self._signal_handler(ex_type, ex_value)
 
     def __getitem__(self, variable_name):
         """Get a variable to the Edb project. The variable can be project using ``$`` prefix or
@@ -493,7 +491,9 @@ class Edb(EdbInit):
         """
         terminals = [term for term in self.layout.terminals if not term.is_reference_terminal]
         ports = {}
+        from pyedb.grpc.database.ports.ports import WavePort
         from pyedb.grpc.database.terminal.bundle_terminal import BundleTerminal
+        from pyedb.grpc.database.terminal.edge_terminal import EdgeTerminal
         from pyedb.grpc.database.terminal.padstack_instance_terminal import (
             PadstackInstanceTerminal,
         )
@@ -504,6 +504,11 @@ class Edb(EdbInit):
                 ports[bundle_ter.name] = bundle_ter
             elif isinstance(t, PadstackInstanceTerminal):
                 ports[t.name] = CoaxPort(self, t)
+            elif isinstance(t, EdgeTerminal):
+                if t.is_wave_port:
+                    ports[t.name] = WavePort(self, t)
+                else:
+                    ports[t.name] = EdgeTerminal(self, t)
             else:
                 ports[t.name] = GapPort(self, t)
         return ports
@@ -572,7 +577,6 @@ class Edb(EdbInit):
                     self.edbpath,
                     self.isreadonly,
                     restart_rpc_server=restart_rpc_server,
-                    kill_all_instances=kill_all_instances,
                 )
                 n_try -= 1
             except Exception as e:
@@ -613,7 +617,7 @@ class Edb(EdbInit):
         n_try = 10
         while not self.db and n_try:
             try:
-                self.create(self.edbpath, restart_rpc_server=restart_rpc_server, kill_all_instances=kill_all_instances)
+                self.create(self.edbpath, restart_rpc_server=restart_rpc_server)
                 n_try -= 1
             except Exception as e:
                 self.logger.error(e.args[0])
@@ -2015,8 +2019,8 @@ class Edb(EdbInit):
                     nets_to_preserve.extend(el.nets)
         if include_pingroups:
             for pingroup in self.layout.pin_groups:
-                for pin in pingroup.pins:
-                    if pin.net_name in reference_list:
+                for pin_name, pin in pingroup.pins.items():
+                    if pin_name in reference_list:
                         pins_to_preserve.append(pin.edb_uid)
         if check_terminals:
             terms = [

pyedb/grpc/edb_init.py

@@ -22,7 +22,9 @@
 
 
 """Database."""
+import atexit
 import os
+import signal
 import sys
 
 import ansys.edb.core.database as database
@@ -68,13 +70,22 @@ class EdbInit(object):
         oa_directory = os.path.join(self.base_path, "common", "oa")
         os.environ["ANSYS_OADIR"] = oa_directory
         os.environ["PATH"] = "{};{}".format(os.environ["PATH"], self.base_path)
+        # register server kill
+        atexit.register(self._signal_handler)
+        # register signal handlers
+        signal.signal(signal.SIGTERM, self._signal_handler)
+        signal.signal(signal.SIGINT, self._signal_handler)
+
+    @staticmethod
+    def _signal_handler(signum=None, frame=None):
+        RpcSession.kill()
 
     @property
     def db(self):
         """Active database object."""
         return self._db
 
-    def create(self, db_path, port=0, restart_rpc_server=False, kill_all_instances=False):
+    def create(self, db_path, port=0, restart_rpc_server=False):
         """Create a Database at the specified file location.
 
         Parameters
@@ -82,12 +93,12 @@ class EdbInit(object):
         db_path : str
             Path to top-level database folder
 
+        port : int
+            grpc port number.
+
         restart_rpc_server : optional, bool
             Force restarting RPC server when `True`.Default value is `False`
 
-        kill_all_instances : optional, bool.
-            Force killing all RPC server instances, must be used with caution. Default value is `False`.
-
         Returns
         -------
         Database
@@ -97,7 +108,6 @@ class EdbInit(object):
                 edb_version=self.edbversion,
                 port=port,
                 restart_server=restart_rpc_server,
-                kill_all_instances=kill_all_instances,
             )
             if not RpcSession.pid:
                 self.logger.error("Failed to start RPC server.")
@@ -105,7 +115,7 @@ class EdbInit(object):
         self._db = database.Database.create(db_path)
         return self._db
 
-    def open(self, db_path, read_only, port=0, restart_rpc_server=False, kill_all_instances=False):
+    def open(self, db_path, read_only, port=0, restart_rpc_server=False):
         """Open an existing Database at the specified file location.
 
         Parameters
@@ -115,11 +125,9 @@ class EdbInit(object):
         read_only : bool
             Obtain read-only access.
         port : optional, int.
-            Specify the port number.If not provided a randon free one is selected. Default value is `0`.
+            Specify the port number. If not provided a randon free one is selected. Default value is `0`.
         restart_rpc_server : optional, bool
             Force restarting RPC server when `True`. Default value is `False`.
-        kill_all_instances : optional, bool.
-            Force killing all RPC server instances, must be used with caution. Default value is `False`.
 
         Returns
         -------
@@ -133,7 +141,6 @@ class EdbInit(object):
                 edb_version=self.edbversion,
                 port=port,
                 restart_server=restart_rpc_server,
-                kill_all_instances=kill_all_instances,
             )
             if not RpcSession.pid:
                 self.logger.error("Failed to start RPC server.")
@@ -154,7 +161,7 @@ class EdbInit(object):
         """Save any changes into a file."""
         return self._db.save()
 
-    def close(self, terminate_rpc_session=True, kill_all_instances=False):
+    def close(self, terminate_rpc_session=True):
         """Close the database.
 
         Parameters
@@ -167,10 +174,7 @@ class EdbInit(object):
         """
         self._db.close()
         self._db = None
-        if kill_all_instances:
-            RpcSession._kill_all_instances()
-            RpcSession.pid = 0
-        elif terminate_rpc_session:
+        if terminate_rpc_session:
             RpcSession.rpc_session.disconnect()
             RpcSession.pid = 0
         return True

pyedb/grpc/rpc_session.py

@@ -50,7 +50,7 @@ class RpcSession:
     port = 10000
 
     @staticmethod
-    def start(edb_version, port=0, restart_server=False, kill_all_instances=False):
+    def start(edb_version, port=0, restart_server=False):
         """Start RPC-server, the server must be started before opening EDB.
 
         Parameters
@@ -107,10 +107,7 @@ class RpcSession:
         if RpcSession.pid:
             if restart_server:
                 pyedb_logger.logger.info("Restarting RPC server")
-                if kill_all_instances:
-                    RpcSession.__kill_all_instances()
-                else:
-                    RpcSession.__kill()
+                RpcSession.kill()
                 RpcSession.__start_rpc_server()
             else:
                 pyedb_logger.info(f"Server already running on port {RpcSession.port}")
@@ -141,13 +138,18 @@ class RpcSession:
             pyedb_logger.logger.info("Grpc session started")
 
     @staticmethod
-    def __kill():
+    def kill():
         p = psutil.Process(RpcSession.pid)
         time.sleep(latency_delay)
-        p.terminate()
+        try:
+            p.terminate()
+            print(f"RPC session pid: {RpcSession.pid} killed due to execution failure.")
+            RpcSession.pid = 0
+        except:
+            print("RPC session closed.")
 
     @staticmethod
-    def _kill_all_instances():
+    def kill_all_instances():
         proc = [p.pid for p in list(psutil.process_iter()) if "edb_rpc" in p.name().lower()]
         time.sleep(latency_delay)
         for pid in proc:
@@ -163,6 +165,7 @@ class RpcSession:
             end_managing()
             RpcSession.rpc_session.disconnect()
             time.sleep(latency_delay)
+            RpcSession.__get_process_id()
 
     @staticmethod
     def __get_random_free_port():

{pyedb-0.44.0.dist-info → pyedb-0.46.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyedb
-Version: 0.44.0
+Version: 0.46.0
 Summary: Higher-Level Pythonic Ansys Electronics Data Base
 Author-email: "ANSYS, Inc." <pyansys.core@ansys.com>
 Maintainer-email: PyEDB developers <simon.vandenbrouck@ansys.com>
@@ -127,15 +127,15 @@ Documentation for the latest stable release of PyEDB is hosted at
 [PyEDB documentation](https://edb.docs.pyansys.com/version/stable/index.html).
 The documentation has five sections:
 
-- [Getting started](https://edb.docs.pyansys.com/version/version/stable/getting_started/index.html): Describes
+- [Getting started](https://edb.docs.pyansys.com/version/stable/getting_started/index.html): Describes
   how to install PyEDB in user mode.
-- [User guide](https://edb.docs.pyansys.com/version/version/stable/user_guide/index.html): Describes how to
+- [User guide](https://edb.docs.pyansys.com/version/stable/user_guide/index.html#user-guide): Describes how to
   use PyEDB.
-- [API reference](https://edb.docs.pyansys.com/version/version/stable/api/index.html): Provides API member descriptions
+- [API reference](https://edb.docs.pyansys.com/version/stable/api/index.html): Provides API member descriptions
   and usage examples.
-- [Examples](https://edb.docs.pyansys.com/version/version/stable/examples/index.html): Provides examples showing
+- [Examples](https://examples.aedt.docs.pyansys.com/version/dev/examples/high_frequency/layout/index.html): Provides examples showing
   end-to-end workflows for using PyEDB.
-- [Contribute](https://edb.docs.pyansys.com/version/version/stable/contribute.html): Describes how to install
+- [Contribute](https://edb.docs.pyansys.com/version/stable/contributing.html): Describes how to install
   PyEDB in developer mode and how to contribute to this PyAnsys library.
 
 In the upper right corner of the documentation's title bar, there is an option