bug: fixed some bugs in handling simulations -> needs testing on Ansys

squadds/simulations/ansys_simulator.py

@@ -146,21 +146,43 @@ def simulate(self, device_dict):
             None
         """
         return_df = {}
-        if isinstance(self.analyzer.selected_system, list): # have a qubit_cavity object
+
+        if isinstance(self.analyzer.selected_system, list):  # have a qubit_cavity object
+            device_dict = get_first_element_if_series(device_dict)
+            qubit_geoms = get_first_element_if_series(device_dict["design_options_qubit"])
+            cavity_geoms = get_first_element_if_series(device_dict["design_options_cavity_claw"])
+            qubit_setup = get_first_element_if_series(device_dict["setup_qubit"])
+            cavity_setup = get_first_element_if_series(device_dict["setup_cavity_claw"])
+
             self.geom_dict = Dict(
-                qubit_geoms = device_dict["design_options_qubit"],
-                cavity_geoms = device_dict["design_options_cavity_claw"]
+                qubit_geoms=qubit_geoms,
+                cavity_geoms=cavity_geoms
             )
             self.setup_dict = Dict(
-                qubit_setup = device_dict["setup_qubit"],
-                cavity_setup = device_dict["setup_cavity_claw"]
+                qubit_setup=qubit_setup,
+                cavity_setup=cavity_setup
+            )
+
+            return_df, self.lom_analysis_obj, self.epr_analysis_obj = simulate_whole_device(
+                design=self.design,
+                device_dict=device_dict,
+                LOM_options=self.setup_dict.qubit_setup,
+                eigenmode_options=self.setup_dict.cavity_setup
+            )
+
+        # Handle non-qubit_cavity object case
+        else:  # have a non-qubit_cavity object
+            design_options = get_first_element_if_series(device_dict["design_options"])
+            setup = get_first_element_if_series(device_dict["setup"])
+
+            self.geom_dict = design_options
+            self.setup_dict = setup
+
+            return_df, self.lom_analysis_obj, self.epr_analysis_obj = simulate_single_design(
+                design=self.design,
+                device_dict=device_dict,
+                lom_options=self.setup_dict
             )
-            return_df, self.lom_analysis_obj, self.epr_analysis_obj = simulate_whole_device(design=self.design, device_dict=device_dict, LOM_options=self.setup_dict.qubit_setup, eigenmode_options=self.setup_dict.cavity_setup)
-
-        else: # have a non-qubit_cavity object
-            self.geom_dict = device_dict["design_options"]
-            self.setup_dict = device_dict["setup"]
-            return_df, self.lom_analysis_obj, self.epr_analysis_obj = simulate_single_design(design=self.design, device_dict=device_dict, lom_options=self.setup_dict)
 
         return return_df
 

squadds/simulations/objects.py

@@ -3,9 +3,9 @@
 SimulationConfig
 ========================================================================================================================
 """
-
 from datetime import datetime
 
+import pandas as pd
 from qiskit_metal.analyses.quantization import EPRanalysis, LOManalysis
 
 from .sweeper_helperfunctions import extract_QSweep_parameters
@@ -53,6 +53,8 @@ def __init__(self, design_name="CavitySweep", renderer_type="hfss", sim_type="ei
         self.min_converged_passes = min_converged_passes
         self.Lj = Lj
         self.Cj = Cj
+        self.cpw_opts_key = None
+        self.cplr_opts_key = None
 
 def simulate_whole_device(design, device_dict, eigenmode_options, LOM_options, open_gui=False):
     """
@@ -72,25 +74,34 @@ def simulate_whole_device(design, device_dict, eigenmode_options, LOM_options, o
 
     cross_dict = device_dict["design_options_qubit"]
     cavity_dict = device_dict["design_options_cavity_claw"]
+    coupler_type = device_dict["coupler_type"]
+
+    if isinstance(cavity_dict.keys(), pd.RangeIndex):
+        cavity_dict = cavity_dict.iloc[0]
+        cross_dict = cross_dict.iloc[0]
+        coupler_type = coupler_type.iloc[0]
+
+    cpw_opts_key, cplr_opts_key, cpw_opts, cplr_opts = get_cavity_claw_options(cavity_dict)
 
     design.delete_all_components()
-    if device_dict["coupler_type"].upper() == "CLT":
+
+    if coupler_type.upper() == "CLT":
         emode_df, emode_obj = run_eigenmode(design, cavity_dict, eigenmode_options)
         lom_df, lom_obj = run_xmon_LOM(design, cross_dict, LOM_options)
         data = get_sim_results(emode_df = emode_df, lom_df = lom_df)
 
-    elif device_dict["coupler_type"].lower() == "ncap":
+    elif coupler_type.lower() == "ncap":
         emode_df, emode_obj = run_eigenmode(design, cavity_dict, eigenmode_options)
         ncap_lom_df, ncap_lom_obj = run_capn_LOM(design, cavity_dict["cplr_opts"], LOM_options)
         lom_df, lom_obj = run_xmon_LOM(design, cross_dict, LOM_options)
         data = get_sim_results(emode_df = emode_df, lom_df = lom_df, ncap_lom_df=ncap_lom_df)
 
     device_dict_format = Dict(
         cavity_options = Dict(
-            coupler_type = device_dict["coupler_type"],
-            coupler_options = cavity_dict["cplr_opts"],
+            coupler_type = coupler_type,
+            coupler_options = cplr_opts,
             cpw_opts = Dict (
-                left_options = cavity_dict["cpw_opts"],
+                    left_options = cpw_opts,
             )
 
         ),
@@ -150,7 +161,7 @@ def simulate_single_design(design, device_dict, emode_options={}, lom_options={}
     emode_obj = None
     lom_obj = None
 
-    if "cpw_opts" in device_dict.keys():
+    if ("cpw_opts" or "cpw_options") in device_dict.keys():
         emode_df, emode_obj = run_eigenmode(design, device_dict, emode_options)
         if coupler_type.lower() == "ncap":
             # emode_df, emode_obj = run_eigenmode(design, device_dict, sim_options)
@@ -245,10 +256,12 @@ def run_eigenmode(design, geometry_dict, sim_options):
             The EPRAnalysis object is returned for further analysis or post-processing.
     """
 
-    cpw_length = int("".join(filter(str.isdigit, geometry_dict["cpw_opts"]["total_length"])))
+    cpw_opts_key, cplr_opts_key, cpw_opts, cplr_opts = get_cavity_claw_options(geometry_dict)
+
+    coupler = create_coupler(geometry_dict[cplr_opts_key], design)
+    cpw_length = int("".join(filter(str.isdigit, geometry_dict[cpw_opts_key]["total_length"])))
+    cpw = create_cpw(geometry_dict[cpw_opts_key], coupler, design)
     claw = create_claw(geometry_dict["claw_opts"], cpw_length, design)
-    coupler = create_coupler(geometry_dict["cplr_opts"], design)
-    cpw = create_cpw(geometry_dict["cpw_opts"], coupler, design)
     config = SimulationConfig(min_converged_passes=3)
 
     epra, hfss = start_simulation(design, config)
@@ -266,7 +279,7 @@ def run_eigenmode(design, geometry_dict, sim_options):
     mesh_lengths = {}
     coupler_type = "CLT"
     # "finger_count" in geometry_dict["cplr_opts"]
-    if geometry_dict['cplr_opts'].get('finger_count') is not None :
+    if geometry_dict[cplr_opts_key].get('finger_count') is not None :
         coupler_type = "NCap"
         render_simulation_no_ports(epra, [cpw,claw], [(cpw.name, "start")], config.design_name, setup.vars)
         mesh_lengths = {'mesh1': {"objects": [f"trace_{cpw.name}", f"readout_connector_arm_{claw.name}"], "MaxLength": '4um'}}

squadds/simulations/utils.py

@@ -10,10 +10,10 @@
 from datetime import datetime
 
 import numpy as np
+import pandas as pd
 import qiskit_metal as metal
 import scqubits as scq
 from matplotlib import pyplot as plt
-from pandas import DataFrame
 from prettytable import PrettyTable
 from pyaedt import Hfss
 from qiskit_metal import Dict, MetalGUI, designs, draw
@@ -36,6 +36,37 @@
 from squadds.components.coupled_systems import QubitCavity
 
 
+def get_cavity_claw_options(cavity_dict):
+    # Assuming cavity_dict is already defined
+    cpw_opts = None
+    cplr_opts = None
+
+    # Iterate over the keys of cavity_dict
+    for key in cavity_dict.keys():
+        if key.startswith("cpw"):
+            cpw_opts_key = key
+            cpw_opts = cavity_dict[cpw_opts_key]
+        elif key.startswith("cplr"):
+            cplr_opts_key = key
+            cplr_opts = cavity_dict[cplr_opts_key]
+
+    return cpw_opts_key, cplr_opts_key, cpw_opts, cplr_opts
+
+def get_first_element_if_series(value):
+    """
+    Checks if the input value is a pd.Series and returns the first element if true.
+    Otherwise, returns the value unchanged.
+
+    Args:
+        value: The input value, which could be a Series or other data type.
+
+    Returns:
+        The first element if the input is a pd.Series, otherwise the input value.
+    """
+    if isinstance(value, pd.Series):
+        return value.iloc[0]  # Safely get the first element of the Series
+    return value
+
 def getMeshScreenshot(projectname, designname, solutiontype="Eigenmode"):
     """
     Get a screenshot of the mesh for a given project, design, and solution type.