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

pyedb/dotnet/database/edb_data/padstacks_data.py

@@ -1696,9 +1696,9 @@ class EDBPadstackInstance(Primitive):
         out = self._edb_padstackinstance.GetPositionAndRotationValue()
         if self._edb_padstackinstance.GetComponent():
             out2 = self._edb_padstackinstance.GetComponent().GetTransform().TransformPoint(out[1])
-            self._position = [out2.X.ToDouble(), out2.Y.ToDouble()]
+            self._position = [round(out2.X.ToDouble(), 6), round(out2.Y.ToDouble(), 6)]
         elif out[0]:
-            self._position = [out[1].X.ToDouble(), out[1].Y.ToDouble()]
+            self._position = [round(out[1].X.ToDouble(), 6), round(out[1].Y.ToDouble(), 6)]
         return self._position
 
     @position.setter
@@ -1724,7 +1724,7 @@ class EDBPadstackInstance(Primitive):
         out = self._edb_padstackinstance.GetPositionAndRotationValue()
 
         if out[0]:
-            return out[2].ToDouble()
+            return round(out[2].ToDouble(), 6)
 
     @property
     def name(self):
@@ -1894,7 +1894,7 @@ class EDBPadstackInstance(Primitive):
             Lower elavation of the placement layer.
         """
         try:
-            return self._edb_padstackinstance.GetGroup().GetPlacementLayer().Clone().GetLowerElevation()
+            return round(self._edb_padstackinstance.GetGroup().GetPlacementLayer().Clone().GetLowerElevation(), 6)
         except AttributeError:  # pragma: no cover
             return None
 
@@ -1908,7 +1908,7 @@ class EDBPadstackInstance(Primitive):
            Upper elevation of the placement layer.
         """
         try:
-            return self._edb_padstackinstance.GetGroup().GetPlacementLayer().Clone().GetUpperElevation()
+            return round(self._edb_padstackinstance.GetGroup().GetPlacementLayer().Clone().GetUpperElevation(), 6)
         except AttributeError:  # pragma: no cover
             return None
 

pyedb/dotnet/database/edb_data/primitives_data.py

@@ -522,9 +522,9 @@ class EDBArcs(object):
             xt, yt = self._app._active_cell.primitive._get_points_for_plot(my_net_points, arc_segments)
             if not xt:
                 return []
-            x, y = GeometryOperators.orient_polygon(xt, yt, clockwise=True)
-            return x, y
+            x, y = list(GeometryOperators.orient_polygon(xt, yt, clockwise=True))
+            return [x, y]
         except:
             x = []
             y = []
-        return x, y
+        return [x, y]

pyedb/dotnet/database/edb_data/variables.py

@@ -57,7 +57,7 @@ class Variable:
         str
 
         """
-        return self._pedb.get_variable(self.name).tostring
+        return self._var_server.GetVariableValue(self.name)[1].ToString()
 
     @property
     def value_object(self):
@@ -77,11 +77,11 @@ class Variable:
         -------
         float
         """
-        return self._pedb.get_variable(self.name).tofloat
+        return self._var_server.GetVariableValue(self.name)[1].ToDouble()
 
     @value.setter
     def value(self, value):
-        self._pedb.change_design_variable_value(self.name, value)
+        self._var_server.SetVariableValue(self.name, self._pedb.edb_value(value))
 
     @property
     def description(self):

pyedb/dotnet/database/geometry/polygon_data.py

@@ -20,6 +20,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 from typing import Union
+import warnings
 
 from pyedb.dotnet.database.general import convert_py_list_to_net_list
 from pyedb.dotnet.database.geometry.point_data import PointData
@@ -132,10 +133,22 @@ class PolygonData:
         poly = self._edb_object.CreateFromArcs(arcs, flag)
         return PolygonData(self._pedb, poly)
 
-    def point_in_polygon(self, x: Union[str, float], y: Union[str, float]) -> bool:
+    def is_inside(self, x: Union[str, float], y: Union[str, float] = None) -> bool:
         """Determines whether a point is inside the polygon."""
+        if isinstance(x, list) and len(x) == 2:
+            y = x[1]
+            x = x[0]
         return self._edb_object.PointInPolygon(self._pedb.point_data(x, y))
 
+    def point_in_polygon(self, x: Union[str, float], y: Union[str, float] = None) -> bool:
+        """Determines whether a point is inside the polygon.
+
+        ..deprecated:: 0.48.0
+           Use: func:`is_inside` instead.
+        """
+        warnings.warn("Use method is_inside instead", DeprecationWarning)
+        return self.is_inside(x, y)
+
     def get_point(self, index):
         """Gets the point at the index as a PointData object."""
         edb_object = self._edb_object.GetPoint(index)

pyedb/dotnet/database/materials.py

@@ -88,22 +88,22 @@ def get_line_float_value(line):
 class MaterialProperties(BaseModel):
     """Store material properties."""
 
-    conductivity: Optional[PositiveFloat] = None
-    dielectric_loss_tangent: Optional[PositiveFloat] = None
-    magnetic_loss_tangent: Optional[PositiveFloat] = None
-    mass_density: Optional[PositiveFloat] = None
-    permittivity: Optional[PositiveFloat] = None
-    permeability: Optional[PositiveFloat] = None
-    poisson_ratio: Optional[PositiveFloat] = None
-    specific_heat: Optional[PositiveFloat] = None
-    thermal_conductivity: Optional[PositiveFloat] = None
-    youngs_modulus: Optional[PositiveFloat] = None
-    thermal_expansion_coefficient: Optional[PositiveFloat] = None
-    dc_conductivity: Optional[PositiveFloat] = None
-    dc_permittivity: Optional[PositiveFloat] = None
-    dielectric_model_frequency: Optional[PositiveFloat] = None
-    loss_tangent_at_frequency: Optional[PositiveFloat] = None
-    permittivity_at_frequency: Optional[PositiveFloat] = None
+    conductivity: Optional[PositiveFloat] = 0.0
+    dielectric_loss_tangent: Optional[PositiveFloat] = 0.0
+    magnetic_loss_tangent: Optional[PositiveFloat] = 0.0
+    mass_density: Optional[PositiveFloat] = 0.0
+    permittivity: Optional[PositiveFloat] = 0.0
+    permeability: Optional[PositiveFloat] = 0.0
+    poisson_ratio: Optional[PositiveFloat] = 0.0
+    specific_heat: Optional[PositiveFloat] = 0.0
+    thermal_conductivity: Optional[PositiveFloat] = 0.0
+    youngs_modulus: Optional[PositiveFloat] = 0.0
+    thermal_expansion_coefficient: Optional[PositiveFloat] = 0.0
+    dc_conductivity: Optional[PositiveFloat] = 0.0
+    dc_permittivity: Optional[PositiveFloat] = 0.0
+    dielectric_model_frequency: Optional[PositiveFloat] = 0.0
+    loss_tangent_at_frequency: Optional[PositiveFloat] = 0.0
+    permittivity_at_frequency: Optional[PositiveFloat] = 0.0
 
 
 class Material(object):

pyedb/dotnet/database/modeler.py

@@ -455,9 +455,16 @@ class Modeler(object):
                 xcoeff = str(xcoeff)
             return xcoeff, ycoeff
 
+        from pyedb.dotnet.database.edb_data.primitives_data import EdbPolygon
+
+        if isinstance(selection_polygon, EdbPolygon):
+            selection_polygon = selection_polygon._edb_object
+        if isinstance(polygon, EdbPolygon):
+            polygon = polygon._edb_object
+
         selection_polygon_data = selection_polygon.GetPolygonData()
-        poligon_data = polygon.GetPolygonData()
-        bound_center = poligon_data.GetBoundingCircleCenter()
+        polygon_data = polygon.GetPolygonData()
+        bound_center = polygon_data.GetBoundingCircleCenter()
         bound_center2 = selection_polygon_data.GetBoundingCircleCenter()
         center = [bound_center.X.ToDouble(), bound_center.Y.ToDouble()]
         center2 = [bound_center2.X.ToDouble(), bound_center2.Y.ToDouble()]
@@ -471,7 +478,7 @@ class Modeler(object):
         prev_point = None
         while continue_iterate:
             try:
-                point = poligon_data.GetPoint(i)
+                point = polygon_data.GetPoint(i)
                 if prev_point != point:
                     check_inside = selection_polygon_data.PointInPolygon(point)
                     if check_inside:
@@ -481,14 +488,14 @@ class Modeler(object):
                             point.X.ToString() + "{}*{}".format(xcoeff, offset_name),
                             point.Y.ToString() + "{}*{}".format(ycoeff, offset_name),
                         )
-                        poligon_data.SetPoint(i, new_points)
+                        polygon_data.SetPoint(i, new_points)
                     prev_point = point
                     i += 1
                 else:
                     continue_iterate = False
             except:
                 continue_iterate = False
-        polygon.SetPolygonData(poligon_data)
+        polygon.SetPolygonData(polygon_data)
         return True
 
     def _create_path(
@@ -622,7 +629,7 @@ class Modeler(object):
 
         return primitive
 
-    def create_polygon(self, main_shape, layer_name, voids=[], net_name=""):
+    def create_polygon(self, main_shape=None, layer_name="", voids=[], net_name="", points=None):
         """Create a polygon based on a list of points and voids.
 
         Parameters
@@ -639,13 +646,40 @@ class Modeler(object):
             List of shape objects for voids or points that creates the shapes. The default is``[]``.
         net_name : str, optional
             Name of the net. The default is ``""``.
+        points : list, optional
+            Added for compatibility with grpc.
 
         Returns
         -------
         bool, :class:`dotnet.database.edb_data.primitives.Primitive`
             Polygon when successful, ``False`` when failed.
         """
+        from pyedb.dotnet.database.geometry.polygon_data import PolygonData
+
+        if main_shape:
+            warnings.warn(
+                "main_shape argument will be deprecated soon with grpc version, use points instead.", DeprecationWarning
+            )
+
         net = self._pedb.nets.find_or_create_net(net_name)
+        if points:
+            arcs = []
+            if isinstance(points, PolygonData):
+                points = points.points
+            for _ in range(len(points)):
+                arcs.append(
+                    self._edb.Geometry.ArcData(
+                        self._pedb.point_data(0, 0),
+                        self._pedb.point_data(0, 0),
+                    )
+                )
+            polygonData = self._edb.Geometry.PolygonData.CreateFromArcs(convert_py_list_to_net_list(arcs), True)
+
+            for idx, i in enumerate(points):
+                pdata_0 = self._pedb.edb_value(i[0])
+                pdata_1 = self._pedb.edb_value(i[1])
+                new_points = self._edb.Geometry.PointData(pdata_0, pdata_1)
+                polygonData.SetPoint(idx, new_points)
         if isinstance(main_shape, list):
             arcs = []
             for _ in range(len(main_shape)):
@@ -666,9 +700,14 @@ class Modeler(object):
         elif isinstance(main_shape, Modeler.Shape):
             polygonData = self.shape_to_polygon_data(main_shape)
         else:
-            polygonData = main_shape
-        if not polygonData or polygonData.IsNull():
-            raise RuntimeError("Failed to create main shape polygon data")
+            if not points:
+                polygonData = main_shape
+        if isinstance(polygonData, PolygonData):
+            if not polygonData.points:
+                raise RuntimeError("Failed to create main shape polygon data")
+        else:
+            if polygonData.IsNull():
+                raise RuntimeError("Failed to create main shape polygon data")
         for void in voids:
             if isinstance(void, list):
                 void = self.Shape("polygon", points=void)
@@ -682,6 +721,8 @@ class Modeler(object):
                 self._logger.error("Failed to create void polygon data")
                 return False
             polygonData.AddHole(voidPolygonData)
+        if isinstance(polygonData, PolygonData):
+            polygonData = polygonData._edb_object
         polygon = self._pedb._edb.Cell.Primitive.Polygon.Create(
             self._active_layout, layer_name, net.net_obj, polygonData
         )

pyedb/dotnet/database/padstack.py

@@ -629,9 +629,11 @@ class EdbPadstacks(object):
         if "PadstackDef" in str(type(pin)):
             padparams = pin.GetData().GetPadParametersValue(layername, self.int_to_pad_type(pad_type))
         else:
-            padparams = self._edb.definition.PadstackDefData(pin.GetPadstackDef().GetData()).GetPadParametersValue(
-                layername, self.int_to_pad_type(pad_type)
-            )
+            if not isinstance(pin, EDBPadstackInstance):
+                pin = EDBPadstackInstance(pin, self._pedb)
+            padparams = self._edb.definition.PadstackDefData(
+                pin._edb_object.GetPadstackDef().GetData()
+            ).GetPadParametersValue(layername, self.int_to_pad_type(pad_type))
         if padparams[2]:
             geometry_type = int(padparams[1])
             parameters = [i.ToString() for i in padparams[2]]
@@ -646,7 +648,7 @@ class EdbPadstacks(object):
                 )
             else:
                 padparams = self._edb.definition.PadstackDefData(
-                    pin.GetPadstackDef().GetData()
+                    pin._edb_object.GetPadstackDef().GetData()
                 ).GetPolygonalPadParameters(layername, self.int_to_pad_type(pad_type))
 
             if padparams[0]:
@@ -1076,7 +1078,7 @@ class EdbPadstacks(object):
         return padstackname
 
     def _get_pin_layer_range(self, pin):
-        res, fromlayer, tolayer = pin.GetLayerRange()
+        res, fromlayer, tolayer = pin._edb_object.GetLayerRange()
         if res:
             return fromlayer, tolayer
         else:

pyedb/dotnet/database/sim_setup_data/data/settings.py

@@ -289,6 +289,34 @@ class AdaptiveSettings(object):
         self.adaptive_settings.AdaptiveFrequencyDataList.Add(high_freq_adapt_data)
         return self._parent._update_setup()
 
+    def add_multi_frequency_adaptive_setup(self, freq_list, max_num_passes=10, max_delta_s=0.02):
+        """Add a setup for frequency data.
+
+        Parameters
+        ----------
+        low_frequency : str, float
+            Frequency with units or float frequency (in Hz).
+        high_frequency : str, float
+            Frequency with units or float frequency (in Hz).
+        max_num_passes : int, optional
+            Maximum number of passes. The default is ``10``.
+        max_delta_s : float, optional
+            Maximum delta S. The default is ``0.02``.
+
+        Returns
+        -------
+        bool
+            ``True`` if method is successful, ``False`` otherwise.
+        """
+        self.adaptive_settings.AdaptiveFrequencyDataList.Clear()
+        for i in freq_list:
+            low_freq_adapt_data = self._parent._pedb.simsetupdata.AdaptiveFrequencyData()
+            low_freq_adapt_data.MaxDelta = self._parent._pedb.edb_value(max_delta_s).ToString()
+            low_freq_adapt_data.MaxPasses = max_num_passes
+            low_freq_adapt_data.AdaptiveFrequency = self._parent._pedb.edb_value(i).ToString()
+            self.adaptive_settings.AdaptiveFrequencyDataList.Add(low_freq_adapt_data)
+        return self._parent._update_setup()
+
 
 class DefeatureSettings(object):
     """Manages EDB methods for defeature settings."""

pyedb/dotnet/database/siwave.py

@@ -261,21 +261,25 @@ class EdbSiwave(object):
         >>> edbapp.siwave.create_circuit_port_on_pin(pins[0], pins[1], 50, "port_name")
         """
         circuit_port = CircuitPort()
-        circuit_port.positive_node.net = pos_pin.GetNet().GetName()
-        circuit_port.negative_node.net = neg_pin.GetNet().GetName()
+        if not isinstance(pos_pin, EDBPadstackInstance):
+            pos_pin = EDBPadstackInstance(pos_pin, self._pedb)
+        if not isinstance(neg_pin, EDBPadstackInstance):
+            neg_pin = EDBPadstackInstance(neg_pin, self._pedb)
+        circuit_port.positive_node.net = pos_pin.net_name
+        circuit_port.negative_node.net = neg_pin.net_name
         circuit_port.impedance = impedance
 
         if not port_name:
             port_name = "Port_{}_{}_{}_{}".format(
-                pos_pin.GetComponent().GetName(),
-                pos_pin.GetNet().GetName(),
-                neg_pin.GetComponent().GetName(),
-                neg_pin.GetNet().GetName(),
+                pos_pin.component.name,
+                pos_pin.net_name,
+                neg_pin.component.name,
+                neg_pin.net_name,
             )
         circuit_port.name = port_name
-        circuit_port.positive_node.component_node = pos_pin.GetComponent()
+        circuit_port.positive_node.component_node = pos_pin.component
         circuit_port.positive_node.node_pins = pos_pin
-        circuit_port.negative_node.component_node = neg_pin.GetComponent()
+        circuit_port.negative_node.component_node = neg_pin.component
         circuit_port.negative_node.node_pins = neg_pin
         return self._create_terminal_on_pins(circuit_port)
 
@@ -386,21 +390,21 @@ class EdbSiwave(object):
         """
 
         voltage_source = VoltageSource()
-        voltage_source.positive_node.net = pos_pin.GetNet().GetName()
-        voltage_source.negative_node.net = neg_pin.GetNet().GetName()
+        voltage_source.positive_node.net = pos_pin.net_name
+        voltage_source.negative_node.net = neg_pin.net_name
         voltage_source.magnitude = voltage_value
         voltage_source.phase = phase_value
         if not source_name:
             source_name = "VSource_{}_{}_{}_{}".format(
-                pos_pin.GetComponent().GetName(),
-                pos_pin.GetNet().GetName(),
-                neg_pin.GetComponent().GetName(),
-                neg_pin.GetNet().GetName(),
+                pos_pin.component.name,
+                pos_pin.net_name,
+                neg_pin.component.name,
+                neg_pin.net_name,
             )
         voltage_source.name = source_name
-        voltage_source.positive_node.component_node = pos_pin.GetComponent()
+        voltage_source.positive_node.component_node = pos_pin.component
         voltage_source.positive_node.node_pins = pos_pin
-        voltage_source.negative_node.component_node = neg_pin.GetComponent()
+        voltage_source.negative_node.component_node = neg_pin.component
         voltage_source.negative_node.node_pins = neg_pin
         return self._create_terminal_on_pins(voltage_source)
 
@@ -434,21 +438,21 @@ class EdbSiwave(object):
         >>> edbapp.siwave.create_current_source_on_pin(pins[0], pins[1], 50, "source_name")
         """
         current_source = CurrentSource()
-        current_source.positive_node.net = pos_pin.GetNet().GetName()
-        current_source.negative_node.net = neg_pin.GetNet().GetName()
+        current_source.positive_node.net = pos_pin.net_name
+        current_source.negative_node.net = neg_pin.net_name
         current_source.magnitude = current_value
         current_source.phase = phase_value
         if not source_name:
             source_name = "ISource_{}_{}_{}_{}".format(
-                pos_pin.GetComponent().GetName(),
-                pos_pin.GetNet().GetName(),
-                neg_pin.GetComponent().GetName(),
-                neg_pin.GetNet().GetName(),
+                pos_pin.component.name,
+                pos_pin.net_name,
+                neg_pin.component.name,
+                neg_pin.net_name,
             )
         current_source.name = source_name
-        current_source.positive_node.component_node = pos_pin.GetComponent()
+        current_source.positive_node.component_node = pos_pin.component
         current_source.positive_node.node_pins = pos_pin
-        current_source.negative_node.component_node = neg_pin.GetComponent()
+        current_source.negative_node.component_node = neg_pin.component
         current_source.negative_node.node_pins = neg_pin
         return self._create_terminal_on_pins(current_source)
 
@@ -480,20 +484,20 @@ class EdbSiwave(object):
         >>> edbapp.siwave.create_resistor_on_pin(pins[0], pins[1],50,"res_name")
         """
         resistor = ResistorSource()
-        resistor.positive_node.net = pos_pin.GetNet().GetName()
-        resistor.negative_node.net = neg_pin.GetNet().GetName()
+        resistor.positive_node.net = pos_pin.net_name
+        resistor.negative_node.net = neg_pin.net_name
         resistor.rvalue = rvalue
         if not resistor_name:
             resistor_name = "Res_{}_{}_{}_{}".format(
-                pos_pin.GetComponent().GetName(),
-                pos_pin.GetNet().GetName(),
-                neg_pin.GetComponent().GetName(),
-                neg_pin.GetNet().GetName(),
+                pos_pin.component.name,
+                pos_pin.net_name,
+                neg_pin.component.name,
+                neg_pin.net_name,
             )
         resistor.name = resistor_name
-        resistor.positive_node.component_node = pos_pin.GetComponent()
+        resistor.positive_node.component_node = pos_pin.component
         resistor.positive_node.node_pins = pos_pin
-        resistor.negative_node.component_node = neg_pin.GetComponent()
+        resistor.negative_node.component_node = neg_pin.component
         resistor.negative_node.node_pins = neg_pin
         return self._create_terminal_on_pins(resistor)
 

pyedb/dotnet/database/stackup.py

@@ -885,6 +885,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]
         self.refresh_layer_collection()
         return self.layers[layer_name]
 

pyedb/dotnet/database/utilities/hfss_simulation_setup.py

@@ -310,7 +310,7 @@ class HfssSimulationSetup(SimulationSetup):
         self._update_setup()
         return mesh_operation
 
-    def set_solution_single_frequency(self, frequency="5GHz", max_num_passes=10, max_delta_s=0.02):
+    def set_solution_single_frequency(self, frequency="5Ghz", max_num_passes=10, max_delta_s=0.02):
         """Set single-frequency solution.
 
         Parameters
@@ -331,7 +331,7 @@ class HfssSimulationSetup(SimulationSetup):
         self.adaptive_settings.adaptive_settings.AdaptiveFrequencyDataList.Clear()
         return self.adaptive_settings.add_adaptive_frequency_data(frequency, max_num_passes, max_delta_s)
 
-    def set_solution_multi_frequencies(self, frequencies=("5GHz", "10GHz"), max_num_passes=10, max_delta_s="0.02"):
+    def set_solution_multi_frequencies(self, frequencies=("5Ghz", "10Ghz"), max_num_passes=10, max_delta_s="0.02"):
         """Set multi-frequency solution.
 
         Parameters
@@ -350,13 +350,12 @@ class HfssSimulationSetup(SimulationSetup):
         """
         self.adaptive_settings.adapt_type = "kMultiFrequencies"
         self.adaptive_settings.adaptive_settings.AdaptiveFrequencyDataList.Clear()
-        for i in frequencies:
-            if not self.adaptive_settings.add_adaptive_frequency_data(i, max_num_passes, max_delta_s):
-                return False
+        if not self.adaptive_settings.add_multi_frequency_adaptive_setup(frequencies, max_num_passes, max_delta_s):
+            return False
         return True
 
     def set_solution_broadband(
-        self, low_frequency="5GHz", high_frequency="10GHz", max_num_passes=10, max_delta_s="0.02"
+        self, low_frequency="5Ghz", high_frequency="10Ghz", max_num_passes=10, max_delta_s="0.02"
     ):
         """Set broadband solution.
 

pyedb/dotnet/database/utilities/siwave_simulation_setup.py

@@ -269,7 +269,9 @@ class SiwaveSimulationSetup(SimulationSetup):
         >>> setup1 = edbapp.create_siwave_syz_setup("setup1")
         >>> setup1.add_sweep(name="sw1", frequency_set=["linear count", "1MHz", "100MHz", 10])
         """
-        sweep_data = SimulationSetup.add_sweep(self, name, frequency_set, sweep_type, **kwargs)
+        sweep_data = SimulationSetup.add_sweep(
+            self, name=name, frequency_set=frequency_set, sweep_type=sweep_type, **kwargs
+        )
         self._siwave_sweeps_list.append(sweep_data)
         return sweep_data
 

pyedb/dotnet/edb.py

@@ -49,7 +49,6 @@ from pyedb.dotnet.database.components import Components
 import pyedb.dotnet.database.dotnet.database
 from pyedb.dotnet.database.dotnet.database import Database
 from pyedb.dotnet.database.edb_data.design_options import EdbDesignOptions
-from pyedb.dotnet.database.edb_data.edbvalue import EdbValue
 from pyedb.dotnet.database.edb_data.ports import (
     BundleWavePort,
     CircuitPort,
@@ -461,9 +460,9 @@ class Edb(Database):
         """
         all_vars = dict()
         for i, j in self.project_variables.items():
-            all_vars[i] = j
+            all_vars[i] = j.value
         for i, j in self.design_variables.items():
-            all_vars[i] = j
+            all_vars[i] = j.value
         return all_vars
 
     @property
@@ -3022,11 +3021,11 @@ class Edb(Database):
         --------
 
         >>> from pyedb import Edb
-        >>> edb = Edb(edbpath=r"C:\temp\myproject.aedb", edbversion="2023.2")
+        >>> edb = Edb(edbpath="C:\\temp\\myproject.aedb", edbversion="2023.2")
 
         >>> options_config = {'UNITE_NETS' : 1, 'LAUNCH_Q3D' : 0}
-        >>> edb.write_export3d_option_config_file(r"C:\temp", options_config)
-        >>> edb.export_hfss(r"C:\temp")
+        >>> edb.write_export3d_option_config_file(r"C:\\temp", options_config)
+        >>> edb.export_hfss(r"C:\\temp")
         """
         siwave_s = SiwaveSolve(self.edbpath, aedt_installer_path=self.base_path)
         return siwave_s.export_3d_cad("HFSS", path_to_output, net_list, num_cores, aedt_file_name, hidden=hidden)
@@ -3065,10 +3064,10 @@ class Edb(Database):
         --------
 
         >>> from pyedb import Edb
-        >>> edb = Edb(edbpath=r"C:\temp\myproject.aedb", edbversion="2021.2")
+        >>> edb = Edb(edbpath="C:\\temp\\myproject.aedb", edbversion="2021.2")
         >>> options_config = {'UNITE_NETS' : 1, 'LAUNCH_Q3D' : 0}
-        >>> edb.write_export3d_option_config_file(r"C:\temp", options_config)
-        >>> edb.export_q3d(r"C:\temp")
+        >>> edb.write_export3d_option_config_file("C:\\temp", options_config)
+        >>> edb.export_q3d("C:\\temp")
         """
 
         siwave_s = SiwaveSolve(self.edbpath, aedt_installer_path=self.base_path)
@@ -3116,11 +3115,11 @@ class Edb(Database):
 
         >>> from pyedb import Edb
 
-        >>> edb = Edb(edbpath=r"C:\temp\myproject.aedb", edbversion="2021.2")
+        >>> edb = Edb(edbpath="C:\\temp\\myproject.aedb", edbversion="2021.2")
 
         >>> options_config = {'UNITE_NETS' : 1, 'LAUNCH_Q3D' : 0}
-        >>> edb.write_export3d_option_config_file(r"C:\temp", options_config)
-        >>> edb.export_maxwell(r"C:\temp")
+        >>> edb.write_export3d_option_config_file("C:\\temp", options_config)
+        >>> edb.export_maxwell("C:\\temp")
         """
         siwave_s = SiwaveSolve(self.edbpath, aedt_installer_path=self.base_path)
         return siwave_s.export_3d_cad(
@@ -3245,10 +3244,13 @@ class Edb(Database):
         -------
         :class:`pyedb.dotnet.database.edb_data.edbvalue.EdbValue`
         """
-        var_server = self.variable_exists(variable_name)
-        if var_server[0]:
-            tuple_value = var_server[1].GetVariableValue(variable_name)
-            return EdbValue(tuple_value[1])
+
+        for i, j in self.project_variables.items():
+            if i == variable_name:
+                return j
+        for i, j in self.design_variables.items():
+            if i == variable_name:
+                return j
         self.logger.info("Variable %s doesn't exists.", variable_name)
         return None
 
@@ -3758,7 +3760,7 @@ class Edb(Database):
         elif not name:
             name = generate_unique_name("setup")
         setup = HfssSimulationSetup(self, name=name)
-        setup.set_solution_single_frequency("1GΗz")
+        setup.set_solution_single_frequency("1Ghz")
         return setup
 
     def create_raptorx_setup(self, name=None):
@@ -3958,7 +3960,7 @@ class Edb(Database):
             Dictionary with EDB path as key and EDB PolygonData as value defining the zone region.
             This dictionary is returned from the command copy_zones():
             >>> edb = Edb(edb_file)
-            >>> zone_dict = edb.copy_zones(r"C:\Temp\test")
+            >>> zone_dict = edb.copy_zones("C:/Temp/test")
 
         common_reference_net : str
             the common reference net name. This net name must be provided to provide a valid project.
@@ -4017,7 +4019,7 @@ class Edb(Database):
                 dictionary terminals with edb name as key and created ports name on clipped signal nets.
                 Dictionary is generated by the command cutout_multizone_layout:
                 >>> edb = Edb(edb_file)
-                >>> edb_zones = edb.copy_zones(r"C:\Temp\test")
+                >>> edb_zones = edb.copy_zones("C:/Temp/test")
                 >>> defined_ports, terminals_info = edb.cutout_multizone_layout(edb_zones, common_reference_net)
                 >>> project_connexions = get_connected_ports(terminals_info)
 
@@ -4724,6 +4726,6 @@ class Edb(Database):
     def get_variable_value(self, variable_name):
         """Added to get closer architecture as for grpc."""
         if variable_name in self.variables:
-            return self.variables[variable_name].value
+            return self.variables[variable_name]
         else:
             return False