#-*- coding: utf-8 -*-
from typing import Union, Tuple
from qiskit_metal.renderers.renderer_ansys_pyaedt.pyaedt_base import QPyaedt
from qiskit_metal.toolbox_metal.parsing import is_true
from qiskit_metal import Dict
from pyaedt import settings
import pandas as pd
import numpy as np
import shapely
[docs]
class QQ3DPyaedt(QPyaedt):
"""
Subclass of pyaedt renderer for running Q3D simulations.
QPyaedt Default Options:
"""
name = 'aedt_q3d'
default_setup = Dict(
name="QQ3DPyaedt_setup",
AdaptiveFreq="5.0", # in GHz
SaveFields="False",
Enabled="True",
MaxPass="15",
MinPass="2",
MinConvPass="2",
PerError="0.5",
PerRefine="30",
AutoIncreaseSolutionOrder="True",
SolutionOrder="High",
Solver_Type="Iterative",
)
"""Default setup."""
aedt_q3d_options = Dict(material_type='pec', material_thickness='200nm')
"""aedt Q3D Options"""
def __init__(self,
multilayer_design: 'MultiPlanar',
project_name: Union[str, None] = None,
design_name: Union[str, None] = None,
initiate=False,
options: Dict = None):
"""Create a QRenderer for Q3D simulations using pyaedt and multiplanar design.
QQ3DPyaedt is subclassed from QPyaedt, subclassed from QRendererAnalysis and
subclassed from QRenderer.
QAnsysRenderer Default Options:
* Lj: '10nH' -- Lj has units of nanoHenries (nH)
* Cj: 0 -- Cj *must* be 0 for pyEPR analysis! Cj has units of femtofarads (fF)
* _Rj: 0 -- _Rj *must* be 0 for pyEPR analysis! _Rj has units of Ohms
* max_mesh_length_jj: '7um' -- Maximum mesh length for Josephson junction elements
* project_path: None -- Default project path; if None --> get active
* project_name: None -- Default project name
* design_name: None -- Default design name
* ansys_file_extension: '.aedt' -- Ansys file extension for 2016 version and newer
* x_buffer_width_mm: 0.2 -- Buffer between max/min x and edge of ground plane, in mm
* y_buffer_width_mm: 0.2 -- Buffer between max/min y and edge of ground plane, in mm
Args:
multilayer_design (MultiPlanar): Use QGeometry within MultiPlanar to obtain elements for Ansys.
project_name (Union[str, None], optional): Give a name, or one will be made based on
class name of renderer. Defaults to None.
design_name (Union[str, None], optional): Give a name, or one will be made based on
class name of renderer. Defaults to None.
initiate (bool, optional): True to initiate the renderer. Defaults to False.
options (Dict, optional): Used to override all options. Defaults to None.
"""
super().__init__(multilayer_design,
renderer_type='Q3D',
project_name=project_name,
design_name=design_name,
initiate=initiate,
options=options)
# QRenderer has a "cls" method called load()
if_registered_in_design = QQ3DPyaedt.load()
#make a class to read in pandas table.
self.tables = None
# Note: desktop is instantiated in the parent's init.
#
# Updating an existing setup would be nice, but for now,
# pyaedt is not easy to use, right now.
# edit_setup appear to delete previous setup values.
# get_setup could get the values of a setup, then one could
# potentially edit that and save it.
# So will get back to this later.
# https://aedtdocs.pyansys.com/API/_autosummary/pyaedt.modules.SolveSetup.Setup.update.html?highlight=update+setup
# The above link used to exist, but has since been unattainable.
#
# def update_q3d_setup(self, q3d_setup_name: str):
# # Activate project_name and design_name before anything else
# self.activate_user_project_design()
# # # get the setup names
# # all_setup_names = list(self.current_app.setup_names)
# # if q3d_setup_name in all_setup_names:
# # self.current_app
# # check if name is in design
# # then enable
# #otherwise
# # be created by the values in default_setup
# # self.add_q3d_setup()
[docs]
def add_q3d_setup(self,
name: str = None,
AdaptiveFreq: float = None,
SaveFields: bool = None,
Enabled: bool = None,
MaxPass: int = None,
MinPass: int = None,
MinConvPass: int = None,
PerError: float = None,
PerRefine: int = None,
AutoIncreaseSolutionOrder: bool = None,
SolutionOrder: str = None,
Solver_Type: str = None):
"""Create a solution setup in Ansys Q3D. If user does not provide
arguments, they will be obtained from QQ3DPyaedt.default_setup dict.
Args:
name (str, optional): Name of solution setup. Defaults to None.
AdaptiveFreq (float, optional): Adaptive frequency in GHz. Defaults to None.
SaveFields (bool, optional): Whether or not to save fields. Defaults to None.
Enabled (bool, optional): Whether or not setup is enabled. Defaults to None.
MaxPass (int, optional): Maximum number of passes. Defaults to None.
MinPass (int, optional): Minimum number of passes. Defaults to None.
MinConvPass (int, optional): Minimum number of converged passes. Defaults to None.
PerError (float, optional): Error tolerance as a percentage. Defaults to None.
PerRefine (int, optional): Refinement as a percentage. Defaults to None.
AutoIncreaseSolutionOrder (bool, optional): Whether or not to increase solution order automatically. Defaults to None.
SolutionOrder (str, optional): Solution order. Defaults to None.
Solver_Type (str, optional): Solver type. Defaults to None.
"""
self.activate_user_project_design()
su = self.default_setup
if not name:
name = self.parse_value(su['name'])
if name in self.current_app.setup_names:
self.logger.warning(
f'The setup name already exists within '
f'project:{self.project_name} design: {self.design_name}. '
f'So a new setup with name={name} was NOT added to design.')
return
if not AdaptiveFreq:
AdaptiveFreq = float(self.parse_value(su['AdaptiveFreq']))
if not SaveFields:
SaveFields = is_true(su['SaveFields'])
if not Enabled:
Enabled = is_true(su['Enabled'])
if not MaxPass:
MaxPass = int(self.parse_value(su['MaxPass']))
if not MinPass:
MinPass = int(self.parse_value(su['MinPass']))
if not MinConvPass:
MinConvPass = int(self.parse_value(su['MinConvPass']))
if not PerError:
PerError = float(self.parse_value(su['PerError']))
if not PerRefine:
PerRefine = int(self.parse_value(su['PerRefine']))
if not AutoIncreaseSolutionOrder:
AutoIncreaseSolutionOrder = is_true(su['AutoIncreaseSolutionOrder'])
if not SolutionOrder:
SolutionOrder = self.parse_value(su['SolutionOrder'])
if not Solver_Type:
Solver_Type = self.parse_value(su['Solver_Type'])
new_setup = self.current_app.create_setup(name)
# yapf: disable
new_setup.props['AdaptiveFreq'] = f'{AdaptiveFreq}GHz'
new_setup.props['SaveFields'] = SaveFields
new_setup.props['Enabled'] = Enabled
new_setup.props['Cap']['MaxPass'] = MaxPass
new_setup.props['Cap']['MinPass'] = MinPass
new_setup.props['Cap']['MinConvPass'] = MinConvPass
new_setup.props['Cap']['PerError'] = PerError
new_setup.props['Cap']['PerRefine'] = PerRefine
new_setup.props['Cap']['AutoIncreaseSolutionOrder'] = AutoIncreaseSolutionOrder
new_setup.props['Cap']['SolutionOrder'] = SolutionOrder
new_setup.props['Cap']['Solver Type'] = Solver_Type
# yapf: enable
new_setup.props.pop('AC', None)
new_setup.props.pop('DC', None)
new_setup.update()
# pylint: disable=arguments-differ
[docs]
def render_design(self,
selection: Union[list, None] = None,
open_pins: Union[list, None] = None,
box_plus_buffer: bool = True):
"""
This render_design will add additional logic for Q3D within project.
Initiate rendering of components in design contained in selection,
assuming they're valid. Components are rendered before the chips they
reside on, and subtraction of negative shapes is performed at the very
end.
First obtain a list of IDs of components to render and a corresponding case, denoted by self.qcomp_ids
and self.case, respectively. If self.case == 1, all components in QDesign are to be rendered.
If self.case == 0, a strict subset of components in QDesign are to be rendered. Otherwise, if
self.case == 2, one or more component names in selection cannot be found in QDesign.
Chip_subtract_dict consists of component names (keys) and a set of all elements within each component that
will eventually be subtracted from the ground plane. Add objects that are perfect conductors and/or have
meshing to self.assign_perfE and self.assign_mesh, respectively; both are initialized as empty lists. Note
that these objects are "refreshed" each time render_design is called (as opposed to in the init function)
to clear QAnsysRenderer of any leftover items from the last call to render_design.
Among the components selected for export, there may or may not be unused (unconnected) pins.
The second parameter, open_pins, contains tuples of the form (component_name, pin_name) that
specify exactly which pins should be open rather than shorted during the simulation. Both the
component and pin name must be specified because the latter could be shared by multiple
components. All pins in this list are rendered with an additional endcap in the form of a
rectangular cutout, to be subtracted from its respective plane.
The final parameter, box_plus_buffer, determines how the chip is drawn. When set to True, it takes the
minimum rectangular bounding box of all rendered components and adds a buffer of x_buffer_width_mm and
y_buffer_width_mm horizontally and vertically, respectively, to the chip size. The center of the chip
lies at the midpoint x/y coordinates of the minimum rectangular bounding box and may change depending
on which components are rendered and how they're positioned. If box_plus_buffer is False, however, the
chip position and dimensions are taken from the chip info dictionary found in self.design, irrespective
of what's being rendered. While this latter option is faster because it doesn't require calculating a
bounding box, it runs the risk of rendered components being too close to the edge of the chip or even
falling outside its boundaries.
Args:
selection (Union[list, None], optional): List of components to render. Defaults to None.
open_pins (Union[list, None], optional): List of tuples of pins that are open. Defaults to None.
box_plus_buffer (bool, optional): Either calculate a bounding box based on the location of rendered geometries
or use chip size from design class.
"""
# self.fill_info will hold the name of newly generated box,
# along with information from layer stack
self.fill_info = self.design.ls.get_layer_datatype_when_fill_is_true()
# Draw in fill = True pieces. based on either full chip or box_plus
# They are reset for each time render_design happens.
super().render_design(selection, box_plus_buffer)
if self.case == 2:
self.logger.warning(
'Unable to proceed with rendering. Please check selection.')
return
self.open_pins_is_valid = self.confirm_open_pins_are_valid_names(
open_pins, [])
if not self.open_pins_is_valid:
self.logger.error(
f'Check the arguments to render_design, invalid name was probably used.'
)
else:
self.activate_user_project_design()
# Ansys default units is 'mm'?????, but metal using 'meter'.
# pyaedt.generic.constants.SI_UNITS.Length is meter.
if open_pins and self.open_pins_is_valid:
self.aedt_render_by_layer_then_tables(open_pins=open_pins)
else:
self.aedt_render_by_layer_then_tables(open_pins=None)
# self.add_mesh()
# self.assign_thin_conductor()
# self.assign_nets()
return
[docs]
def aedt_render_by_layer_then_tables(self,
open_pins: Union[list, None],
data_type: int = 0):
"""_summary_
Args:
open_pins (Union[list, None], optional): _description_. Defaults to None.
datatype (int, optional): _description_. Defaults to 0.
"""
# For Q3d skip_junction is always True.
super().aedt_render_by_layer_then_tables(skip_junction=True,
open_pins=open_pins,
port_list=None,
jj_to_port=None,
ignored_jjs=None,
data_type=data_type)
for layer_num in sorted(
self.design.qgeometry.get_all_unique_layers_for_all_tables(
self.qcomp_ids)):
for table_type in self.design.qgeometry.get_element_types():
if table_type != 'junction':
#At this point, we know table type,
self.render_components(table_type,
layer_num,
port_list=None,
jj_to_port=None,
ignored_jjs=None)
#For each layer, add the endcaps and
# add polyline to subtract to self.chip_subtract_dict[layer_num].
if isinstance(open_pins, list):
# Only use this method if user defines open pins.
if open_pins:
#Confirm there is something in the list.
open_pins_subset = self.get_open_pins_in_layer(
open_pins, layer_num)
self.add_endcaps(open_pins_subset, layer_num)
# The layer is obtained from qgeometry tables, but layer_stack
# can have multiple data_types. For now, the subtract will
# happen from data_type==0.
self.subtract_from_ground(layer_num, data_type=data_type)
#self.current_app.modeler.sheet_names
a = 5
# commenting this out for now.
# def get_data(self):
# self.current_app.post.get_solution_data()
# all_cell_names = self.current_app.matrices[0].get_sources_for_plot(
# a=5
[docs]
def analyze_setup(self, setup_name: str):
"""Run a specific solution setup in Ansys Q3D.
Args:
setup_name (str): Name of setup.
"""
# Activate project_name and design_name before anything else
self.activate_user_project_design()
if setup_name in self.current_app.setup_names:
if self.current_app.auto_identify_nets():
self.current_app.analyze_setup(setup_name)
else:
self.logger.warning(
f'Auto Identify Nets returned False. '
f'Please review your design to see what is failing. '
f'Within Ansys, press simulation in the tab, then validate (green check mark).'
)
else:
self.logger.warning(
f'Since the setup_name is not in the project/design which was used to start Q3d, '
f'a new setup will be added with default settings for Q3D.')
self.add_q3d_setup(setup_name)
if self.current_app.auto_identify_nets():
self.current_app.analyze_setup(setup_name)
else:
self.logger.warning(
f'Auto Identify Nets returned False. '
f'Please review your design to see what is failing. '
f'Within Ansys, press simulation in the tab, then validate (green check mark).'
)
# Below commands are from a notebook which shows abstraction usage.
# c2.sim.capacitance_matrix, c2.sim.units = q3d.get_capacitance_matrix()
# c2.sim.capacitance_all_passes, _ = q3d.get_capacitance_all_passes()
# c2.sim.capacitance_matrix
[docs]
def get_capacitance_matrix(self):
a = 5
[docs]
def get_capacitance_all_passes(self, setup_name: str) -> Union[dict, None]:
"""ASSUME analyze_setup() has already happened.
Get the magnitude of solution data in pandas data
format for each pass.
Args:
setup_name (str): Name of setup which has already been
used for analyze_setup().
Returns:
Union[dict, None]: Key - freq in GHz Value is a list. The 0 th index is key, the
1st entry is the 1st pass is a pandas dataframe of capacitance matrix. (magnitude)
2nd entry is the 2nd pass is a pandas dataframe of capacitance matrix. (magnitude)
etc....
If analyze_setup has not been run, return None.
"""
all_C_matrices = self.current_app.matrices[0].get_sources_for_plot()
if len(all_C_matrices) == 0:
self.design.logger.warning(
f'There are no capacitance matrixes to return.'
f'Did you execute analyze_setup()?')
return None
# Pandas output should have been set prior to opening Ansys,
# however, just confirming if changed by user through GUI.
settings.enable_pandas_output = True
setup_sweep_name = f'{setup_name}: AdaptivePass'
cap_data = self.current_app.post.get_solution_data(
expressions=all_C_matrices,
context="Original",
setup_sweep_name=setup_sweep_name,
variations={"Pass": ["All"]})
c1_units = cap_data.units_data
all_cap_data_magnitude = []
all_cap_data_magnitude_freqs = {}
confirm_freq = cap_data.active_intrinsic['Freq'] # Is 5.0
# If a list is not returned, make one so can iterate through it.
if isinstance(confirm_freq, float):
confirm_freq = [confirm_freq]
for freq in confirm_freq:
all_cap_data_magnitude.append(freq)
for item in cap_data.intrinsics['Pass']:
#cap_real_imag = cap_data.full_matrix_real_imag
cap_mag = cap_data.full_matrix_mag_phase[0].iloc[int(item) - 1]
cap_mag_df = self.convert_to_dataframe(cap_mag)
all_cap_data_magnitude.append(cap_mag_df)
all_cap_data_magnitude_freqs[freq] = all_cap_data_magnitude
return all_cap_data_magnitude_freqs
[docs]
def convert_to_dataframe(
self, cap_series: pd.core.series.Series
) -> Union[pd.core.frame.DataFrame, None]:
"""Convert the series to a dataframe based on the column names.
If the names are missing, then the dataframe will be None.
Args:
cap_series (pd.core.series.Series): Series given by pyaedt.
Returns:
Union[pd.core.frame.DataFrame, None]: A dataframe if there are names in columns.
Otherwise, None.
"""
df = None
row_names, col_names = self.get_unique_row_and_col_names(cap_series)
len_row_names = len(row_names)
len_col_names = len(col_names)
if len_row_names == 0 or len_col_names == 0:
self.design.logger.warning(
f'The dataframe for solution data was not made.'
f'The names of rows={row_names} or columns={col_names} are empty.'
f'The dataframe was not made and is None.')
else:
df = pd.DataFrame(np.empty((len_row_names, len_col_names),
dtype=object),
index=pd.Index(row_names),
columns=pd.Index(col_names))
#for series_name in cap_series.index:
for series_name, value in cap_series.items():
# ASSUME format from pyaedt, C(row_name , col_name)
row_name, col_name = series_name[2:-1].split(',', 1)
df.loc[row_name, [col_name]] = value
return df
[docs]
def get_unique_row_and_col_names(
self, cap_series: pd.core.series.Series) -> Tuple[list, list]:
"""Parse the names in the series and identify the unique names
for rows and columns
Args:
cap_series (pd.core.series.Series): Data from pyaedt with assumed format for names:
C(row_name , col_name)
Returns:
Tuple[list, list]: 1st is names of rows and second set is names of columns.
Should be in alphabetical order.
"""
row_names = set()
col_names = set()
for series_name in cap_series.index:
# ASSUME format from pyaedt, C(row_name , col_name)
row_name, col_name = series_name[2:-1].split(',', 1)
row_names.add(row_name)
col_names.add(col_name)
return sorted(row_names), sorted(col_names)
[docs]
def render_element(self,
qgeom: pd.Series,
is_junction: bool,
port_list: None = None,
jj_to_port: None = None,
ignored_jjs: None = None):
"""Render an individual shape whose properties are listed in a row of
QGeometry table. Junction elements are handled separately from non-
junction elements. For Q3D, junctions are not rendered.
For Q3D, port_list, jj_to_port, and ignored_jjs are not used.
Args:
qgeom (pd.Series): GeoSeries of element properties.
is_junction (bool): Whether or not qgeom belongs to junction table.
"""
qc_shapely = qgeom.geometry
if not is_junction:
#Q3D doesn't render junction.
if isinstance(qc_shapely, shapely.geometry.Polygon):
self.render_element_poly(qgeom)
elif isinstance(qc_shapely, shapely.geometry.LineString):
self.render_element_path(qgeom)