Expose Maxwell Circuit Editor (#789)

* Add MaxwellCircuit Class

* Add AnalysisMaxwellCircuit class

* Add Modeler for MaxwellCircuit

* Add Primitives class for MaxwellCircuit

* Add Unit tests for Maxwell Circuit

* Fix up issues with insert design

* Fix up unit tests

* Fix flake8 errors

* fix up black style issues

* Apply suggestions from code review

Co-authored-by: Maxime Rey <[email protected]>

* Update Documentation comments

Co-authored-by: Maxime Rey <[email protected]>

Author: SushobhitGupt

_unittest/test_35_MaxwellCircuit.py

@@ -0,0 +1,40 @@
+# Setup paths for module imports
+from _unittest.conftest import scratch_path
+
+# Import required modules
+from pyaedt import MaxwellCircuit
+from pyaedt.generic.filesystem import Scratch
+import gc
+
+
+class TestClass:
+    def setup_class(self):
+        project_name = "MaxwellCircuitProject"
+        design_name = "MaxwellCircuitDesign1"
+        # set a scratch directory and the environment / test data
+        with Scratch(scratch_path) as self.local_scratch:
+            self.aedtapp = MaxwellCircuit(project_name, design_name)
+
+    def teardown_class(self):
+        self.aedtapp._desktop.ClearMessages("", "", 3)
+        assert self.aedtapp.close_project(self.aedtapp.project_name, saveproject=False)
+        self.local_scratch.remove()
+        gc.collect()
+
+    def test_01_create_resistor(self):
+        id = self.aedtapp.modeler.schematic.create_resistor("Resistor1", 10, [0, 0])
+        assert id.parameters["R"] == "10"
+
+    def test_02_create_inductor(self):
+        id = self.aedtapp.modeler.schematic.create_inductor("Inductor1", 1.5, [0.25, 0])
+        assert id.parameters["L"] == "1.5"
+
+    def test_03_create_capacitor(self):
+        id = self.aedtapp.modeler.schematic.create_capacitor("Capacitor1", 7.5, [0.5, 0])
+        assert id.parameters["C"] == "7.5"
+
+    def test_04_create_diode(self):
+        assert self.aedtapp.modeler.schematic.create_diode("Diode1")
+
+    def test_05_create_winding(self):
+        assert self.aedtapp.modeler.schematic.create_winding("mywinding")

_unittest_ironpython/test_35_MaxwellCircuit.py

@@ -0,0 +1,23 @@
+from conf_unittest import test_generator, PytestMockup
+import os
+
+if os.name != "posix":
+    test_filter = "test_"
+
+    test_name = os.path.basename(__file__).replace(".py", "")
+    mymodule = __import__("_unittest." + test_name, fromlist=["TestClass"])
+    test_obj = mymodule.TestClass()
+
+    class TestSequenceFunctionsGenerate(PytestMockup):
+        @classmethod
+        def setUpClass(cls):
+            test_obj.setup_class()
+
+        @classmethod
+        def tearDownClass(cls):
+            test_obj.teardown_class()
+
+    test_names = [name for name in dir(test_obj) if name.startswith(test_filter)]
+    for test_name in test_names:
+        test_fn = test_generator(test_obj, test_name)
+        setattr(TestSequenceFunctionsGenerate, test_name, test_fn)

pyaedt/__init__.py

@@ -32,6 +32,7 @@
     Edb,
     Maxwell3d,
     Maxwell2d,
+    MaxwellCircuit,
     Mechanical,
     Rmxprt,
     TwinBuilder,

pyaedt/application/Analysis.py

@@ -103,8 +103,7 @@ def __init__(
             close_on_exit,
             student_version,
         )
-        self._ooptimetrics = self._odesign.GetModule("Optimetrics")
-        self._ooutput_variable = self._odesign.GetModule("OutputVariable")
+
         self.logger.info("Design Loaded")
         self._setup = None
         if setup_name:
@@ -115,13 +114,18 @@ def __init__(
         self._available_variations = self.AvailableVariations(self)
         if "HFSS 3D Layout Design" in self.design_type:
             self._oanalysis = self._odesign.GetModule("SolveSetups")
-        elif "EMIT" in self.design_type:
+        elif "EMIT" in self.design_type or "Maxwell Circuit" in self.design_type:
             self._oanalysis = None
         elif "Circuit Design" in self.design_type or "Twin Builder" in self.design_type:
             self._oanalysis = self._odesign.GetModule("SimSetup")
         else:
             self._oanalysis = self._odesign.GetModule("AnalysisSetup")
-        self.setups = [self.get_setup(setup_name) for setup_name in self.setup_names]
+
+        if self.design_type != "Maxwell Circuit":
+            self._ooptimetrics = self._odesign.GetModule("Optimetrics")
+            self._ooutput_variable = self._odesign.GetModule("OutputVariable")
+            self.setups = [self.get_setup(setup_name) for setup_name in self.setup_names]
+
         self.opti_parametric = ParametericsSetups(self)
         self.opti_optimization = OptimizationSetups(self)
         self.opti_doe = DOESetups(self)

pyaedt/application/AnalysisMaxwellCircuit.py

@@ -0,0 +1,72 @@
+from pyaedt.modeler.Circuit import ModelerMaxwellCircuit
+from pyaedt.application.Analysis import Analysis
+
+
+class AnalysisMaxwellCircuit(Analysis):
+    """Class for Maxwell Circuit (MaxwellCircuit)
+
+    Maxwell Circuit Editor has no setup, solution, analysis or postprocessor
+    It is automatically initialized by Application call (Maxwell Circuit).
+    Refer to Application function for inputs definition
+
+    Parameters
+    ----------
+    projectname : str, optional
+        Name of the project to select or the full path to the project
+        or AEDTZ archive to open.  The default is ``None``, in which
+        case an attempt is made to get an active project. If no
+        projects are present, an empty project is created.
+    designname : str, optional
+        Name of the design to select. The default is ``None``, in
+        which case an attempt is made to get an active design. If no
+        designs are present, an empty design is created.
+    specified_version : str, optional
+        Version of AEDT to use. The default is ``None``. If ``None``,
+        the active setup is used or the latest installed version is
+        used.
+    NG : bool, optional
+        Whether to launch AEDT in the non-graphical mode. The default
+        is ``False``, in which case AEDT is launched in the graphical mode.
+    new_desktop_session : bool, optional
+        Whether to launch an instance of AEDT in a new thread, even if
+        another instance of the ``specified_version`` is active on the
+        machine.  The default is ``True``.
+    close_on_exit : bool, optional
+        Whether to release AEDT on exit. The default is ``True``.
+    student_version : bool, optional
+        Whether open AEDT Student Version. The default is ``False``.
+
+    """
+
+    def __init__(
+        self,
+        application,
+        projectname,
+        designname,
+        specified_version=None,
+        non_graphical=False,
+        new_desktop_session=False,
+        close_on_exit=False,
+        student_version=False,
+    ):
+
+        Analysis.__init__(
+            self,
+            application,
+            projectname,
+            designname,
+            None,
+            None,
+            specified_version,
+            non_graphical,
+            new_desktop_session,
+            close_on_exit,
+            student_version,
+        )
+        self.solution_type = None
+        self._modeler = ModelerMaxwellCircuit(self)
+
+    @property
+    def modeler(self):
+        """Design oModeler."""
+        return self._modeler

pyaedt/application/Design.py

@@ -606,7 +606,7 @@ def design_type(self):
 
         Options are ``"Circuit Design"``, ``"Emit"``, ``"HFSS"``,
         ``"HFSS 3D Layout Design"``, ``"Icepak"``, ``"Maxwell 2D"``,
-        ``"Maxwell 3D"``, ``"Mechanical"``, ``"ModelCreation"``,
+        ``"Maxwell 3D"``, ``"Maxwell Circuit"``, ``"Mechanical"``, ``"ModelCreation"``,
         ``"Q2D Extractor"``, ``"Q3D Extractor"``, ``"RMxprtSolution"``,
         and ``"Twin Builder"``.
 

pyaedt/application/design_solutions.py

@@ -6,6 +6,7 @@
     "Maxwell 3D": "Magnetostatic",
     "Twin Builder": "TR",
     "Circuit Design": "NexximLNA",
+    "Maxwell Circuit": "",
     "2D Extractor": "Open",
     "Q3D Extractor": "Q3D Extractor",
     "HFSS": "HFSS Modal Network",
@@ -433,13 +434,16 @@
     "EMIT": {
         "EMIT": {"name": None, "options": None, "report_type": None, "default_setup": None, "default_adaptive": None}
     },
+    # Maxwell Circuit has no solution type
+    "Maxwell Circuit": {},
 }
 
 model_names = {
     "Maxwell 2D": "Maxwell2DModel",
     "Maxwell 3D": "Maxwell3DModel",
     "Twin Builder": "SimplorerCircuit",
     "Circuit Design": "NexximCircuit",
+    "Maxwell Circuit": "MaxCirCircuit",
     "2D Extractor": "2DExtractorModel",
     "Q3D Extractor": "Q3DModel",
     "HFSS": "HFSSModel",

pyaedt/generic/design_types.py

@@ -13,6 +13,7 @@
     from pyaedt.rmxprt import Rmxprt
     from pyaedt.twinbuilder import TwinBuilder
     from pyaedt.twinbuilder import TwinBuilder as Simplorer  # noqa: F401 # namespace only for backward compatibility
+    from pyaedt.maxwellcircuit import MaxwellCircuit
     from pyaedt.emit import Emit
     from pyaedt.desktop import Desktop
 except ImportError:
@@ -28,13 +29,15 @@
     from pyaedt.rmxprt import Rmxprt
     from pyaedt.twinbuilder import TwinBuilder
     from pyaedt.twinbuilder import TwinBuilder as Simplorer  # noqa: F401 # namespace only for backward compatibility
+    from pyaedt.maxwellcircuit import MaxwellCircuit
     from pyaedt.emit import Emit
     from pyaedt.desktop import Desktop
 
 
 app_map = {
     "Maxwell 2D": Maxwell2d,
     "Maxwell 3D": Maxwell3d,
+    "Maxwell Circuit": MaxwellCircuit,
     "Twin Builder": TwinBuilder,
     "Circuit Design": Circuit,
     "2D Extractor": Q2d,

pyaedt/maxwellcircuit.py

@@ -0,0 +1,159 @@
+"""This module contains the `MaxwellCircuit` class."""
+
+from __future__ import absolute_import
+import math
+
+from pyaedt.application.AnalysisMaxwellCircuit import AnalysisMaxwellCircuit
+from pyaedt.generic.general_methods import aedt_exception_handler
+
+
+class MaxwellCircuit(AnalysisMaxwellCircuit, object):
+    """Provides the Maxwell Circuit Editor application interface.
+
+    Parameters
+    ----------
+    projectname : str, optional
+        Name of the project to select or the full path to the project
+        or AEDTZ archive to open.  The default is ``None``, in which
+        case an attempt is made to get an active project. If no
+        projects are present, an empty project is created.
+    designname : str, optional
+        Name of the design to select. The default is ``None``, in
+        which case an attempt is made to get an active design. If no
+        designs are present, an empty design is created.
+    specified_version : str, optional
+        Version of AEDT to use. The default is ``None``. If ``None``,
+        the active setup is used or the latest installed version is
+        used.
+    NG : bool, optional
+        Whether to launch AEDT in the non-graphical mode. The default
+        is ``False``, in which case AEDT is launched in the graphical mode.
+    new_desktop_session : bool, optional
+        Whether to launch an instance of AEDT in a new thread, even if
+        another instance of the ``specified_version`` is active on the
+        machine.  The default is ``True``.
+    close_on_exit : bool, optional
+        Whether to release AEDT on exit. The default is ``True``.
+    student_version : bool, optional
+        Whether open AEDT Student Version. The default is ``False``.
+
+    Examples
+    --------
+    Create an instance of Maxwell Circuit Editor and connect to an existing
+    Maxwell ckt design or create a new Maxwell ckt design if one does not
+    exist.
+
+    >>> from pyaedt import MaxwellCircuit
+    >>> app = MaxwellCircuit()
+
+    Create an instance of Maxwell Circuit and link to a project named
+    ``"projectname"``. If this project does not exist, create one with
+    this name.
+
+    >>> app = MaxwellCircuit(projectname)
+
+    Create an instance of Maxwell Circuit and link to a design named
+    ``"designname"`` in a project named ``"projectname"``.
+
+    >>> app = MaxwellCircuit(projectname, designame)
+
+    Create an instance of Maxwell Circuit and open the specified
+    project, which is named ``"myfile.aedt"``.
+
+    >>> app = MaxwellCircuit("myfile.aedt")
+    """
+
+    def __init__(
+        self,
+        projectname=None,
+        designname=None,
+        specified_version=None,
+        non_graphical=False,
+        new_desktop_session=False,
+        close_on_exit=False,
+        student_version=False,
+    ):
+        """Constructor."""
+        AnalysisMaxwellCircuit.__init__(
+            self,
+            "Maxwell Circuit",
+            projectname,
+            designname,
+            specified_version,
+            non_graphical,
+            new_desktop_session,
+            close_on_exit,
+            student_version,
+        )
+
+    @aedt_exception_handler
+    def create_schematic_from_netlist(self, file_to_import):
+        """Create a circuit schematic from an HSpice net list.
+
+        Supported currently are:
+
+        * R
+        * L
+        * C
+        * Diodes
+
+        Parameters
+        ----------
+        file_to_import : str
+            Full path to the HSpice file.
+
+        Returns
+        -------
+        bool
+            ``True`` when successful, ``False`` when failed.
+
+        """
+        xpos = 0
+        ypos = 0
+        delta = 0.0508
+        use_instance = True
+        with open(file_to_import, "r") as f:
+            for line in f:
+                mycomp = None
+                fields = line.split(" ")
+                name = fields[0]
+                if fields[0][0] == "R":
+                    value = fields[3][fields[3].find("=") + 1 :].strip()
+                    mycomp = self.modeler.schematic.create_resistor(
+                        name, value, [xpos, ypos], use_instance_id_netlist=use_instance
+                    )
+                elif fields[0][0] == "L":
+                    value = fields[3][fields[3].find("=") + 1 :].strip()
+                    mycomp = self.modeler.schematic.create_inductor(
+                        name, value, [xpos, ypos], use_instance_id_netlist=use_instance
+                    )
+                elif fields[0][0] == "C":
+                    value = fields[3][fields[3].find("=") + 1 :].strip()
+                    mycomp = self.modeler.schematic.create_capacitor(
+                        name, value, [xpos, ypos], use_instance_id_netlist=use_instance
+                    )
+                elif fields[0][0] == "D":
+                    value = fields[3][fields[3].find("=") + 1 :].strip()
+                    mycomp = self.modeler.schematic.create_diode(
+                        name, value, [xpos, ypos], use_instance_id_netlist=use_instance
+                    )
+                if mycomp:
+                    id = 1
+                    for pin in mycomp.pins:
+                        if pin.name == "CH" or pin.name == fields[0][0]:
+                            continue
+                        pos = pin.location
+                        if pos[0] < xpos:
+                            angle = 0.0
+                        else:
+                            angle = math.pi
+                        self.modeler.schematic.create_page_port(fields[id], [pos[0], pos[1]], angle)
+                        id += 1
+                    ypos += delta
+                    if ypos > 0.254:
+                        xpos += delta
+                        ypos = 0
+        return True
+
+    def __enter__(self):
+        return self