FEAT: circuit configuration

Author: gkorompi

src/ansys/aedt/core/application/analysis_nexxim.py

@@ -24,6 +24,7 @@
 import warnings
 
 from ansys.aedt.core.application.analysis import Analysis
+from ansys.aedt.core.generic.configurations import ConfigurationsNexxim
 from ansys.aedt.core.generic.general_methods import pyaedt_function_handler
 from ansys.aedt.core.generic.settings import settings
 from ansys.aedt.core.modeler.circuits.object_3d_circuit import CircuitComponent
@@ -91,10 +92,21 @@ def __init__(
         self._post = None
         self._internal_excitations = None
         self._internal_sources = None
+        self._configurations = ConfigurationsNexxim(self)
         if not settings.lazy_load:
             self._modeler = self.modeler
             self._post = self.post
 
+    @property
+    def configurations(self):
+        """Property to import and export configuration files.
+
+        Returns
+        -------
+        :class:`ansys.aedt.core.generic.configurations.Configurations`
+        """
+        return self._configurations
+
     @pyaedt_function_handler(setupname="name")
     def delete_setup(self, name):
         """Delete a setup.

src/ansys/aedt/core/generic/configurations.py

@@ -22,6 +22,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+from collections import defaultdict
 import copy
 from datetime import datetime
 import json
@@ -2166,3 +2167,222 @@ def apply_operations_to_native_components(obj, operation_dict, native_dict):  #
                             native_dict["Instances"],
                         )
         return True
+
+
+class ConfigurationsNexxim(Configurations):
+    """Enables export and import configuration options to be applied to a new or existing Nexxim design."""
+
+    @pyaedt_function_handler()
+    def export_config(self, config_file=None, overwrite=False):
+        """Export current design properties to a JSON or TOML file.
+
+        Parameters
+        ----------
+        config_file : str, optional
+            Full path to json file. If ``None``, then the config file will be saved in working directory.
+        overwrite : bool, optional
+            If ``True`` the json file will be overwritten if already existing.
+            If ``False`` and the version is compatible, the data in the existing file will be updated.
+            Default is ``False``.
+
+        Returns
+        -------
+        str
+            Exported config file.
+        """
+
+        if not config_file:
+            config_file = os.path.join(
+                self._app.working_directory, generate_unique_name(self._app.design_name) + ".json"
+            )
+        # dict_out = {}
+        # self._export_general(dict_out)
+        pin_mapping = defaultdict(list)
+        data_refdes = {}
+        data_models = {}
+        pin_nets = {}
+        skip_list = [
+            "LabelID",
+            "ADD_NOISE",
+            "DTEMP",
+            "ModelName",
+            "CosimDefinition",
+            "CoSimulator",
+            "InstanceName",
+            "NexximNetlist",
+            "Name",
+            "COMPONENT",
+            "EyeMeasurementFunctions",
+            "ACMAG",
+        ]
+        for comp in list(self._app.modeler.schematic.components.values()):
+            properties = {}
+            name = []
+            num_terminals = None
+            refdes = comp.refdes
+            position = comp.location
+            angle = comp.angle
+            parameters = comp.parameters
+            if not comp.component_info:
+                continue
+            else:
+                component = comp.component_info["Component"]
+            path = comp.component_path
+            if path == False:
+                type = "Nexxim Component"
+                path = ""
+                for param, value in parameters.items():
+                    if param in skip_list:
+                        continue
+                    elif value and value[-1] == "'" and value[1] == "'":
+                        value = value[-1:1]
+                    properties[param] = value
+            elif path[-4:] == ".ibs":
+                if "AMI_Version" in parameters:
+                    type = "ami"
+                else:
+                    type = "ibis"
+                for prop, value in parameters.items():
+                    if value and value[-1] == '"' and value[0] == '"':
+                        value = value[1:-1]
+                    properties[prop] = value
+            elif path[-4:] in [".LIB", ".lib"] or path[-3:] == ".sp":
+                type = "spice"
+            elif path[-1:] == "p" and path[-2:-1].isdigit():
+                type = "touchstone"
+            elif path[-4:] == ".sss":
+                type = "nexxim state space"
+                num_terminals = comp.model_data.props["numberofports"]
+
+            for pin in comp.pins:
+                if pin.net == "0":
+                    net = "gnd"
+                else:
+                    net = pin.net
+                temp_dict = {pin: net}
+                pin_nets.update(temp_dict)
+
+            temp_dict2 = {
+                refdes: {"component": component, "properties": properties, "position": position, "angle": angle}
+            }
+            data_refdes.update(temp_dict2)
+            if num_terminals:
+                model = {component: {"type": type, "file_path": path, "num_terminals": num_terminals}}
+                num_terminals = None
+            else:
+                model = {component: {"type": type, "file_path": path}}
+            data_models.update(model)
+            print(data_refdes)
+
+        for k, v in pin_nets.items():
+            pin_mapping[v].append(k)
+
+        if "" in pin_mapping:
+            del pin_mapping[""]
+        for k, l in pin_mapping.items():
+            temp_dict3 = {}
+            for i in l:
+                temp_dict3.update({i._circuit_comp.refdes: i.name})
+            pin_mapping[k] = temp_dict3
+
+        dict_out = {
+            "models": data_models,
+            "refdes": data_refdes,
+            "pin_mapping": pin_mapping,
+        }  # Call private export method to update dict_out.
+
+        # update the json if it exists already
+
+        if os.path.exists(config_file) and not overwrite:
+            dict_in = read_configuration_file(config_file)
+            try:  # TODO: Allow import of config created with other versions of pyaedt.
+                if dict_in["general"]["pyaedt_version"] == __version__:
+                    for k, v in dict_in.items():
+                        if k not in dict_out:
+                            dict_out[k] = v
+                        elif isinstance(v, dict):
+                            for i, j in v.items():
+                                if i not in dict_out[k]:
+                                    dict_out[k][i] = j
+            except KeyError as e:
+                self._app.logger.error(str(e))
+
+        # write the updated dict to file
+        if write_configuration_file(dict_out, config_file):
+            self._app.logger.info(f"Json file {config_file} created correctly.")
+            return config_file
+        self._app.logger.error(f"Error creating json file {config_file}.")
+        return False
+
+    @pyaedt_function_handler()
+    def import_config(self, config_file, *args):
+        """Import configuration settings from a JSON or TOML file and apply it to the current design.
+
+
+        Parameters
+        ----------
+        config_file : str
+            Full path to json file.
+
+        Returns
+        -------
+        dict, bool
+            Config dictionary.
+        """
+        if len(args) > 0:  # pragma: no cover
+            raise TypeError("import_config expected at most 1 arguments, got %d" % (len(args) + 1))
+        self.results._reset_results()
+
+        data = read_configuration_file(config_file)
+        for i, j in data["refdes"].items():
+            for k, l in data["models"].items():
+                if k == j["component"]:
+                    type = l["type"]
+                    if type == "Nexxim Component":
+                        new_comp = self._app.modeler.components.create_component(
+                            name=i,
+                            component_library="",
+                            component_name=j["component"],
+                            location=j["position"],
+                            angle=j["angle"],
+                        )
+                    elif type in ["ibis", "ami"]:
+                        if type == "ami":
+                            ami = True
+                        else:
+                            ami = False
+                        comp_set = self._app.get_ibis_model_from_file(l["file_path"], ami).components.values()
+                        for comp in comp_set:
+                            for pin in comp.pins.values():
+                                if pin.buffer_name == k:
+                                    new_comp = pin.insert(j["position"][0], j["position"][1])
+                    elif type == "touchstone":
+                        new_comp = self._app.modeler.schematic.create_touchstone_component(
+                            l["file_path"], location=j["position"], angle=j["angle"]
+                        )
+                    elif type == "spice":
+                        new_comp = self._app.modeler.schematic.create_component_from_spicemodel(
+                            input_file=l["file_path"], location=j["position"]
+                        )
+                    elif type == "nexxim state space":
+                        new_comp = self._app.modeler.schematic.create_nexxim_state_space_component(
+                            l["file_path"], l["num_terminals"], location=j["position"], angle=j["angle"]
+                        )
+                    for name, parameter in j["properties"].items():
+                        new_comp.parameters[name] = parameter
+
+        for i, j in data["pin_mapping"].items():
+            pins = []
+            for k, l in j.items():
+                for comp in list(self._app.modeler.schematic.components.values()):
+                    if not comp.refdes:
+                        continue
+                    elif comp.refdes == k:
+                        for pin in comp.pins:
+                            if pin.name == l:
+                                pins.append(pin)
+            if i == "gnd":
+                for gnd_pin in pins:
+                    self._app.modeler.schematic.create_gnd(gnd_pin.location, gnd_pin.angle, page=i)
+            else:
+                pins[0].connect_to_component(pins[1:], page_name=i)

src/ansys/aedt/core/generic/ibis_reader.py

@@ -875,6 +875,9 @@ def parse_ibis_file(self):
                         arg_component.append([False, False])
                     else:
                         arg_component.append([True, False])
+                        if hasattr(pin, "negative_pin"):
+                            arg_component.append(f"{pin.short_name}:=")
+                            arg_component.append([True, True])
                 arg_components.append(arg_component)
 
             args.append(arg_buffers)
@@ -899,7 +902,11 @@ def read_model(self, ibis, model_list):
 
         """
         for model_info in model_list:
-            model_spec_info = model_info["model"].strip().split("\n")
+            if "model" in model_info:
+                model_spec_info = model_info["model"].strip().split("\n")
+            elif "model selector" in model_info:
+                model_spec_info = model_info["model selector"].strip().split("\n")
+                model_spec_info = [i.split(" ")[0] for i in model_spec_info]
             for idx, model_spec in enumerate(model_spec_info):
                 if not idx:
                     model = Model()
@@ -1294,6 +1301,9 @@ def parse_ibis_file(self):
                         arg_component.append([False, flag])
                     else:
                         arg_component.append([True, flag])
+                        if hasattr(pin, "negative_pin"):
+                            arg_component.append(f"{pin.short_name}:=")
+                            arg_component.append([True, True])
                 arg_components.append(arg_component)
 
             args.append(arg_buffers)

src/ansys/aedt/core/modeler/circuits/primitives_circuit.py

@@ -486,7 +486,7 @@ def create_model_from_touchstone(self, input_file, model_name=None, show_bitmap=
             bmp_file_name = os.path.basename(image_subcircuit_path)
 
         if not port_names:
-            port_names = ["Port" + str(i + 1) for i in range(num_terminal)]
+            port_names = [str(i + 1) for i in range(num_terminal)]
         arg = [
             "NAME:" + model_name,
             "Name:=",
@@ -724,7 +724,7 @@ def create_model_from_nexxim_state_space(self, input_file, num_terminal, model_n
         if model_name in list(self.omodel_manager.GetNames()):
             model_name = generate_unique_name(model_name, n=2)
 
-        port_names = ["Port" + str(i + 1) for i in range(num_terminal)]
+        port_names = [str(i + 1) for i in range(num_terminal)]
         arg = [
             "NAME:" + model_name,
             "Name:=",