pyedb 0.37.0__py3-none-any.whl → 0.39.0__py3-none-any.whl

pyedb/configuration/cfg_ports_sources.py

@@ -19,11 +19,14 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
+import os
+
+import numpy as np
 
 from pyedb.configuration.cfg_common import CfgBase
-from pyedb.dotnet.edb_core.edb_data.ports import WavePort
-from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
-from pyedb.dotnet.edb_core.geometry.point_data import PointData
+from pyedb.dotnet.database.edb_data.ports import WavePort
+from pyedb.dotnet.database.general import convert_py_list_to_net_list
+from pyedb.dotnet.database.geometry.point_data import PointData
 
 
 class CfgTerminalInfo(CfgBase):
@@ -31,11 +34,25 @@ class CfgTerminalInfo(CfgBase):
 
     def __init__(self, pedb, **kwargs):
         self._pedb = pedb
-        self.type = list(kwargs.keys())[0]
+        if "pin" in kwargs:
+            self.type = "pin"
+        elif "net" in kwargs:
+            self.type = "net"
+        elif "pin_group" in kwargs:
+            self.type = "pin_group"
+        elif "nearest_pin" in kwargs:
+            self.type = "nearest_pin"
+        elif "coordinates" in kwargs:
+            self.type = "coordinates"
+        else:  # pragma no cover
+            raise RuntimeError
         self.value = kwargs[self.type]
-        self.contact_radius = kwargs.get("contact_radius", None)
-        self.num_of_contact = kwargs.get("num_of_contact", 1)
-        self.inline = kwargs.get("inline", False)
+        self.reference_designator = kwargs.get("reference_designator")
+
+        self.contact_type = kwargs.get("contact_type", "default")  # options are full, center, quad, inline
+        contact_radius = "0.1mm" if kwargs.get("contact_radius") is None else kwargs.get("contact_radius")
+        self.contact_radius = self._pedb.edb_value(contact_radius).ToDouble()
+        self.num_of_contact = kwargs.get("num_of_contact", 4)
 
     def export_properties(self):
         return {self.type: self.value}
@@ -208,6 +225,16 @@ class CfgPorts:
         return ports
 
 
+class CfgProbes:
+    def __init__(self, pedb, data):
+        self._pedb = pedb
+        self.probes = [CfgProbe(self._pedb, **probe) for probe in data]
+
+    def apply(self):
+        for probe in self.probes:
+            probe.api.set_parameters_to_edb()
+
+
 class CfgCircuitElement(CfgBase):
     def __init__(self, pedb, **kwargs):
         self._pedb = pedb
@@ -215,12 +242,15 @@ class CfgCircuitElement(CfgBase):
         self.type = kwargs["type"]
         self.reference_designator = kwargs.get("reference_designator", None)
         self.distributed = kwargs.get("distributed", False)
+        self._elem_num = 1
 
         pos = kwargs["positive_terminal"]  # {"pin" : "A1"}
         if list(pos.keys())[0] == "coordinates":
             self.positive_terminal_info = CfgCoordianteTerminalInfo(self._pedb, **pos)
         else:
             self.positive_terminal_info = CfgTerminalInfo(self._pedb, **pos)
+            if not self.positive_terminal_info.reference_designator:
+                self.positive_terminal_info.reference_designator = self.reference_designator
 
         neg = kwargs.get("negative_terminal", {})
         if len(neg) == 0:
@@ -231,49 +261,83 @@ class CfgCircuitElement(CfgBase):
             self.negative_terminal_info = CfgNearestPinTerminalInfo(self._pedb, **neg)
         else:
             self.negative_terminal_info = CfgTerminalInfo(self._pedb, **neg)
+            if not self.negative_terminal_info.reference_designator:
+                self.negative_terminal_info.reference_designator = self.positive_terminal_info.reference_designator
 
-    def _create_terminals(self):
+    def create_terminals(self):
         """Create step 1. Collect positive and negative terminals."""
 
+        # Collect all positive terminals
         pos_type, pos_value = self.positive_terminal_info.type, self.positive_terminal_info.value
         pos_objs = dict()
         pos_coor_terminal = dict()
         if self.type == "coax":
-            pins = self._get_pins(pos_type, pos_value)
-            pins = {f"{self.name}_{self.reference_designator}": i for _, i in pins.items()}
+            pins = self._get_pins(pos_type, pos_value, self.positive_terminal_info.reference_designator)
+            pins = {f"{self.name}_{self.positive_terminal_info.reference_designator}": i for _, i in pins.items()}
             pos_objs.update(pins)
         elif pos_type == "coordinates":
             layer = self.positive_terminal_info.layer
             point = [self.positive_terminal_info.point_x, self.positive_terminal_info.point_y]
             net_name = self.positive_terminal_info.net
+            if net_name not in self._pedb.nets:
+                self._pedb.nets.find_or_create_net(net_name)
             pos_coor_terminal[self.name] = self._pedb.get_point_terminal(self.name, net_name, point, layer)
 
+        elif pos_type == "pin":
+            pins = {
+                pos_value: self._pedb.components.instances[self.positive_terminal_info.reference_designator].pins[
+                    pos_value
+                ]
+            }
+            if self.positive_terminal_info.contact_type in ["quad", "inline"]:
+                for _, pin in pins.items():
+                    contact_type = self.positive_terminal_info.contact_type
+                    radius = self.positive_terminal_info.contact_radius
+                    num_of_contact = self.positive_terminal_info.num_of_contact
+                    virtual_pins = self._create_virtual_pins_on_pin(pin, contact_type, radius, num_of_contact)
+                    pos_objs.update(virtual_pins)
+                    self._elem_num = len(pos_objs)
+            else:
+                pos_objs.update(pins)
         elif pos_type == "pin_group":
+            pins = self._get_pins(pos_type, pos_value, self.positive_terminal_info.reference_designator)
             if self.distributed:
-                pins = self._get_pins(pos_type, pos_value)
                 pos_objs.update(pins)
                 self._elem_num = len(pos_objs)
+            elif self.positive_terminal_info.contact_type in ["quad", "inline"]:
+                for _, pin in pins.items():
+                    contact_type = self.positive_terminal_info.contact_type
+                    radius = self.positive_terminal_info.contact_radius
+                    num_of_contact = self.positive_terminal_info.num_of_contact
+                    virtual_pins = self._create_virtual_pins_on_pin(pin, contact_type, radius, num_of_contact)
+                    pos_objs.update(virtual_pins)
+                    self._elem_num = len(pos_objs)
             else:
                 pos_objs[pos_value] = self._pedb.siwave.pin_groups[pos_value]
         elif pos_type == "net":
+            pins = self._get_pins(pos_type, pos_value, self.positive_terminal_info.reference_designator)
             if self.distributed:
-                pins = self._get_pins(pos_type, pos_value)
                 pos_objs.update(pins)
                 self._elem_num = len(pos_objs)
+            elif self.positive_terminal_info.contact_type in ["quad", "inline"]:
+                for _, pin in pins.items():
+                    contact_type = self.positive_terminal_info.contact_type
+                    radius = self.positive_terminal_info.contact_radius
+                    num_of_contact = self.positive_terminal_info.num_of_contact
+                    virtual_pins = self._create_virtual_pins_on_pin(pin, contact_type, radius, num_of_contact)
+                    pos_objs.update(virtual_pins)
+                    self._elem_num = len(pos_objs)
             else:
-                pins = self._get_pins(pos_type, pos_value)
                 # create pin group
-                neg_obj = self._create_pin_group(pins)
+                neg_obj = self._create_pin_group(pins, self.positive_terminal_info.reference_designator)
                 pos_objs.update(neg_obj)
-        elif pos_type == "pin":
-            pins = {pos_value: self._pedb.components.instances[self.reference_designator].pins[pos_value]}
-            pos_objs.update(pins)
         else:
             raise Exception(f"Wrong positive terminal type {pos_type}.")
 
         self.pos_terminals = {i: j.create_terminal(i) for i, j in pos_objs.items()}
         self.pos_terminals.update(pos_coor_terminal)
 
+        # Collect all negative terminals
         self.neg_terminal = None
         if self.negative_terminal_info:
             neg_type, neg_value = self.negative_terminal_info.type, self.negative_terminal_info.value
@@ -282,6 +346,8 @@ class CfgCircuitElement(CfgBase):
                 layer = self.negative_terminal_info.layer
                 point = [self.negative_terminal_info.point_x, self.negative_terminal_info.point_y]
                 net_name = self.negative_terminal_info.net
+                if net_name not in self._pedb.nets:
+                    self._pedb.nets.find_or_create_net(net_name)
                 self.neg_terminal = self._pedb.get_point_terminal(self.name + "_ref", net_name, point, layer)
             elif neg_type == "nearest_pin":
                 ref_net = neg_value.get("reference_net", "GND")
@@ -297,13 +363,17 @@ class CfgCircuitElement(CfgBase):
                     neg_obj = {neg_value: self._pedb.siwave.pin_groups[neg_value]}
                 elif neg_type == "net":
                     # Get pins
-                    pins = self._get_pins(neg_type, neg_value)  # terminal type pin or net
+                    pins = self._get_pins(
+                        neg_type, neg_value, self.negative_terminal_info.reference_designator
+                    )  # terminal type pin or net
                     # create pin group
-                    neg_obj = self._create_pin_group(pins, True)
+                    neg_obj = self._create_pin_group(pins, self.negative_terminal_info.reference_designator, True)
                 elif neg_type == "pin":
-                    terminal_name = f"{self.reference_designator}_{neg_value}"
+                    terminal_name = f"{self.negative_terminal_info.reference_designator}_{neg_value}"
                     neg_obj = {
-                        terminal_name: self._pedb.components.instances[self.reference_designator].pins[neg_value]
+                        terminal_name: self._pedb.components.instances[
+                            self.negative_terminal_info.reference_designator
+                        ].pins[neg_value]
                     }
                 else:
                     raise Exception(f"Wrong negative terminal type {neg_type}.")
@@ -311,11 +381,11 @@ class CfgCircuitElement(CfgBase):
                     j.create_terminal(i) if not j.terminal else j.terminal for i, j in neg_obj.items()
                 ][0]
 
-    def _get_pins(self, terminal_type, terminal_value):
+    def _get_pins(self, terminal_type, terminal_value, reference_designator):
         terminal_value = terminal_value if isinstance(terminal_value, list) else [terminal_value]
 
         def get_pin_obj(pin_name):
-            return {pin_name: self._pedb.components.instances[self.reference_designator].pins[pin_name]}
+            return {pin_name: self._pedb.components.instances[reference_designator].pins[pin_name]}
 
         pins = dict()
         if terminal_type == "pin":
@@ -323,20 +393,83 @@ class CfgCircuitElement(CfgBase):
                 pins.update(get_pin_obj(i))
         else:
             if terminal_type == "net":
-                temp = self._pedb.components.get_pins(self.reference_designator, terminal_value[0])
+                temp = self._pedb.components.get_pins(reference_designator, terminal_value[0])
             elif terminal_type == "pin_group":
                 pin_group = self._pedb.siwave.pin_groups[terminal_value[0]]
                 temp = pin_group.pins
-            pins.update({f"{self.reference_designator}_{terminal_value[0]}_{i}": j for i, j in temp.items()})
+            pins.update({f"{reference_designator}_{terminal_value[0]}_{i}": j for i, j in temp.items()})
         return pins
 
-    def _create_pin_group(self, pins, is_ref=False):
+    def _create_virtual_pins_on_pin(self, pin, contact_type, radius, num_of_contact=4):
+        component = pin.component
+        placement_layer = component.placement_layer
+        pos_x, pos_y = pin.position
+        comp_rotation = self._pedb.edb_value(component.rotation).ToDouble() % 3.141592653589793
+
+        pad = pin.definition.pad_by_layer[placement_layer]
+        if pad.shape.lower() in ["rectangle", "oval"]:
+            width, height = pad.parameters_values[0:2]
+        elif pad.shape.lower() == "nogeometry":
+            polygon_data = pad.polygon_data
+            if polygon_data:
+                p1, p2 = polygon_data.bounding_box
+                width = p2[0] - p1[0]
+                height = p2[1] - p1[1]
+            else:
+                raise AttributeError(f"Unsupported pad shape {pad.shape.lower()}")
+        else:  # pragma no cover
+            raise AttributeError(f"Unsupported pad shape {pad.shape.lower()}")
+
+        positions = []
+        if contact_type.lower() == "inline":
+            if width > height:
+                offset = (width - radius * 2) / (num_of_contact - 1)
+            else:
+                offset = (height - radius * 2) / (num_of_contact - 1)
+
+            start_pos = (num_of_contact - 1) / 2
+            offset = [offset * i for i in np.arange(start_pos * -1, start_pos + 1)]
+
+            if (width > height and comp_rotation == 0) or (width < height and comp_rotation != 0):
+                positions.extend(list(zip(offset, [0] * num_of_contact)))
+            else:
+                positions.extend(list(zip([0] * num_of_contact, offset)))
+        else:  # quad
+            x_offset = width / 2 - radius if comp_rotation == 0 else height / 2 - radius
+            y_offset = height / 2 - radius if comp_rotation == 0 else width / 2 - radius
+
+            for x, y in [[1, 1], [-1, 1], [1, -1], [-1, -1]]:
+                positions.append([x_offset * x, y_offset * y])
+
+        pdef_name = f"{self.name}_{pin.pin_number}"
+        self._pedb.padstacks.create(padstackname=pdef_name, has_hole=False, paddiam=radius * 2, antipaddiam=0)
+        instances = {}
+        for idx, xy in enumerate(positions):
+            x = xy[0] + pos_x
+            y = xy[1] + pos_y
+            pin_name = f"{pdef_name}_{idx}"
+            p_inst = self._pedb.padstacks.place(
+                position=[x, y],
+                definition_name=pdef_name,
+                net_name=pin.net_name,
+                via_name=pin_name,
+                fromlayer=placement_layer,
+                tolayer=placement_layer,
+                is_pin=True,
+            )
+            instances[pin_name] = p_inst
+        self._pedb.components.create(
+            pins=list(instances.values()),
+        )
+        return instances
+
+    def _create_pin_group(self, pins, reference_designator, is_ref=False):
         if is_ref:
-            pg_name = f"pg_{self.name}_{self.reference_designator}_ref"
+            pg_name = f"pg_{self.name}_{reference_designator}_ref"
         else:
-            pg_name = f"pg_{self.name}_{self.reference_designator}"
+            pg_name = f"pg_{self.name}_{reference_designator}"
         pin_names = [i.component_pin for i in pins.values()]
-        name, temp = self._pedb.siwave.create_pin_group(self.reference_designator, pin_names, pg_name)
+        name, temp = self._pedb.siwave.create_pin_group(reference_designator, pin_names, pg_name)
         return {name: temp}
 
 
@@ -350,7 +483,7 @@ class CfgPort(CfgCircuitElement):
 
     def set_parameters_to_edb(self):
         """Create port."""
-        self._create_terminals()
+        self.create_terminals()
         is_circuit_port = True if self.type == "circuit" else False
         circuit_elements = []
         for name, j in self.pos_terminals.items():
@@ -382,56 +515,66 @@ class CfgSource(CfgCircuitElement):
         super().__init__(pedb, **kwargs)
 
         self.magnitude = kwargs.get("magnitude", 0.001)
-        self.equipotential = kwargs.get("equipotential", False)
 
     def set_parameters_to_edb(self):
         """Create sources."""
-        self._create_terminals()
+        self.create_terminals()
         # is_circuit_port = True if self.type == "circuit" else False
         circuit_elements = []
-        method = self._pedb.create_current_source if self.type == "current" else self._pedb.create_voltage_source
+        create_xxx_source = (
+            self._pedb.create_current_source if self.type == "current" else self._pedb.create_voltage_source
+        )
         for name, j in self.pos_terminals.items():
             if isinstance(self.neg_terminal, dict):
-                elem = method(j, self.neg_terminal[name])
+                elem = create_xxx_source(j, self.neg_terminal[name])
             else:
-                elem = method(j, self.neg_terminal)
-            if not self.distributed:
+                elem = create_xxx_source(j, self.neg_terminal)
+            if self._elem_num == 1:
                 elem.name = self.name
                 elem.magnitude = self.magnitude
             else:
-                elem.name = f"{self.name}_{elem.name}"
+                elem.name = name
                 elem.magnitude = self.magnitude / self._elem_num
+            elem = self._pedb.terminals[elem.name]
             circuit_elements.append(elem)
-        for terminal in circuit_elements:
-            if self.equipotential:
-                terms = [terminal, terminal.ref_terminal] if terminal.ref_terminal else [terminal]
-                for t in terms:
-                    if not t.is_reference_terminal:
-                        radius = self.positive_terminal_info.contact_radius
-                        num_of_contact = self.positive_terminal_info.num_of_contact
-                        inline = self.positive_terminal_info.inline
-                    else:
-                        radius = self.negative_terminal_info.contact_radius
-                        num_of_contact = self.negative_terminal_info.num_of_contact
-                        inline = self.negative_terminal_info.inline
-
-                    pads = []
-                    if t.terminal_type == "PadstackInstanceTerminal":
-                        pads.append(t.reference_object)
-                    elif t.terminal_type == "PinGroupTerminal":
-                        name = t._edb_object.GetPinGroup().GetName()
-                        pg = self._pedb.siwave.pin_groups[name]
-                        pads.extend([i for _, i in pg.pins.items()])
-                    elif t.terminal_type == "PointTerminal" and radius:
-                        temp = [i for i in self._pedb.layout.terminals if i.name == t.name][0]
-                        if radius is not None:
-                            prim = self._pedb.modeler.create_circle(
-                                temp.layer.name, temp.location[0], temp.location[1], radius, temp.net_name
-                            )
-                            prim.dcir_equipotential_region = True
 
+        for terminal in circuit_elements:
+            # Get reference terminal
+            terms = [terminal, terminal.ref_terminal] if terminal.ref_terminal else [terminal]
+            for t in terms:
+                if not t.is_reference_terminal:
+                    radius = self.positive_terminal_info.contact_radius
+                    contact_type = self.positive_terminal_info.contact_type
+                else:
+                    radius = self.negative_terminal_info.contact_radius
+                    contact_type = self.negative_terminal_info.contact_type
+                if t.terminal_type == "PointTerminal":
+                    temp = [i for i in self._pedb.layout.terminals if i.name == t.name][0]
+                    prim = self._pedb.modeler.create_circle(
+                        temp.layer.name, temp.location[0], temp.location[1], radius, temp.net_name
+                    )
+                    prim.dcir_equipotential_region = True
+                    continue
+                elif contact_type.lower() == "default":
+                    continue
+                elif t.terminal_type == "PadstackInstanceTerminal":
+                    if contact_type.lower() in ["full", "quad", "inline"]:
+                        t.padstack_instance._set_equipotential()
+                    elif contact_type.lower() == "center":
+                        t.padstack_instance._set_equipotential(contact_radius=radius)
+                elif t.terminal_type == "PinGroupTerminal":
+                    name = t._edb_object.GetPinGroup().GetName()
+                    pg = self._pedb.siwave.pin_groups[name]
+                    pads = [i for _, i in pg.pins.items()]
                     for i in pads:
-                        i._set_equipotential(contact_radius=radius, inline=inline, num_of_contact=num_of_contact)
+                        if contact_type.lower() in ["full", "quad", "inline"]:
+                            i._set_equipotential()
+                        elif contact_type.lower() == "center":
+                            i._set_equipotential(contact_radius=radius)
+                        elif t.is_reference_terminal:
+                            continue
+                else:
+                    raise AttributeError("Unsupported terminal type.")
 
         return circuit_elements
 
@@ -446,6 +589,41 @@ class CfgSource(CfgCircuitElement):
         }
 
 
+class CfgProbe(CfgCircuitElement):
+    class Common:
+        def __init__(self, parent):
+            self.parent = parent
+            self.pedb = parent._pedb
+
+        def set_parameters_to_edb(self):
+            self.parent.create_terminals()
+            circuit_elements = []
+            for name, j in self.parent.pos_terminals.items():
+                if isinstance(self.parent.neg_terminal, dict):
+                    elem = self.pedb.create_voltage_probe(j, self.parent.neg_terminal[name])
+                else:
+                    elem = self.pedb.create_voltage_probe(j, self.parent.neg_terminal)
+                elem.name = self.parent.name
+                circuit_elements.append(elem)
+            return circuit_elements
+
+    class Grpc(Common):
+        def __init__(self, parent):
+            super().__init__(parent)
+
+    class DotNet(Grpc):
+        def __init__(self, parent):
+            super().__init__(parent)
+
+    def __init__(self, pedb, **kwargs):
+        kwargs["type"] = "probe"
+        super().__init__(pedb, **kwargs)
+        if os.environ["PYEDB_USE_DOTNET"] == "0":
+            self.api = self.Grpc(self)
+        else:
+            self.api = self.DotNet(self)
+
+
 class CfgWavePort:
     def __init__(self, pedb, **kwargs):
         self._pedb = pedb

pyedb/configuration/configuration.py

@@ -27,7 +27,7 @@ from pathlib import Path
 import toml
 
 from pyedb.configuration.cfg_data import CfgData
-from pyedb.dotnet.edb_core.definition.package_def import PackageDef
+from pyedb.dotnet.database.definition.package_def import PackageDef
 
 
 class Configuration:
@@ -140,13 +140,30 @@ class Configuration:
             temp = []
             for _, pdef in pedb_defs.items():
                 cfg_def = CfgPadstackDefinition(self._pedb, pdef)
-                cfg_def.retrieve_parameters_from_edb()
+                cfg_def.api.retrieve_parameters_from_edb()
                 temp.append(cfg_def)
             self.cfg_data.stackup.apply()
             for cfg_pdef in temp:
-                cfg_pdef.set_parameters_to_edb()
+                cfg_pdef.api.set_parameters_to_edb()
         else:
+            temp_pdef_data = {}
+            for pdef_name, pdef in self._pedb.padstacks.definitions.items():
+                pdef_data = pdef._padstack_def_data
+                for lyr_name in list(pdef_data.GetLayerNames()):
+                    result = pdef_data.GetPadParametersValue(lyr_name, self._pedb._edb.Definition.PadType.RegularPad)
+                    flag, pad_shape, params, offset_x, offset_y, rotation = result
+                    if flag is False:
+                        result = pdef_data.GetPolygonalPadParameters(
+                            lyr_name, self._pedb._edb.Definition.PadType.RegularPad
+                        )
+                        flag, polygon_data, offset_x, offset_y, rotation = result
+                        if flag:
+                            temp_pdef_data[pdef_name] = pdef_data
+                            break
             self.cfg_data.stackup.apply()
+            for pdef_name, pdef_data in temp_pdef_data.items():
+                pdef = self._pedb.padstacks.definitions[pdef_name]
+                pdef._padstack_def_data = pdef_data
 
         # Configure padstacks
         if self.cfg_data.padstacks:
@@ -171,6 +188,9 @@ class Configuration:
         # Configure ports
         self.cfg_data.ports.apply()
 
+        # Configure probes
+        self.cfg_data.probes.apply()
+
         return True
 
     def _load_stackup(self):

pyedb/dotnet/{application → database}/Variables.py

@@ -368,7 +368,7 @@ class VariableManager(object):
     This class provides access to all variables or a subset of the
     variables. Manipulation of the numerical or string definitions of
     variable values is provided in the
-    :class:`pyedb.dotnet.application.Variables.Variable` class.
+    :class:`pyedb.dotnet.database.Variables.Variable` class.
 
     Parameters
     ----------
@@ -410,7 +410,7 @@ class VariableManager(object):
 
     See Also
     --------
-    pyedb.dotnet.application.Variables.Variable
+    pyedb.dotnet.database.Variables.Variable
 
     Examples
     --------
@@ -434,23 +434,23 @@ class VariableManager(object):
     Get a dictionary of all project and design variables.
 
     >>> v.variables
-    {'Var1': <pyedb.dotnet.application.Variables.Variable at 0x2661f34c448>,
-     'Var2': <pyedb.dotnet.application.Variables.Variable at 0x2661f34c308>,
-     'Var3': <pyedb.dotnet.application.Variables.Expression at 0x2661f34cb48>,
-     '$PrjVar1': <pyedb.dotnet.application.Variables.Expression at 0x2661f34cc48>}
+    {'Var1': <pyedb.dotnet.database.Variables.Variable at 0x2661f34c448>,
+     'Var2': <pyedb.dotnet.database.Variables.Variable at 0x2661f34c308>,
+     'Var3': <pyedb.dotnet.database.Variables.Expression at 0x2661f34cb48>,
+     '$PrjVar1': <pyedb.dotnet.database.Variables.Expression at 0x2661f34cc48>}
 
     Get a dictionary of only the design variables.
 
     >>> v.design_variables
-    {'Var1': <pyedb.dotnet.application.Variables.Variable at 0x2661f339508>,
-     'Var2': <pyedb.dotnet.application.Variables.Variable at 0x2661f3415c8>,
-     'Var3': <pyedb.dotnet.application.Variables.Expression at 0x2661f341808>}
+    {'Var1': <pyedb.dotnet.database.Variables.Variable at 0x2661f339508>,
+     'Var2': <pyedb.dotnet.database.Variables.Variable at 0x2661f3415c8>,
+     'Var3': <pyedb.dotnet.database.Variables.Expression at 0x2661f341808>}
 
     Get a dictionary of only the independent design variables.
 
     >>> v.independent_design_variables
-    {'Var1': <pyedb.dotnet.application.Variables.Variable at 0x2661f335d08>,
-     'Var2': <pyedb.dotnet.application.Variables.Variable at 0x2661f3557c8>}
+    {'Var1': <pyedb.dotnet.database.Variables.Variable at 0x2661f335d08>,
+     'Var2': <pyedb.dotnet.database.Variables.Variable at 0x2661f3557c8>}
 
     """
 
@@ -1287,7 +1287,7 @@ class Variable(object):
     Examples
     --------
 
-    >>> from pyedb.dotnet.application.Variables import Variable
+    >>> from pyedb.dotnet.database.Variables import Variable
 
     Define a variable using a string value consistent with the AEDT properties.
 
@@ -1719,7 +1719,7 @@ class Variable(object):
 
         Examples
         --------
-        >>> from pyedb.dotnet.application.Variables import Variable
+        >>> from pyedb.dotnet.database.Variables import Variable
 
         >>> v = Variable("10W")
         >>> assert v.numeric_value == 10
@@ -1752,7 +1752,7 @@ class Variable(object):
 
         Examples
         --------
-        >>> from pyedb.dotnet.application.Variables import Variable
+        >>> from pyedb.dotnet.database.Variables import Variable
 
         >>> v = Variable("10W")
         >>> assert v.format("f") == '10.000000W'
@@ -1777,7 +1777,7 @@ class Variable(object):
 
         Examples
         --------
-        >>> from pyedb.dotnet.application.Variables import Variable
+        >>> from pyedb.dotnet.database.Variables import Variable
 
         Multiply ``'Length1'`` by unitless ``'None'``` to obtain ``'Length'``.
         A numerical value is also considered to be unitless.
@@ -1827,7 +1827,7 @@ class Variable(object):
 
         Parameters
         ----------
-        other : class:`pyedb.dotnet.application.Variables.Variable`
+        other : class:`pyedb.dotnet.database.Variables.Variable`
             Object to be multiplied.
 
         Returns
@@ -1837,7 +1837,7 @@ class Variable(object):
 
         Examples
         --------
-        >>> from pyedb.dotnet.application.Variables import Variable
+        >>> from pyedb.dotnet.database.Variables import Variable
         >>> import ansys.aedt.core.generic.constants
         >>> v1 = Variable("3mA")
         >>> v2 = Variable("10A")
@@ -1867,7 +1867,7 @@ class Variable(object):
 
         Parameters
         ----------
-        other : class:`pyedb.dotnet.application.Variables.Variable`
+        other : class:`pyedb.dotnet.database.Variables.Variable`
             Object to be subtracted.
 
         Returns
@@ -1879,7 +1879,7 @@ class Variable(object):
         --------
 
         >>> import ansys.aedt.core.generic.constants
-        >>> from pyedb.dotnet.application.Variables import Variable
+        >>> from pyedb.dotnet.database.Variables import Variable
         >>> v3 = Variable("3mA")
         >>> v4 = Variable("10A")
         >>> result_2 = v3 - v4
@@ -1923,7 +1923,7 @@ class Variable(object):
         Divide a variable with units ``"W"`` by a variable with units ``"V"`` and automatically
         resolve the new units to ``"A"``.
 
-        >>> from pyedb.dotnet.application.Variables import Variable
+        >>> from pyedb.dotnet.database.Variables import Variable
         >>> import ansys.aedt.core.generic.constants
         >>> v1 = Variable("10W")
         >>> v2 = Variable("40V")
@@ -1967,7 +1967,7 @@ class Variable(object):
         the result is in ``"Hz"``.
 
         >>> import ansys.aedt.core.generic.constants
-        >>> from pyedb.dotnet.application.Variables import Variable
+        >>> from pyedb.dotnet.database.Variables import Variable
         >>> v = Variable("1s")
         >>> result = 3.0 / v
         >>> assert result.numeric_value == 3.0