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

pyedb/__init__.py

@@ -44,7 +44,7 @@ deprecation_warning()
 #
 
 pyedb_path = os.path.dirname(__file__)
-__version__ = "0.46.0"
+__version__ = "0.48.0"
 version = __version__
 
 #

pyedb/configuration/cfg_stackup.py

@@ -24,6 +24,33 @@ from pyedb import Edb
 from pyedb.configuration.cfg_common import CfgBase
 
 
+class CfgMaterialPropertyThermalModifier:
+    def __init__(self, **kwargs):
+        self.property_name = kwargs["property_name"]
+        self.basic_quadratic_c1 = kwargs.get("basic_quadratic_c1", 0)
+        self.basic_quadratic_c2 = kwargs.get("basic_quadratic_c2", 0)
+        self.basic_quadratic_temperature_reference = kwargs.get("basic_quadratic_temperature_reference", 22)
+        self.advanced_quadratic_lower_limit = kwargs.get("advanced_quadratic_lower_limit", -273.15)
+        self.advanced_quadratic_upper_limit = kwargs.get("advanced_quadratic_upper_limit", 1000)
+
+        self.advanced_quadratic_auto_calculate = kwargs.get("advanced_quadratic_auto_calculate", True)
+        self.advanced_quadratic_lower_constant = kwargs.get("advanced_quadratic_lower_constant", 1)
+        self.advanced_quadratic_upper_constant = kwargs.get("advanced_quadratic_upper_constant", 1)
+
+    def to_dict(self):
+        return {
+            "property_name": self.property_name,
+            "basic_quadratic_c1": self.basic_quadratic_c1,
+            "basic_quadratic_c2": self.basic_quadratic_c2,
+            "basic_quadratic_temperature_reference": self.basic_quadratic_temperature_reference,
+            "advanced_quadratic_lower_limit": self.advanced_quadratic_lower_limit,
+            "advanced_quadratic_upper_limit": self.advanced_quadratic_upper_limit,
+            "advanced_quadratic_auto_calculate": self.advanced_quadratic_auto_calculate,
+            "advanced_quadratic_lower_constant": self.advanced_quadratic_lower_constant,
+            "advanced_quadratic_upper_constant": self.advanced_quadratic_upper_constant,
+        }
+
+
 class CfgMaterial(CfgBase):
     def __init__(self, **kwargs):
         self.name = kwargs.get("name", None)
@@ -37,6 +64,10 @@ class CfgMaterial(CfgBase):
         self.specific_heat = kwargs.get("specific_heat", None)
         self.thermal_conductivity = kwargs.get("thermal_conductivity", None)
 
+        self.thermal_modifier = [
+            CfgMaterialPropertyThermalModifier(**i) for i in kwargs.get("thermal_modifier", {}) if i is not None
+        ]
+
 
 class CfgLayer(CfgBase):
     def __init__(self, **kwargs):
@@ -131,12 +162,15 @@ class CfgStackup:
                 attrs = mat_in_cfg.get_attributes()
                 mat = self._pedb.materials.add_material(**attrs)
 
+                for i in attrs.get("thermal_modifier", []):
+                    mat.set_thermal_modifier(**i.to_dict())
+
         def get_materials_from_db(self):
             materials = []
             for name, p in self._pedb.materials.materials.items():
                 mat = {}
                 for p_name in CfgMaterial().__dict__:
-                    mat[p_name] = getattr(p, p_name)
+                    mat[p_name] = getattr(p, p_name, None)
                 materials.append(mat)
             return materials
 

pyedb/configuration/configuration.py

@@ -572,17 +572,17 @@ class Configuration:
         """
         return self.api.export(
             file_path,
-            stackup=True,
-            package_definitions=False,
-            setups=True,
-            sources=True,
-            ports=True,
-            nets=True,
-            pin_groups=True,
-            operations=True,
-            components=True,
-            boundaries=True,
-            s_parameters=True,
-            padstacks=True,
-            general=True,
+            stackup=stackup,
+            package_definitions=package_definitions,
+            setups=setups,
+            sources=sources,
+            ports=ports,
+            nets=nets,
+            pin_groups=pin_groups,
+            operations=operations,
+            components=components,
+            boundaries=boundaries,
+            s_parameters=s_parameters,
+            padstacks=padstacks,
+            general=general,
         )

pyedb/dotnet/database/cell/primitive/primitive.py

@@ -51,7 +51,9 @@ class Primitive(Connectable):
             "invalid": bondwire_type.Invalid,
             "apd": bondwire_type.ApdBondwire,
             "jedec_4": bondwire_type.Jedec4Bondwire,
+            "jedec4": bondwire_type.Jedec4Bondwire,
             "jedec_5": bondwire_type.Jedec5Bondwire,
+            "jedec5": bondwire_type.Jedec5Bondwire,
             "num_of_bondwire_type": bondwire_type.NumOfBondwireType,
         }
         bondwire_cross_section_type = self._pedb._edb.Cell.Primitive.BondwireCrossSectionType
@@ -261,7 +263,12 @@ class Primitive(Connectable):
 
         """
         bbox = self.polygon_data._edb_object.GetBBox()
-        return [bbox.Item1.X.ToDouble(), bbox.Item1.Y.ToDouble(), bbox.Item2.X.ToDouble(), bbox.Item2.Y.ToDouble()]
+        return [
+            round(bbox.Item1.X.ToDouble(), 6),
+            round(bbox.Item1.Y.ToDouble(), 6),
+            round(bbox.Item2.X.ToDouble(), 6),
+            round(bbox.Item2.Y.ToDouble(), 6),
+        ]
 
     def convert_to_polygon(self):
         """Convert path to polygon.

pyedb/dotnet/database/cell/terminal/terminal.py

@@ -21,6 +21,7 @@
 # SOFTWARE.
 
 import re
+import warnings
 
 from pyedb.dotnet.database.cell.connectable import Connectable
 from pyedb.dotnet.database.edb_data.padstacks_data import EDBPadstackInstance
@@ -196,18 +197,35 @@ class Terminal(Connectable):
         return self._edb_object.IsReferenceTerminal()
 
     @property
-    def ref_terminal(self):
-        """Get reference terminal."""
-
+    def reference_terminal(self):
+        """Adding grpc compatibility."""
         edb_terminal = self._edb_object.GetReferenceTerminal()
         if not edb_terminal.IsNull():
             return self._pedb.terminals[edb_terminal.GetName()]
         else:
             return None
 
+    @reference_terminal.setter
+    def reference_terminal(self, value):
+        self._edb_object.SetReferenceTerminal(value._edb_object)
+
+    @property
+    def ref_terminal(self):
+        """Get reference terminal.
+
+        .deprecated:: pyedb 0.47.0
+        Use: attribute:`reference_terminal` instead.
+
+        """
+        warnings.warn(
+            "`ref_terminal` is deprecated, use `reference_terminal` instead.",
+            DeprecationWarning,
+        )
+        return self.reference_terminal
+
     @ref_terminal.setter
     def ref_terminal(self, value):
-        self._edb_object.SetReferenceTerminal(value._edb_object)
+        self.reference_terminal = value
 
     @property
     def reference_object(self):  # pragma : no cover

pyedb/dotnet/database/components.py

@@ -947,6 +947,25 @@ class Components(object):
         >>> port_type=SourceType.CoaxPort, do_pingroup=False, refnet="GND")
 
         """
+        # Adding grpc compatibility
+        if not isinstance(port_type, int):
+            if port_type == "circuit_port":
+                port_type = SourceType.CircPort
+            elif port_type == "coaxial_port":
+                port_type = SourceType.CoaxPort
+            elif port_type == "lumped_port":
+                port_type = SourceType.LumpedPort
+            elif port_type == "rlc":
+                port_type = SourceType.Rlc
+            elif port_type == "current_source":
+                port_type = SourceType.Isource
+            elif port_type == "voltage_source":
+                port_type = SourceType.Vsource
+            elif port_type == "dc_terminal":
+                port_type = SourceType.DcTerminal
+            else:
+                self._pedb.logger.error(f"Port type {port_type} seems to be for grpc version but is not compatible.")
+                return False
         if isinstance(component, str):
             component = self.instances[component].edbcomponent
 
@@ -1576,7 +1595,9 @@ class Components(object):
         >>> edbapp.components.create(pins, "A1New")
 
         """
-        pins = [p._edb_object for p in pins]
+        _pins = [p._edb_object for p in pins if isinstance(p, EDBPadstackInstance)]
+        if _pins:
+            pins = _pins
         if not component_name:
             component_name = generate_unique_name("Comp_")
         if component_part_name:
@@ -1589,8 +1610,6 @@ class Components(object):
             self._active_layout, component_name, compdef.GetName()
         )
 
-        if isinstance(pins[0], EDBPadstackInstance):
-            pins = [i._edb_object for i in pins]
         hosting_component_location = pins[0].GetComponent().GetTransform()
         for pin in pins:
             pin.SetIsLayoutPin(True)

pyedb/dotnet/database/dotnet/database.py

@@ -484,6 +484,24 @@ class CellClassDotNet:
 
         return PrimitiveDotNet(self._app)
 
+    @property
+    def simulation_setups(self):
+        return self._app.setups
+
+    def get_all_variable_names(self):
+        """Method added for compatibility with grpc.
+
+        Returns
+        -------
+        List[Str]
+            List of variables name.
+
+        """
+        return list(self._app.variable_exists("")[1].GetAllVariableNames())
+
+    def get_variable_value(self, variable_name):
+        return self._app.variables[variable_name]
+
 
 class UtilityDotNet:
     """Utility Edb class."""

pyedb/dotnet/database/edb_data/padstacks_data.py

@@ -1261,6 +1261,8 @@ class EDBPadstackInstance(Primitive):
         """
         terminal = self.create_terminal(name)
         if reference:
+            if isinstance(reference, tuple):
+                reference = reference[1]
             ref_terminal = reference.create_terminal(terminal.name + "_ref")
             if reference._edb_object.ToString() == "PinGroup":
                 is_circuit_port = True
@@ -1463,6 +1465,19 @@ class EDBPadstackInstance(Primitive):
         else:
             return self._edb_padstackinstance.SetBackDrillParameters(layer, val, False)
 
+    @property
+    def backdrill_type(self):
+        """Adding grpc compatibility. DotNet is supporting only layer drill type with adding stub length."""
+        return "layer_drill"
+
+    def get_back_drill_by_layer(self):
+        params = self.backdrill_parameters["from_bottom"]
+        return (
+            params["drill_to_layer"],
+            round(self._pedb.edb_value(params["stub_length"]).ToDouble(), 6),
+            round(self._pedb.edb_value(params["diameter"]).ToDouble(), 6),
+        )
+
     @property
     def backdrill_bottom(self):
         """Backdrill layer from bottom.
@@ -1539,6 +1554,11 @@ class EDBPadstackInstance(Primitive):
                 False,
             )
 
+    def set_back_drill_by_layer(self, drill_to_layer, diameter, offset):
+        """Method added to bring compatibility with grpc."""
+
+        self.set_backdrill_bottom(drill_depth=drill_to_layer.name, drill_diameter=diameter, offset=offset)
+
     def set_backdrill_bottom(self, drill_depth, drill_diameter, offset=0.0):
         """Set backdrill from bottom.
 

pyedb/dotnet/database/edb_data/ports.py

@@ -54,6 +54,16 @@ class GapPort(EdgeTerminal):
         """Magnitude."""
         return self._edb_object.GetSourceAmplitude().ToDouble()
 
+    @property
+    def source_amplitude(self):
+        """Property added for grpc compatibility"""
+        return self.magnitude
+
+    @property
+    def source_phase(self):
+        """Property added for grpc compatibility"""
+        return self.phase
+
     @property
     def phase(self):
         """Phase."""
@@ -77,6 +87,10 @@ class GapPort(EdgeTerminal):
             self._edb_object.GetPortPostProcessingProp().RenormalizionZ0.ToComplex().Item2,
         )
 
+    @property
+    def renormalization_impedance(self):
+        return self.renormalize_z0[0]
+
 
 class CircuitPort(GapPort):
     """Manages gap port properties.

pyedb/dotnet/database/edb_data/utilities.py

@@ -69,7 +69,7 @@ class EDBStatistics(object):
 
     @property
     def stackup_thickness(self):
-        return self._stackup_thickness
+        return round(self._stackup_thickness, 6)
 
     @stackup_thickness.setter
     def stackup_thickness(self, value):

pyedb/dotnet/database/geometry/polygon_data.py

@@ -82,7 +82,7 @@ class PolygonData:
         list[list[float]]
         """
         return [
-            [self._pedb.edb_value(i.X).ToDouble(), self._pedb.edb_value(i.Y).ToDouble()]
+            (self._pedb.edb_value(i.X).ToDouble(), self._pedb.edb_value(i.Y).ToDouble())
             for i in list(self._edb_object.Points)
         ]
 

pyedb/dotnet/database/hfss.py

@@ -429,7 +429,7 @@ class EdbHfss(object):
             source_name,
         )
 
-    def create_coax_port_on_component(self, ref_des_list, net_list):
+    def create_coax_port_on_component(self, ref_des_list, net_list, delete_existing_terminal=False):
         """Create a coaxial port on a component or component list on a net or net list.
            The name of the new coaxial port is automatically assigned.
 
@@ -441,6 +441,10 @@ class EdbHfss(object):
         net_list : list, str
             List of one or more nets.
 
+        delete_existing_terminal : bool
+            Only active with grpc version. This argument is added only to ensure compatibility between DotNet and grpc.
+
+
         Returns
         -------
         bool
@@ -448,6 +452,8 @@ class EdbHfss(object):
 
         """
         coax = []
+        if delete_existing_terminal:
+            self._pedb.logger.warning(f"flag delete_existing_terminal is set to True but is only supported with grpc.")
         if not isinstance(ref_des_list, list):
             ref_des_list = [ref_des_list]
         if not isinstance(net_list, list):
@@ -1234,6 +1240,10 @@ class EdbHfss(object):
         self._layout.cell.SetHFSSExtentInfo(hfss_extent)  # returns void
         return True
 
+    def add_setup(self, name=None):
+        """Adding method for grpc compatibility"""
+        return self._pedb.create_hfss_setup(name=name)
+
     def configure_hfss_analysis_setup(self, simulation_setup=None):
         """
         Configure HFSS analysis setup.

pyedb/dotnet/database/materials.py

@@ -116,6 +116,22 @@ class Material(object):
         self.__material_def = material_def
         self.__dc_model = material_def.GetDielectricMaterialModel()
 
+        self._pedb = edb
+        self._edb_object = material_def
+        definition = self.__edb_definition
+        self.material_property_id_mapping = {
+            "conductivity": definition.MaterialPropertyId.Conductivity,
+            "permittivity": definition.MaterialPropertyId.Permittivity,
+            "dielectric_loss_tangent": definition.MaterialPropertyId.DielectricLossTangent,
+            "magnetic_loss_tangent": definition.MaterialPropertyId.MagneticLossTangent,
+            "mass_density": definition.MaterialPropertyId.MassDensity,
+            "permeability": definition.MaterialPropertyId.Permeability,
+            "poisson_ratio": definition.MaterialPropertyId.PoissonsRatio,
+            "specific_heat": definition.MaterialPropertyId.SpecificHeat,
+            "thermal_conductivity": definition.MaterialPropertyId.ThermalConductivity,
+            "thermal_expansion_coefficient": definition.MaterialPropertyId.ThermalExpansionCoefficient,
+        }
+
     @property
     def name(self):
         """Material name."""
@@ -442,6 +458,68 @@ class Material(object):
     #     # Trigger get value on the property
     #     _ = getattr(self, name)
 
+    def set_thermal_modifier(
+        self,
+        property_name: str,
+        basic_quadratic_temperature_reference: float = 21,
+        basic_quadratic_c1: float = 0.1,
+        basic_quadratic_c2: float = 0.1,
+        advanced_quadratic_lower_limit: float = -270,
+        advanced_quadratic_upper_limit: float = 1001,
+        advanced_quadratic_auto_calculate: bool = False,
+        advanced_quadratic_lower_constant: float = 1.1,
+        advanced_quadratic_upper_constant: float = 1.1,
+    ):
+        """Sets the material property thermal modifier of a given material property.
+
+        Parameters
+        ----------
+        property_name : str
+            Name of the property to modify.
+        basic_quadratic_temperature_reference : float, optional
+            The TempRef value in the quadratic model.
+        basic_quadratic_c1 : float, optional
+            The C1 value in the quadratic model.
+        basic_quadratic_c2 : float, optional
+            The C2 value in the quadratic model.
+        advanced_quadratic_lower_limit : float, optional
+            The lower temperature limit where the quadratic model is valid.
+        advanced_quadratic_upper_limit : float, optional
+            The upper temperature limit where the quadratic model is valid.
+        advanced_quadratic_auto_calculate : bool, optional
+             The flag indicating whether or the LowerConstantThermalModifierVal and UpperConstantThermalModifierVal
+             values should be auto calculated.
+        advanced_quadratic_lower_constant : float, optional
+            The constant thermal modifier value for temperatures lower than LowerConstantThermalModifierVal.
+        advanced_quadratic_upper_constant : float, optional
+            The constant thermal modifier value for temperatures greater than UpperConstantThermalModifierVal.
+
+        Returns
+        -------
+
+        """
+        _edb = self._pedb._edb
+        basic = _edb.Utility.BasicQuadraticParams(
+            _edb.Utility.Value(basic_quadratic_temperature_reference),
+            _edb.Utility.Value(basic_quadratic_c1),
+            _edb.Utility.Value(basic_quadratic_c2),
+        )
+        advanced = _edb.Utility.AdvancedQuadraticParams(
+            _edb.Utility.Value(advanced_quadratic_lower_limit),
+            _edb.Utility.Value(advanced_quadratic_upper_limit),
+            advanced_quadratic_auto_calculate,
+            _edb.Utility.Value(advanced_quadratic_lower_constant),
+            _edb.Utility.Value(advanced_quadratic_upper_constant),
+        )
+
+        thermal_modifier = _edb.Definition.MaterialPropertyThermalModifier(basic, advanced)
+        if not self.__material_def.SetThermalModifier(
+            self.material_property_id_mapping[property_name], thermal_modifier
+        ):
+            raise ValueError(f"Fail to set thermal modifier for property {property_name}")
+        else:
+            return True
+
 
 class Materials(object):
     """Manages EDB methods for material management accessible from `Edb.materials` property."""

pyedb/dotnet/database/modeler.py

@@ -1317,7 +1317,7 @@ class Modeler(object):
         stat_model.num_resistors = len(self._pedb.components.resistors)
         stat_model.num_inductors = len(self._pedb.components.inductors)
         bbox = self._pedb._hfss.get_layout_bounding_box(self._active_layout)
-        stat_model._layout_size = bbox[2] - bbox[0], bbox[3] - bbox[1]
+        stat_model._layout_size = round(bbox[2] - bbox[0], 6), round(bbox[3] - bbox[1], 6)
         stat_model.num_discrete_components = (
             len(self._pedb.components.Others) + len(self._pedb.components.ICs) + len(self._pedb.components.IOs)
         )
@@ -1328,7 +1328,7 @@ class Modeler(object):
         stat_model.num_traces = len(self._pedb.modeler.paths)
         stat_model.num_polygons = len(self._pedb.modeler.polygons)
         stat_model.num_vias = len(self._pedb.padstacks.instances)
-        stat_model.stackup_thickness = self._pedb.stackup.get_layout_thickness()
+        stat_model.stackup_thickness = round(self._pedb.stackup.get_layout_thickness(), 6)
         if evaluate_area:
             outline_surface = stat_model.layout_size[0] * stat_model.layout_size[1]
             if net_list:
@@ -1343,8 +1343,8 @@ class Modeler(object):
                             surface += prim.length * prim.width
                         if prim.type == "Polygon":
                             surface += prim.polygon_data._edb_object.Area()
-                            stat_model.occupying_surface[layer] = surface
-                            stat_model.occupying_ratio[layer] = surface / outline_surface
+                            stat_model.occupying_surface[layer] = round(surface, 6)
+                            stat_model.occupying_ratio[layer] = round(surface / outline_surface, 6)
         return stat_model
 
     def create_bondwire(
@@ -1361,6 +1361,7 @@ class Modeler(object):
         end_y,
         net,
         bondwire_type="jedec4",
+        start_cell_instance_name=None,
     ):
         """Create a bondwire object.
 
@@ -1390,13 +1391,16 @@ class Modeler(object):
             Y value of end point.
         net : str or :class:`Net <ansys.edb.net.Net>` or None
             Net of the Bondwire.
+        start_cell_instance_name : None
+            Added for grpc compatibility.
 
         Returns
         -------
         :class:`pyedb.dotnet.database.dotnet.primitive.BondwireDotNet`
             Bondwire object created.
         """
-
+        if start_cell_instance_name:
+            self._pedb.logger.warning(f"start_cell_instance_name {start_cell_instance_name} is only valid with grpc.")
         return Bondwire(
             pedb=self._pedb,
             bondwire_type=bondwire_type,

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

@@ -47,6 +47,20 @@ class MeshOperation(object):
             "kNumMeshOpTypes": self._edb_object.TMeshOpType.kNumMeshOpTypes,
         }
 
+    @property
+    def net_layer_info(self):
+        """Adding property for grpc compatibility.
+
+        Returns
+        -------
+        The tuple is in this form: (net_name, layer_name, is_sheet)``.
+        """
+        layer_inf = []
+        for net_name, mesh_op in self.nets_layers_list.items():
+            for layer in mesh_op:
+                layer_inf.append((net_name, layer, True))
+        return layer_inf
+
     @property
     def enabled(self):
         """Whether if mesh operation is enabled.
@@ -220,6 +234,11 @@ class LengthMeshOperation(MeshOperation, object):
         """
         return self._edb_object.MaxLength
 
+    @property
+    def restrict_max_length(self):
+        """Adding property for grpc compatibility."""
+        return self.restrict_length
+
     @property
     def restrict_length(self):
         """Whether to restrict length of elements.
@@ -286,6 +305,11 @@ class SkinDepthMeshOperation(MeshOperation, object):
     def surface_triangle_length(self, value):
         self._edb_object.SurfTriLength = value
 
+    @property
+    def number_of_layers(self):
+        """Adding property for grpc compatibility."""
+        return self.number_of_layer_elements
+
     @property
     def number_of_layer_elements(self):
         """Number of layer elements.

pyedb/dotnet/database/siwave.py

@@ -401,7 +401,7 @@ class EdbSiwave(object):
         voltage_source.positive_node.component_node = pos_pin.GetComponent()
         voltage_source.positive_node.node_pins = pos_pin
         voltage_source.negative_node.component_node = neg_pin.GetComponent()
-        voltage_source.negative_node.node_pins = pos_pin
+        voltage_source.negative_node.node_pins = neg_pin
         return self._create_terminal_on_pins(voltage_source)
 
     def create_current_source_on_pin(self, pos_pin, neg_pin, current_value=0.1, phase_value=0, source_name=""):

pyedb/dotnet/database/utilities/simulation_setup.py

@@ -109,6 +109,11 @@ class SimulationSetup(object):
         warnings.warn("Use new property :func:`sim_setup_info` instead.", DeprecationWarning)
         return self.sim_setup_info._edb_object
 
+    @property
+    def is_null(self):
+        """Adding this property for compatibility with grpc."""
+        return self._edb_object.IsNull()
+
     def get_simulation_settings(self):
         sim_settings = self.sim_setup_info.simulation_settings
         properties = {}
@@ -237,13 +242,43 @@ class SimulationSetup(object):
         """List of frequency sweeps."""
         return {i.name: i for i in self.sim_setup_info.sweep_data_list}
 
-    def add_sweep(self, name: str = None, frequency_set: list = None, sweep_type: str = "interpolation", **kwargs):
+    @property
+    def sweep_data(self):
+        """Adding property for compatibility with grpc."""
+        return list(self.sweeps.values())
+
+    @sweep_data.setter
+    def sweep_data(self, sweep_data):
+        for sweep in self.sweep_data:
+            self.delete_frequency_sweep(sweep)
+        for sweep in sweep_data:
+            self._add_frequency_sweep(sweep)
+
+    def add_sweep(
+        self,
+        name: str = None,
+        distribution: str = None,
+        start_freq: str = None,
+        stop_freq: str = None,
+        step=None,
+        frequency_set: list = None,
+        sweep_type: str = "interpolation",
+        **kwargs,
+    ):
         """Add frequency sweep.
 
         Parameters
         ----------
         name : str, optional
             Name of the frequency sweep. The default is ``None``.
+        distribution : str, optional
+            Added for grpc compatibility.
+        start_freq : str, optional
+            Added for rpc compatibility.
+        stop_freq : str, optional
+            Added for grpc compatibility.
+        step : optional
+            Added for grpc compatibility.
         frequency_set : list, optional
             List of frequency points. The default is ``None``.
         sweep_type : str, optional
@@ -261,21 +296,28 @@ class SimulationSetup(object):
             raise ValueError("Sweep {} already exists.".format(name))
 
         sweep_data = SweepData(self._pedb, name=name, sim_setup=self)
-        for k, v in kwargs.items():
-            if k in dir(sweep_data):
-                setattr(sweep_data, k, v)
-        sweep_data.type = sweep_type
+        # adding grpc compatibility
+        if distribution and start_freq and stop_freq and step:
+            if distribution == "linear":
+                distribution = "linear_scale"  # to be compatible with grpc
+            frequency_set = [[distribution, start_freq, stop_freq, step]]
 
         if frequency_set in [None, []]:
-            sweep_type = "linear_scale"
+            distribution = "linear_scale"
             start, stop, increment = "50MHz", "5GHz", "50MHz"
-            frequency_set = [[sweep_type, start, stop, increment]]
+            frequency_set = [[distribution, start, stop, increment]]
         elif not isinstance(frequency_set[0], list):
             frequency_set = [frequency_set]
 
         for fs in frequency_set:
-            sweep_type, start, stop, increment = fs
-            sweep_data.add(sweep_type, start, stop, increment)
+            distribution, start, stop, increment = fs
+            sweep_data.add(distribution, start, stop, increment)
+
+        for k, v in kwargs.items():
+            if k in dir(sweep_data):
+                setattr(sweep_data, k, v)
+        sweep_data.type = sweep_type
+
         return sweep_data
 
     def delete(self):