piel.tools
#
Subpackages#
Package Contents#
Functions#
|
Checks if a cocotb testbench exists in the design directory. |
|
Writes a cocotb makefile. |
|
Equivalent to running the cocotb makefile |
|
This function returns a list of all the simulation output files in the design directory. |
|
This function returns a Pandas dataframe that contains all the simulation data outputted from the simulation run. |
|
|
|
This function returns the input ports of a component. However, input ports may have different sets of prefixes and suffixes. This function implements different sorting algorithms for different ports names. The default algorithm is prefix, which sorts the ports by their prefix. The Endianness implementation means that the tuple order is determined according to the last numerical index order of the port numbering. |
|
This function returns the input ports of a component. However, input ports may have different sets of prefixes |
Returns a thermal phase shifter that has properly fixed electrical connectivity to extract a suitable electrical netlist and models. |
|
|
This function provides the integration mechanism for easily migrating the interconnection with other toolsets from an OpenLane v1 design to an OpenLane v2 design. |
|
Extracts the datetime from a given run_path and returns it as a string. |
|
For a given design_directory, the openlane output can be found in the runs subdirectory. This function sorts the runs according to the default notations between both openlane and openlane2 run formats. |
|
For a given design_directory, the openlane output can be found in the runs subdirectory. This function sorts the runs according to the default notations between both openlane and openlane2 run formats. |
|
Returns the path to the final GDS generated by OpenLane. |
|
Returns the version of the design run. |
|
For a given design_directory, the openlane output can be found in the runs subdirectory. This function sorts the runs according to the default notations between both openlane and openlane2 run formats. |
Checks if a design has a config.json file. |
|
|
Checks if a design exists in the OpenLane v1 design folder. |
Configures and runs an OpenLane v1 design. |
|
For a given source_design_directory, this function reads in the config.json file and returns a set of parametric sweeps that gets used when creating a set of parametric designs. |
|
Configures the OpenLane v1 flow script after checking that the design directory exists. |
|
Takes a OpenLane v1 source directory and creates a parametric combination of these designs. |
|
|
Gets the design directory from the root directory. |
|
Gets the latest version root of OpenLane v1. |
|
Reads a config.json from a design directory. |
|
Writes a config.json onto a design_directory |
|
Filter the timing sta files from the list of files |
|
Filter the power sta files from the list of files |
|
This function aims to list and perform analysis on all the relevant files in a particular run between all the corners. |
|
This function aims to list and perform analysis on all the relevant files in a particular run between all the corners. |
|
Calculate the maximum frame amount based on the frame IDs in the DataFrame |
|
Calculate the propagation delay for each frame in the file |
Calculate the propagation delay between two nets |
|
|
Identify the timing data lines for each frame and creates a metadata dictionary for frames. |
|
Identify the frame delimiters and assign frame ID to each line in the file |
|
Filter the timing data by net name and type |
|
Get the frame metadata |
|
Calculate the timing data for each frame in the file |
|
Extract the timing data from the file |
|
Calculate the timing data for each frame in the file |
|
Read the fixed width file and return a DataFrame |
|
Check if the keyword is contained in the file lines |
|
Create a DataFrame from the raw lines of a file |
|
Extract the data from the file lines using the given keyword and regex |
|
Extract lines from the file |
|
Returns a dictionary of all the metrics for all the designs in the output directory. |
|
Read design metrics from OpenLane v2 run files. |
|
Runs the OpenLane v2 flow. |
|
This function configures the NGSPICE simulation for the circuit and returns a simulation class. |
|
This function configures the DC operating point simulation for the circuit and returns a simulation class. |
|
This function configures the transient simulation for the circuit and returns a simulation class. |
|
This function runs the transient simulation for the circuit and returns the results. |
|
This function converts a numeric value to a number under a SPICE unit closest to the base prefix. This allows us to connect a particular number real output, into a term that can be used in a SPICE netlist. |
|
This function converts an address of an instance with particular parameter values in the form: |
|
This function returns the recursive location of any matching |
|
Returns a dictionary of all instances of a given component in a recursive netlist. |
Returns a list of all instances with a given prefix in a recursive netlist. |
|
This function returns an active component list with a tuple mapping of the location of the active component within the recursive netlist and corresponding model. It will recursively look within a netlist to locate what models use a particular component model. At each stage of recursion, it will compose a list of the elements that implement this matching model in order to relate the model to the instance, and hence the netlist address of the component that needs to be updated in order to functionally implement the model. |
|
|
This function returns the ports index of the sax dense S-parameter matrix. |
|
A |
For a specific amount of modes, we can generate all the possible Fock states for whatever amount of input photons we desire. This returns a list of all corresponding Fock states. |
|
|
|
|
This function returns the indexes of the nonzero elements of a Fock state. |
This function converts a Fock state defined as: |
|
|
This function returns a list of valid Fock states that fulfill a condition of having a maximum photon number at a specific mode index. |
This function returns a list of valid Fock states where each state has a maximum photon number, but only in one mode. |
|
|
Verify that the matrix is unitary. |
|
This function returns a unitary between the indexes selected, and verifies the indexes are valid by checking that |
|
This function returns a unitary between the indexes selected, and verifies the indexes are valid by checking that |
Attributes#
- check_cocotb_testbench_exists(design_directory: str | pathlib.Path) bool [source]#
Checks if a cocotb testbench exists in the design directory.
- Parameters:
design_directory (str | pathlib.Path) – Design directory.
- Returns:
True if cocotb testbench exists.
- Return type:
cocotb_testbench_exists(bool)
- configure_cocotb_simulation(design_directory: str | pathlib.Path, simulator: Literal[icarus, verilator], top_level_language: Literal[verilog, vhdl], top_level_verilog_module: str, test_python_module: str, design_sources_list: list | None = None)[source]#
Writes a cocotb makefile.
If no design_sources_list is provided then it adds all the design sources under the src folder.
In the form .. code-block:
#!/bin/sh # Makefile # defaults SIM ?= icarus TOPLEVEL_LANG ?= verilog # Note we need to include the test script to the PYTHONPATH export PYTHONPATH = VERILOG_SOURCES += $(PWD)/my_design.sv # use VHDL_SOURCES for VHDL files # TOPLEVEL is the name of the toplevel module in your Verilog or VHDL file TOPLEVEL := my_design # MODULE is the basename of the Python test file MODULE := test_my_design # include cocotb's make rules to take care of the simulator setup include $(shell cocotb-config --makefiles)/Makefile.sim
- Parameters:
design_directory (str | pathlib.Path) – The directory where the design is located.
simulator (Literal["icarus", "verilator"]) – The simulator to use.
top_level_language (Literal["verilog", "vhdl"]) – The top level language.
top_level_verilog_module (str) – The top level verilog module.
test_python_module (str) – The test python module.
design_sources_list (list | None, optional) – A list of design sources. Defaults to None.
- Returns:
None
- delete_simulation_output_files#
- run_cocotb_simulation(design_directory: str) subprocess.CompletedProcess [source]#
Equivalent to running the cocotb makefile .. code-block:
make
- Parameters:
design_directory (str) – The directory where the design is located.
- Returns:
The subprocess.CompletedProcess object.
- Return type:
subprocess.CompletedProcess
- get_simulation_output_files#
- get_simulation_output_files_from_design(design_directory: piel.types.piel_path_types, extension: str = 'csv')[source]#
This function returns a list of all the simulation output files in the design directory.
- Parameters:
design_directory (piel_path_types) – The path to the design directory.
- Returns:
List of all the simulation output files in the design directory.
- Return type:
output_files (list)
- read_simulation_data(file_path: piel.types.piel_path_types)[source]#
This function returns a Pandas dataframe that contains all the simulation data outputted from the simulation run.
- Parameters:
file_path (piel_path_types) – The path to the simulation data file.
- Returns:
The simulation data in a Pandas dataframe.
- Return type:
simulation_data (pd.DataFrame)
- get_input_ports_index(ports_index: dict, sorting_algorithm: Literal[get_input_ports_index.prefix] = 'prefix', prefix: str = 'in') tuple [source]#
This function returns the input ports of a component. However, input ports may have different sets of prefixes and suffixes. This function implements different sorting algorithms for different ports names. The default algorithm is prefix, which sorts the ports by their prefix. The Endianness implementation means that the tuple order is determined according to the last numerical index order of the port numbering.
raw_ports_index = { "in_o_0": 0, "out_o_0": 1, "out_o_1": 2, "out_o_2": 3, "out_o_3": 4, "in_o_1": 5, "in_o_2": 6, "in_o_3": 7, } get_input_ports_index(ports_index=raw_ports_index) # Output ((0, "in_o_0"), (5, "in_o_1"), (6, "in_o_2"), (7, "in_o_3"))
- Parameters:
ports_index (dict) – The ports index dictionary.
sorting_algorithm (Literal["prefix"], optional) – The sorting algorithm to use. Defaults to “prefix”.
prefix (str, optional) – The prefix to use for the sorting algorithm. Defaults to “in”.
- Returns:
The ordered input ports index tuple.
- Return type:
tuple
- get_matched_ports_tuple_index(ports_index: dict, selected_ports_tuple: tuple | None = None, sorting_algorithm: Literal[get_matched_ports_tuple_index.prefix, selected_ports] = 'prefix', prefix: str = 'in')[source]#
This function returns the input ports of a component. However, input ports may have different sets of prefixes and suffixes. This function implements different sorting algorithms for different ports names. The default algorithm is prefix, which sorts the ports by their prefix. The Endianness implementation means that the tuple order is determined according to the last numerical index order of the port numbering. Returns just a tuple of the index.
raw_ports_index = { "in_o_0": 0, "out_o_0": 1, "out_o_1": 2, "out_o_2": 3, "out_o_3": 4, "in_o_1": 5, "in_o_2": 6, "in_o_3": 7, } get_input_ports_tuple_index(ports_index=raw_ports_index) # Output (0, 5, 6, 7)
- Parameters:
ports_index (dict) – The ports index dictionary.
selected_ports_tuple (tuple, optional) – The selected ports tuple. Defaults to None.
sorting_algorithm (Literal["prefix"], optional) – The sorting algorithm to use. Defaults to “prefix”.
prefix (str, optional) – The prefix to use for the sorting algorithm. Defaults to “in”.
- Returns:
The ordered input ports index tuple. matched_ports_name_tuple_order(tuple): The ordered input ports name tuple.
- Return type:
matches_ports_index_tuple_order(tuple)
- straight_heater_metal_simple(length: float = 320.0, length_straight_input: float = 15.0, heater_width: float = 2.5, cross_section_heater: gdsfactory.typings.CrossSectionSpec = 'heater_metal', cross_section_waveguide_heater: gdsfactory.typings.CrossSectionSpec = 'strip_heater_metal', via_stack: gdsfactory.typings.ComponentSpec | None = 'via_stack_heater_mtop', port_orientation1: int | None = None, port_orientation2: int | None = None, heater_taper_length: float | None = 5.0, ohms_per_square: float | None = None, **kwargs) gdsfactory.component.Component [source]#
Returns a thermal phase shifter that has properly fixed electrical connectivity to extract a suitable electrical netlist and models. dimensions from https://doi.org/10.1364/OE.27.010456 :param length: of the waveguide. :param length_undercut_spacing: from undercut regions. :param length_undercut: length of each undercut section. :param length_straight_input: from input port to where trenches start. :param heater_width: in um. :param cross_section_heater: for heated sections. heater metal only. :param cross_section_waveguide_heater: for heated sections. :param cross_section_heater_undercut: for heated sections with undercut. :param with_undercut: isolation trenches for higher efficiency. :param via_stack: via stack. :param port_orientation1: left via stack port orientation. :param port_orientation2: right via stack port orientation. :param heater_taper_length: minimizes current concentrations from heater to via_stack. :param ohms_per_square: to calculate resistance. :param cross_section: for waveguide ports. :param kwargs: cross_section common settings.
- get_design_from_openlane_migration(v1: bool = True, design_name_v1: str | None = None, design_directory: str | pathlib.Path | None = None, root_directory_v1: str | pathlib.Path | None = None)[source]#
This function provides the integration mechanism for easily migrating the interconnection with other toolsets from an OpenLane v1 design to an OpenLane v2 design.
This function checks if the inputs are to be treated as v1 inputs. If so, and a design_name is provided then it will set the design_directory to the corresponding design_name directory in the corresponding root_directory_v1 / designs. If no root_directory is provided then it returns $OPENLANE_ROOT/”<latest>”/. If a `design_directory is provided then this will always take precedence even with a v1 flag.
- Parameters:
v1 (bool) – If True, it will migrate from v1 to v2.
design_name_v1 (str) – Design name of the v1 design that can be found within $OPENLANE_ROOT/”<latest>”/designs.
design_directory (str) – Design directory PATH. Optional path for v2-based designs.
root_directory_v1 (str) – Root directory of OpenLane v1. If set to None it will return $OPENLANE_ROOT/”<latest>”
- Returns:
None
- extract_datetime_from_path(run_path: pathlib.Path) str [source]#
Extracts the datetime from a given run_path and returns it as a string.
- find_all_design_runs(design_directory: piel.types.piel_path_types, run_name: str | None = None) list[pathlib.Path] [source]#
For a given design_directory, the openlane output can be found in the runs subdirectory. This function sorts the runs according to the default notations between both openlane and openlane2 run formats.
If a run_name is specified, then the function will return the exact run if it exists. Otherwise, it will return the latest run
- Parameters:
design_directory (piel_path_types) – The path to the design directory
run_name (str, optional) – The name of the run to return. Defaults to None.
version (Literal["v1", "v2"], optional) – The version of OpenLane to use. Defaults to None.
- Raises:
ValueError – If the run_name is specified but not found in the design_directory
- Returns:
A list of pathlib.Path objects corresponding to the runs
- Return type:
list[pathlib.Path]
- find_latest_design_run(design_directory: piel.types.piel_path_types, run_name: str | None = None, version: Literal[v1, v2] | None = None)[source]#
For a given design_directory, the openlane output can be found in the runs subdirectory. This function sorts the runs according to the default notations between both openlane and openlane2 run formats.
If a run_name is specified, then the function will return the exact run if it exists. Otherwise, it will return the latest run.
- Parameters:
design_directory (piel_path_types) – The path to the design directory
run_name (str, optional) – The name of the run to return. Defaults to None.
version (Literal["v1", "v2"], optional) – The version of the run to return. Defaults to None.
- Raises:
ValueError – If the run_name is specified but not found in the design_directory
- Returns:
A tuple of the latest run path and the version
- Return type:
(pathlib.Path, str)
- get_gds_path_from_design_run(design_directory: piel.types.piel_path_types, run_directory: piel.types.piel_path_types | None = None) pathlib.Path [source]#
Returns the path to the final GDS generated by OpenLane.
- Parameters:
design_directory (piel_path_types) – The path to the design directory
run_directory (piel_path_types, optional) – The path to the run directory. Defaults to None. Otherwise gets the latest run.
- Returns:
The path to the final GDS
- Return type:
pathlib.Path
- get_design_run_version(run_directory: piel.types.piel_path_types) Literal[v1, v2] [source]#
Returns the version of the design run.
- sort_design_runs(path_list: list[pathlib.Path]) dict[str, list[pathlib.Path]] [source]#
For a given design_directory, the openlane output can be found in the runs subdirectory. This function sorts the runs according to the default notations between both openlane and openlane2 run formats.
- Parameters:
path_list (list[pathlib.Path]) – A list of pathlib.Path objects corresponding to the runs
- Returns:
A dictionary of sorted runs
- Return type:
dict[str, list[pathlib.Path]]
- check_config_json_exists_openlane_v1(design_name: str, root_directory: str | pathlib.Path | None = None) bool [source]#
Checks if a design has a config.json file.
- Parameters:
design_name (str) – Name of the design.
- Returns:
True if config.json exists.
- Return type:
config_json_exists(bool)
- check_design_exists_openlane_v1(design_name: str, root_directory: str | pathlib.Path | None = None) bool [source]#
Checks if a design exists in the OpenLane v1 design folder.
Lists all designs inside the Openlane V1 design root.
- Parameters:
design_name (str) – Name of the design.
- Returns:
True if design exists.
- Return type:
design_exists(bool)
- configure_and_run_design_openlane_v1(design_name: str, configuration: dict | None = None, root_directory: str | pathlib.Path | None = None) None [source]#
Configures and runs an OpenLane v1 design.
This function does the following: 1. Check that the design_directory provided is under $OPENLANE_ROOT/<latestversion>/designs 2. Check if config.json has already been provided for this design. If a configuration dictionary is inputted into the function parameters, then it overwrites the default config.json. 3. Create a script directory, a script is written and permissions are provided for it to be executable. 4. Permit and execute the openlane_flow.sh script in the scripts directory.
- Parameters:
design_name (str) – Name of the design.
configuration (dict | None) – Configuration dictionary.
root_directory (str | pathlib.Path) – Design directory.
- Returns:
None
- configure_parametric_designs_openlane_v1(design_name: str, parameter_sweep_dictionary: dict, add_id: bool = True) list [source]#
For a given source_design_directory, this function reads in the config.json file and returns a set of parametric sweeps that gets used when creating a set of parametric designs.
- Parameters:
add_id (bool) – Add an ID to the design name. Defaults to True.
parameter_sweep_dictionary (dict) – Dictionary of parameters to sweep.
source_design_directory (str | pathlib.Path) – Source design directory.
- Returns:
List of configurations to sweep.
- Return type:
configuration_sweep(list)
- configure_flow_script_openlane_v1(design_name: str, root_directory: str | pathlib.Path | None = None) None [source]#
Configures the OpenLane v1 flow script after checking that the design directory exists.
- Parameters:
design_directory (str | pathlib.Path | None) – Design directory. Defaults to latest OpenLane root.
- Returns:
None
- create_parametric_designs_openlane_v1(design_name: str, parameter_sweep_dictionary: dict, target_directory: str | pathlib.Path | None = None) None [source]#
Takes a OpenLane v1 source directory and creates a parametric combination of these designs.
- Parameters:
design_name (str) – Name of the design.
parameter_sweep_dictionary (dict) – Dictionary of parameters to sweep.
target_directory (str | pathlib.Path | None) – Optional target directory.
- Returns:
None
- get_design_directory_from_root_openlane_v1(design_name: str, root_directory: str | pathlib.Path | None = None) pathlib.Path [source]#
Gets the design directory from the root directory.
- Parameters:
design_name (str) – Name of the design.
root_directory (str | pathlib.Path) – Design directory.
- Returns:
Design directory.
- Return type:
design_directory(pathlib.Path)
- get_latest_version_root_openlane_v1() pathlib.Path [source]#
Gets the latest version root of OpenLane v1.
- read_configuration_openlane_v1(design_name: str, root_directory: str | pathlib.Path | None = None) dict [source]#
Reads a config.json from a design directory.
- Parameters:
design_name (str) – Design name.
root_directory (str | pathlib.Path) – Design directory.
- Returns:
Configuration dictionary.
- Return type:
configuration(dict)
- write_configuration_openlane_v1(configuration: dict, design_directory: piel.types.piel_path_types) None [source]#
Writes a config.json onto a design_directory
- Parameters:
configuration (dict) – OpenLane configuration dictionary.
design_directory (str) – Design directory PATH.
- Returns:
None
- filter_timing_sta_files(file_list)[source]#
Filter the timing sta files from the list of files
- Parameters:
file_list (list) – List containing the file paths
- Returns:
List containing the timing sta files
- Return type:
timing_sta_files (list)
- filter_power_sta_files(file_list)[source]#
Filter the power sta files from the list of files
- Parameters:
file_list (list) – List containing the file paths
- Returns:
List containing the power sta files
- Return type:
power_sta_files (list)
- get_all_timing_sta_files(run_directory)[source]#
This function aims to list and perform analysis on all the relevant files in a particular run between all the corners.
- Parameters:
run_directory (str, optional) – The run directory to perform the analysis on. Defaults to None.
- Returns:
List of all the .rpt files in the run directory.
- Return type:
timing_sta_files_list (list)
- get_all_power_sta_files(run_directory)[source]#
This function aims to list and perform analysis on all the relevant files in a particular run between all the corners.
- Parameters:
run_directory (str, optional) – The run directory to perform the analysis on. Defaults to None.
- Returns:
List of all the .rpt files in the run directory.
- Return type:
power_sta_files_list (list)
- calculate_max_frame_amount(file_lines_data: pandas.DataFrame)[source]#
Calculate the maximum frame amount based on the frame IDs in the DataFrame
- Parameters:
file_lines_data (pd.DataFrame) – Dataframe containing the file lines
- Returns:
Maximum number of frames in the file
- Return type:
maximum_frame_amount (int)
- calculate_propagation_delay_from_file(file_path: str | pathlib.Path)[source]#
Calculate the propagation delay for each frame in the file
- Parameters:
file_path (str | pathlib.Path) – Path to the file
- Returns:
Dictionary containing the propagation delay
- Return type:
propagation_delay (dict)
- calculate_propagation_delay_from_timing_data(net_name_in: str, net_name_out: str, timing_data: pandas.DataFrame)[source]#
Calculate the propagation delay between two nets
- Parameters:
net_name_in (str) – Name of the input net
net_name_out (str) – Name of the output net
timing_data (pd.DataFrame) – Dataframe containing the timing data
- Returns:
Dataframe containing the propagation delay
- Return type:
propagation_delay_dataframe (pd.DataFrame)
- configure_timing_data_rows(file_lines_data: pandas.DataFrame)[source]#
Identify the timing data lines for each frame and creates a metadata dictionary for frames.
- Parameters:
file_lines_data (pd.DataFrame) – Dataframe containing the file lines
- Returns:
Dictionary containing the frame metadata
- Return type:
frame_meta_data (dict)
- configure_frame_id(file_lines_data: pandas.DataFrame)[source]#
Identify the frame delimiters and assign frame ID to each line in the file
- Parameters:
file_lines_data (pd.DataFrame) – Dataframe containing the file lines
- Returns:
Dataframe containing the file lines
- Return type:
file_lines_data (pd.DataFrame)
- filter_timing_data_by_net_name_and_type(timing_data: pandas.DataFrame, net_name: str, net_type: str)[source]#
Filter the timing data by net name and type
- Parameters:
timing_data (pd.DataFrame) – DataFrame containing the timing data
net_name (str) – Net name to be filtered
net_type (str) – Net type to be filtered
- Returns:
DataFrame containing the timing data
- Return type:
timing_data (pd.DataFrame)
- get_frame_meta_data(file_lines_data)[source]#
Get the frame metadata
- Parameters:
file_lines_data (pd.DataFrame) – DataFrame containing the file lines
- Returns:
DataFrame containing the start point name end_point_name (pd.DataFrame): DataFrame containing the end point name path_group_name (pd.DataFrame): DataFrame containing the path group name path_type_name (pd.DataFrame): DataFrame containing the path type name
- Return type:
start_point_name (pd.DataFrame)
- get_frame_lines_data(file_path: str | pathlib.Path)[source]#
Calculate the timing data for each frame in the file
- Parameters:
file_path (str | pathlib.Path) – Path to the file
- Returns:
DataFrame containing the file lines
- Return type:
file_lines_data (pd.DataFrame)
- get_frame_timing_data(file: str | pathlib.Path, frame_meta_data: dict, frame_id: int = 0)[source]#
Extract the timing data from the file
- Parameters:
file (str | pathlib.Path) – Address of the file
frame_meta_data (dict) – Dictionary containing the frame metadata
frame_id (int) – Frame ID to be read
- Returns:
DataFrame containing the timing data
- Return type:
timing_data (pd.DataFrame)
- get_all_timing_data_from_file(file_path: str | pathlib.Path)[source]#
Calculate the timing data for each frame in the file
- Parameters:
file_path (str | pathlib.Path) – Path to the file
- Returns:
Dictionary containing the timing data for each frame
- Return type:
frame_timing_data (dict)
- read_sta_rpt_fwf_file(file: str | pathlib.Path, frame_meta_data: dict, frame_id: int = 0)[source]#
Read the fixed width file and return a DataFrame
- Parameters:
file (str | pathlib.Path) – Address of the file
frame_meta_data (dict) – Dictionary containing the frame metadata
frame_id (int) – Frame ID to be read
- Returns:
DataFrame containing the file data
- Return type:
file_data (pd.DataFrame)
- contains_in_lines(file_lines_data: pandas.DataFrame, keyword: str)[source]#
Check if the keyword is contained in the file lines
- Parameters:
file_lines_data (pd.DataFrame) – Dataframe containing the file lines
keyword (str) – Keyword to search for
- Returns:
Dataframe containing the file lines
- Return type:
file_lines_data (pd.DataFrame)
- create_file_lines_dataframe(file_lines_raw)[source]#
Create a DataFrame from the raw lines of a file
- Parameters:
file_lines_raw (list) – list containing the file lines
- Returns:
Dataframe containing the file lines
- Return type:
file_lines_data (pd.DataFrame)
- get_file_line_by_keyword(file_lines_data: pandas.DataFrame, keyword: str, regex: str)[source]#
Extract the data from the file lines using the given keyword and regex
- Parameters:
file_lines_data (pd.DataFrame) – Dataframe containing the file lines
keyword (str) – Keyword to search for
regex (str) – Regex to extract the data
- Returns:
Dataframe containing the extracted values
- Return type:
extracted_values (pd.DataFrame)
- read_file_lines(file_path: str | pathlib.Path)[source]#
Extract lines from the file
- Parameters:
file_path (str | pathlib.Path) – Path to the file
- Returns:
list containing the file lines
- Return type:
file_lines_raw (list)
- get_all_designs_metrics_openlane_v2(output_directory: piel.types.piel_path_types, target_prefix: str)[source]#
Returns a dictionary of all the metrics for all the designs in the output directory.
Usage:
- Parameters:
output_directory (piel_path_types) – The path to the output directory.
target_prefix (str) – The prefix of the designs to get the metrics for.
- Returns:
A dictionary of all the metrics for all the designs in the output directory.
- Return type:
dict
- read_metrics_openlane_v2(design_directory: piel.types.piel_path_types) dict [source]#
Read design metrics from OpenLane v2 run files.
- Parameters:
design_directory (piel_path_types) – Design directory PATH.
- Returns:
Metrics dictionary.
- Return type:
dict
- run_openlane_flow(configuration: dict | None = None, design_directory: piel.types.piel_path_types = '.', parallel_asynchronous_run: bool = False, only_generate_flow_setup: bool = False)[source]#
Runs the OpenLane v2 flow.
- Parameters:
configuration (dict) – OpenLane configuration dictionary. If none is present it will default to the config.json file on the design_directory.
design_directory (piel_path_types) – Design directory PATH.
parallel_asynchronous_run (bool) – Run the flow in parallel.
only_generate_flow_setup (bool) – Only generate the flow setup.
Returns:
- configure_ngspice_simulation(run_directory: piel.types.piel_path_types = '.')[source]#
This function configures the NGSPICE simulation for the circuit and returns a simulation class.
- Parameters:
run_directory (piel_path_types) – Directory where the simulation will be run
- Returns:
Configured NGSPICE simulation options
- Return type:
simulation_options
- configure_operating_point_simulation(testbench: hdl21.Module, **kwargs)[source]#
This function configures the DC operating point simulation for the circuit and returns a simulation class.
- Parameters:
testbench (Module) – HDL21 testbench
**kwargs – Additional arguments to be passed to the operating point simulation such as name.
- Returns:
HDL21 simulation class
- Return type:
Simulation
- configure_transient_simulation(testbench: hdl21.Module, stop_time_s: float, step_time_s: float, **kwargs)[source]#
This function configures the transient simulation for the circuit and returns a simulation class.
- Parameters:
testbench (Module) – HDL21 testbench
stop_time_s (float) – Stop time of the simulation in seconds
step_time_s (float) – Step time of the simulation in seconds
**kwargs – Additional arguments to be passed to the transient simulation
- Returns:
HDL21 simulation class
- Return type:
Simulation
- run_simulation(simulation: hdl21.sim.Sim, simulator_name: Literal[ngspice] = 'ngspice', simulation_options: vlsirtools.spice.SimOptions | None = None, to_csv: bool = True)[source]#
This function runs the transient simulation for the circuit and returns the results.
- Parameters:
simulation (h.sim.Sim) – HDL21 simulation class
simulator_name (Literal["ngspice"]) – Name of the simulator
simulation_options (Optional[vsp.SimOptions]) – Simulation options
to_csv (bool) – Whether to save the results to a csv file
- Returns:
Simulation results
- Return type:
results
- convert_numeric_to_prefix(value: float)[source]#
This function converts a numeric value to a number under a SPICE unit closest to the base prefix. This allows us to connect a particular number real output, into a term that can be used in a SPICE netlist.
- address_value_dictionary_to_function_parameter_dictionary(address_value_dictionary: dict, parameter_key: str)[source]#
This function converts an address of an instance with particular parameter values in the form:
{(‘component_lattice_gener_fb8c4da8’, ‘mzi_1’, ‘sxt’): 0, (‘component_lattice_gener_fb8c4da8’, ‘mzi_5’, ‘sxt’): 0}
to
{‘mzi_1’: {‘sxt’: {parameter_key: 0}}, (‘mzi_5’, {‘sxt’: {parameter_key: 0}}}
- compose_recursive_instance_location(recursive_netlist: dict, top_level_instance_name: str, required_models: list, target_component_prefix: str, models: dict)[source]#
This function returns the recursive location of any matching
target_component_prefix
instances within therecursive_netlist
. A function that returns the mapping of thematched_component
in the corresponding netlist at any particular level of recursion. This function iterates over a particular level of recursion of a netlist. It returns a list of the missing required components, and updates a dictionary of models that contains a particular matching component. It returns the corresponding list of instances of a particular component at that level of recursion, so that it can be appended upon in order to construct the location of the corresponding matching elements.If
required_models
is an empty list, it means no recursion is required and the function is complete. If arequired_model_i
inrequired_models
matchestarget_component_prefix
, then no more recursion is required down the component function.The
recursive_netlist
should contain all the missing composed models that are not provided in the main models dictionary. If not, then we need to require the user to input the missing model that cannot be extracted from the composed netlist.We know when a model is composed, and when it is already provided at every level of recursion based on the
models
dictionary that gets updated at each level of recursion with the corresponding models of that level, and therequired_models
down itself.However, a main question appears on how to do the recursion. There needs to be a flag that determines that the recursion is complete. However, this is only valid for every particular component in the
required_models
list. Every component might have missing component. This means that this recursion begins component by component, updating therequired_models
list until all of them have been composed from the recursion or it is determined that is it missing fully.It would be ideal to access the particular component that needs to be implemented.
Returns a tuple of
model_composition_mapping, instance_composition_mapping, target_component_mapping
in the form of- ({‘mzi_214beef3’: [‘straight_heater_metal_s_ad3c1693’]},
- {‘mzi_214beef3’: [‘mzi_1’, ‘mzi_5’],
‘mzi_d46c281f’: [‘mzi_2’, ‘mzi_3’, ‘mzi_4’]})
- get_component_instances(recursive_netlist: dict, top_level_prefix: str, component_name_prefix: str)[source]#
Returns a dictionary of all instances of a given component in a recursive netlist.
- Parameters:
recursive_netlist – The recursive netlist to search.
top_level_prefix – The prefix of the top level instance.
component_name_prefix – The name of the component to search for.
- Returns:
A dictionary of all instances of the given component.
- get_netlist_instances_by_prefix(recursive_netlist: dict, instance_prefix: str) str [source]#
Returns a list of all instances with a given prefix in a recursive netlist.
- Parameters:
recursive_netlist – The recursive netlist to search.
instance_prefix – The prefix to search for.
- Returns:
A list of all instances with the given prefix.
- get_matched_model_recursive_netlist_instances(recursive_netlist: dict, top_level_instance_prefix: str, target_component_prefix: str, models: dict | None = None) list[tuple] [source]#
This function returns an active component list with a tuple mapping of the location of the active component within the recursive netlist and corresponding model. It will recursively look within a netlist to locate what models use a particular component model. At each stage of recursion, it will compose a list of the elements that implement this matching model in order to relate the model to the instance, and hence the netlist address of the component that needs to be updated in order to functionally implement the model.
It takes in as a set of parameters the recursive_netlist generated by a
gdsfactory
netlist implementation.Returns a list of tuples, that correspond to the phases applied with the corresponding component paths at multiple levels of recursion. eg. [(“component_lattice_gener_fb8c4da8”, “mzi_1”, “sxt”), (“component_lattice_gener_fb8c4da8”, “mzi_5”, “sxt”)] and these are our keys to our sax circuit decomposition.
- get_sdense_ports_index(input_ports_order: tuple, all_ports_index: dict) dict [source]#
This function returns the ports index of the sax dense S-parameter matrix.
Given that the order of the iteration is provided by the user, the dictionary keys will also be ordered accordingly when iterating over them. This requires the user to provide a set of ordered.
TODO verify reasonable iteration order.
# The input_ports_order can be a tuple of tuples that contain the index and port name. Eg. input_ports_order = ((0, "in_o_0"), (5, "in_o_1"), (6, "in_o_2"), (7, "in_o_3")) # The all_ports_index is a dictionary of the ports index. Eg. all_ports_index = { "in_o_0": 0, "out_o_0": 1, "out_o_1": 2, "out_o_2": 3, "out_o_3": 4, "in_o_1": 5, "in_o_2": 6, "in_o_3": 7, } # Output {"in_o_0": 0, "in_o_1": 5, "in_o_2": 6, "in_o_3": 7}
- Parameters:
input_ports_order (tuple) – The ports order tuple. Can be a tuple of tuples that contain the index and port name.
all_ports_index (dict) – The ports index dictionary.
- Returns:
The ordered input ports index tuple.
- Return type:
tuple
- sax_to_s_parameters_standard_matrix(sax_input: sax.SType, input_ports_order: tuple | None = None) tuple [source]#
A
sax
S-parameter SDict is provided as a dictionary of tuples with (port0, port1) as the key. This determines the direction of the scattering relationship. It means that the number of terms in an S-parameter matrix is the number of ports squared.In order to generalise, this function returns both the S-parameter matrices and the indexing ports based on the amount provided. In terms of computational speed, we definitely would like this function to be algorithmically very fast. For now, I will write a simple python implementation and optimise in the future.
It is possible to see the sax SDense notation equivalence here: https://flaport.github.io/sax/nbs/08_backends.html
import jax.numpy as jnp from sax.core import SDense # Directional coupler SDense representation dc_sdense: SDense = ( jnp.array([[0, 0, τ, κ], [0, 0, κ, τ], [τ, κ, 0, 0], [κ, τ, 0, 0]]), {"in0": 0, "in1": 1, "out0": 2, "out1": 3}, ) # Directional coupler SDict representation # Taken from https://flaport.github.io/sax/nbs/05_models.html def coupler(*, coupling: float = 0.5) -> SDict: kappa = coupling**0.5 tau = (1 - coupling) ** 0.5 sdict = reciprocal( { ("in0", "out0"): tau, ("in0", "out1"): 1j * kappa, ("in1", "out0"): 1j * kappa, ("in1", "out1"): tau, } ) return sdict
If we were to relate the mapping accordingly based on the ports indexes, a S-Parameter matrix in the form of \(S_{(output,i),(input,i)}\) would be:
\[\begin{split}S = \begin{bmatrix} S_{00} & S_{10} \\ S_{01} & S_{11} \\ \end{bmatrix} = \begin{bmatrix} \tau & j \kappa \\ j \kappa & \tau \\ \end{bmatrix}\end{split}\]Note that the standard S-parameter and hence unitary representation is in the form of:
\[\begin{split}S = \begin{bmatrix} S_{00} & S_{01} \\ S_{10} & S_{11} \\ \end{bmatrix}\end{split}\]\[\begin{split}\begin{bmatrix} b_{1} \\ \vdots \\ b_{n} \end{bmatrix} = \begin{bmatrix} S_{11} & \dots & S_{1n} \\ \vdots & \ddots & \vdots \\ S_{n1} & \dots & S_{nn} \end{bmatrix} \begin{bmatrix} a_{1} \\ \vdots \\ a_{n} \end{bmatrix}\end{split}\]TODO check with Floris, does this mean we need to transpose the matrix?
- Parameters:
sax_input (sax.SType) – The sax S-parameter dictionary.
input_ports_order (tuple) – The ports order tuple containing the names and order of the input ports.
- Returns:
The S-parameter matrix and the input ports index tuple in the standard S-parameter notation.
- Return type:
tuple
- snet#
- all_fock_states_from_photon_number(mode_amount: int, photon_amount: int = 1, output_type: Literal[qutip, jax] = 'qutip') list [source]#
For a specific amount of modes, we can generate all the possible Fock states for whatever amount of input photons we desire. This returns a list of all corresponding Fock states.
- Parameters:
mode_amount (int) – The amount of modes in the system.
photon_amount (int, optional) – The amount of photons in the system. Defaults to 1.
output_type (str, optional) – The type of output. Defaults to “qutip”.
- Returns:
A list of all the Fock states.
- Return type:
list
- convert_output_type#
- fock_state_nonzero_indexes(fock_state: qutip.Qobj | jax.numpy.ndarray) tuple[int] [source]#
This function returns the indexes of the nonzero elements of a Fock state.
- Parameters:
fock_state (qutip.Qobj) – A QuTip QObj representation of the Fock state.
- Returns:
The indexes of the nonzero elements of the Fock state.
- Return type:
tuple
- fock_state_to_photon_number_factorial(fock_state: qutip.Qobj | jax.numpy.ndarray) float [source]#
This function converts a Fock state defined as:
\[\]ewcommand{ket}[1]{left|{#1} ight angle}
ket{f_1} = ket{j_1, j_2, … j_N}$
and returns:
\[j_1^{'}! j_2^{'}! ... j_N^{'}!\]- Args:
fock_state (qutip.Qobj): A QuTip QObj representation of the Fock state.
- Returns:
float: The photon number factorial of the Fock state.
- fock_states_at_mode_index(mode_amount: int, target_mode_index: int, maximum_photon_amount: int | None = 1, output_type: Literal[qutip, jax] = 'qutip') list [source]#
This function returns a list of valid Fock states that fulfill a condition of having a maximum photon number at a specific mode index.
- Parameters:
mode_amount (int) – The amount of modes in the system.
target_mode_index (int) – The mode index to check the photon number at.
maximum_photon_amount (int, optional) – The amount of photons in the system. Defaults to 1.
output_type (str, optional) – The type of output. Defaults to “qutip”.
- Returns:
A list of all the Fock states.
- Return type:
list
- fock_states_only_individual_modes(mode_amount: int, maximum_photon_amount: int | None = 1, output_type: Literal[qutip, jax, numpy, list, tuple] = 'qutip') list [source]#
This function returns a list of valid Fock states where each state has a maximum photon number, but only in one mode.
- Parameters:
mode_amount (int) – The amount of modes in the system.
maximum_photon_amount (int) – The maximum amount of photons in a single mode.
output_type (str, optional) – The type of output. Defaults to “qutip”.
- Returns:
A list of all the valid Fock states.
- Return type:
list
- standard_s_parameters_to_qutip_qobj#
- verify_matrix_is_unitary(matrix: jax.numpy.ndarray) bool [source]#
Verify that the matrix is unitary.
- Parameters:
matrix (jnp.ndarray) – The matrix to verify.
- Returns:
True if the matrix is unitary, False otherwise.
- Return type:
bool
- subunitary_selection_on_range(unitary_matrix: jax.numpy.ndarray, stop_index: tuple, start_index: tuple | None = (0, 0))[source]#
This function returns a unitary between the indexes selected, and verifies the indexes are valid by checking that the output matrix is also a unitary.
TODO implement validation of a 2D matrix.
- subunitary_selection_on_index(unitary_matrix: jax.numpy.ndarray, rows_index: jax.numpy.ndarray | tuple, columns_index: jax.numpy.ndarray | tuple)[source]#
This function returns a unitary between the indexes selected, and verifies the indexes are valid by checking that the output matrix is also a unitary.
TODO implement validation of a 2D matrix.