Source code for kqcircuits.util.gui_helper

# This code is part of KQCircuits
# Copyright (C) 2021 IQM Finland Oy
# This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later
# version.
# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
# You should have received a copy of the GNU General Public License along with this program. If not, see
# The software distribution should follow IQM trademark policy for open-source software
# ( IQM welcomes contributions to the code. Please see our contribution agreements
# for individuals ( and organizations (

import ast
import re

from kqcircuits.pya_resolver import pya
from kqcircuits.elements.waveguide_composite import Node, WaveguideComposite
from kqcircuits.util.library_helper import load_libraries, element_by_class_name

[docs] def get_nodes_near_position(top_cell, position, box_size=10, require_gui_editing_enabled=True): """Find all WaveguideComposite nodes near a specified position. Considers only waveguides that are a direct child of the specified ``top_cell``. Args: top_cell: cell in which to search for WaveguideComposite instances position: pya.DPoint position where to search for nodes box_size: capture distance in x,y away from ``position`` where the node can be require_gui_editing_enabled: if True, only instances with ``enable_gui_editing==True`` are considered. Returns: a list of tuples ``(instance, node, node_index)`` where ``instance`` is the WaveguideComposite Instance, ``node`` is the ``Node`` object that ``node_index`` is the index of ``node`` in the ``nodes`` parameter of the waveguide. """ box = pya.DBox(pya.DPoint(-box_size, -box_size), pya.DPoint(box_size, box_size)).moved(pya.DVector(position)) found_nodes = [] for inst in top_cell.each_inst(): if inst.is_pcell() and isinstance(inst.pcell_declaration(), WaveguideComposite): if (not require_gui_editing_enabled) or inst.pcell_parameter("enable_gui_editing"): dtrans = inst.dcplx_trans nodes = Node.nodes_from_string(inst.pcell_parameter("nodes")) for i, node in enumerate(nodes): node_position = dtrans * node.position if box.contains(node_position): found_nodes.append((inst, node, i)) return found_nodes
[docs] def node_to_text(node): """Convert ``Node`` object to text fields that can be used for GUI editing. The inverse of this function is ``node_from_text``. Args: node: Node to convert Returns: tuple of strings ``(x, y, element, inst_name, angle, length_before, length_increment, align, parameters)`` """ x = str(node.position.x) y = str(node.position.y) inst_name = node.inst_name if node.inst_name is not None else "" angle = str(node.angle) if node.angle is not None else "" length_before = str(node.length_before) if node.length_before is not None else "" length_increment = str(node.length_increment) if node.length_increment is not None else "" element = node.element.__name__ if node.element is not None else "" align = ",".join(node.align) if node.align is not None else "" parameters = "\n".join([f"{key}={repr(value)}" for key, value in node.params.items()]) return (x, y, element, inst_name, angle, length_before, length_increment, align, parameters)
[docs] def node_from_text(x, y, element, inst_name, angle, length_before, length_increment, align, parameters): """Create Node from text inputs. This is the inverse of ``node_to_text``. For all arguments except x and y, an empty string is treated as default value. Spaces are stripped from the inputs. For ``parameters``, the values will be parsed by ``ast.literal_eval``, which accepts most standard python literals. Args: x (str): x position, will be converted to float y (str): y position, will be converted to float element (str): class name of the element, must exist in the `kqcircuits.elements` namespace inst_name (str): instance name to use for the element angle (str): angle of the node, will be converted to float length_before (str): length before this node, will be converted to float length_increment (str): length increment produced by meander before this node, will be converted to float align (str): input and output refpoint to use for aligning the element, separated by a comma parameters (str): multiline string, where each line contains a parameter=value pair. Returns: Node Raises: ValueError: if an input value cannot be converted to the correct type. """ x = float(x) y = float(y) params = {} if inst_name != "": params["inst_name"] = inst_name.strip() if angle != "": params["angle"] = float(angle) if length_before != "": params["length_before"] = float(length_before) if length_increment != "": params["length_increment"] = float(length_increment) element = element.strip() if element == "": element = None if align != "": params["align"] = tuple(s.strip() for s in align.split(",")) param_lines = parameters.split("\n") for param_line in param_lines: param_line = param_line.strip() if param_line != "": m = re.fullmatch(r"([a-zA-Z0-9_]+)\s*=\s*(.*)", param_line) if not m: raise ValueError("Element parameters should be one key=value pair on each line") key = m.groups()[0] value = ast.literal_eval(m.groups()[1]) params[key] = value return Node.deserialize((x, y, element, params))
[docs] def replace_node(waveguide_instance, node_index, node): """Replace a Node in a WaveguideComposite by index. Args: waveguide_instance: Instance of the waveguide node_index: (int) index of the node to replace node: new Node """ nodes = Node.nodes_from_string(waveguide_instance.pcell_parameter("nodes")) nodes[node_index] = node waveguide_instance.change_pcell_parameter("nodes", [str(node) for node in nodes]) # Update gui_path and gui_path_shadow to reflect possible position changes in the node if waveguide_instance.pcell_parameter("enable_gui_editing"): path = pya.DPath([node.position for node in nodes], 1) # Round to database units since the KLayout partial tool also works in database units dbu = waveguide_instance.layout().dbu path = path.to_itype(dbu).to_dtype(dbu) waveguide_instance.change_pcell_parameter("gui_path", path) waveguide_instance.change_pcell_parameter("gui_path_shadow", path)
[docs] def get_all_node_elements(): """Returns all class names from PCells in the Element library which can be used in WaveguideComposite nodes Returns: List of class names (str) """ valid_elements = ["Airbridge"] layout = load_libraries(path="elements")["Element Library"].layout() for pcell_id in layout.pcell_ids(): pcell = layout.pcell_declaration(pcell_id) valid_elements.append(pcell.__class__.__name__) return valid_elements
[docs] def get_valid_node_elements(): """Returns a list of all element class names which would be, at least in principle, usable as ```Node.element```. An element is considered valid if it has at least two refpoint pairs ```X``` and ```X_corner```, for any value of x. Note: this function creates each element with default parameter values. Since this is generally slow and clumsy, this function is not used at startup. Instead, a curated list ```node_editor_valid_elements``` is kept in ```kqcircuits.defaults```. Returns: List of class names (str) """ layout = pya.Layout() all_elements = get_all_node_elements() valid_elements = [] for classname in all_elements: element = element_by_class_name(classname) if element is not None: cell, refp = element.create_with_refpoints(layout) refpoints_with_corner = [ name.rstrip("_corner") for name in refp if name.endswith("_corner") and name.rstrip("_corner") in refp ] layout.delete_cell(cell.cell_index()) if len(refpoints_with_corner) > 1: valid_elements.append(classname) else: valid_elements.append(classname) return valid_elements