pyadi-jif 0.1.0__py2.py3-none-any.whl → 0.1.1__py2.py3-none-any.whl

adijif/tools/explorer/src/pages/helpers/datapath.py

@@ -0,0 +1,85 @@
+"""Helper functions for datapath configuration UI elements."""
+
+import streamlit as st
+
+from adijif.converters import converter as conv
+
+
+def gen_datapath(converter: conv) -> int:
+    """Generate datapath configuration UI elements for Streamlit.
+
+    Args:
+        converter: The converter object to generate the datapath for.
+
+    Returns:
+        The selected decimation or interpolation value.
+
+    Raises:
+        Exception: If no interpolation setting is found for DACs.
+    """
+    if converter.converter_type.lower() == "adc":
+        decimation = 1
+        if converter.datapath:
+            if hasattr(converter.datapath, "cddc_decimations_available"):
+                options = converter.datapath.cddc_decimations_available
+                cddc_decimation = st.selectbox(
+                    "CDDC Decimation",
+                    options=options,
+                    format_func=lambda x: str(x),
+                )
+                decimation = cddc_decimation
+                v = len(converter.datapath.cddc_decimations)
+                converter.datapath.cddc_decimations = [cddc_decimation] * v
+            if hasattr(converter.datapath, "fddc_decimations_available"):
+                options = converter.datapath.fddc_decimations_available
+                fddc_decimation = st.selectbox(
+                    "FDDC Decimation",
+                    options=options,
+                    format_func=lambda x: str(x),
+                )
+                decimation *= fddc_decimation
+                v = len(converter.datapath.fddc_decimations)
+                converter.datapath.fddc_decimations = [fddc_decimation] * v
+        elif hasattr(converter, "decimation_available"):
+            decimation = st.selectbox(
+                "Decimation",
+                options=converter.decimation_available,
+                format_func=lambda x: str(x),
+            )
+            decimation = int(decimation)
+            converter.decimation = decimation
+    else:
+        interpolation = 1
+        if converter.datapath:
+            if hasattr(converter.datapath, "cduc_interpolations_available"):
+                options = converter.datapath.cduc_interpolations_available
+                cduc_interpolation = st.selectbox(
+                    "CDUC Interpolation",
+                    options=options,
+                    format_func=lambda x: str(x),
+                )
+                interpolation = cduc_interpolation
+                converter.datapath.cduc_interpolation = cduc_interpolation
+            if hasattr(converter.datapath, "fduc_interpolations_available"):
+                options = converter.datapath.fduc_interpolations_available
+                fduc_interpolation = st.selectbox(
+                    "FDUC Interpolation",
+                    options=options,
+                    format_func=lambda x: str(x),
+                )
+                interpolation *= fduc_interpolation
+                converter.datapath.fduc_interpolation = fduc_interpolation
+        elif hasattr(converter, "interpolation_available"):
+            interpolation = st.selectbox(
+                "Interpolation",
+                options=converter.interpolation_available,
+                format_func=lambda x: str(x),
+            )
+            interpolation = int(interpolation)
+            converter.interpolation = interpolation
+        else:
+            raise Exception("No interpolation setting found")
+
+        decimation = interpolation
+
+    return decimation

adijif/tools/explorer/src/pages/helpers/drawers.py

@@ -0,0 +1,87 @@
+"""Helper functions for drawing ADC diagrams."""
+
+import logging
+from typing import Optional
+
+import adijif as jif
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+
+def draw_adc(adc: Optional[object] = None) -> str:
+    """Draw ADC clock tree diagram.
+
+    Args:
+        adc: ADC converter object. If None, uses ad9680 as default.
+
+    Returns:
+        Path to generated SVG file.
+    """
+    if adc is None:
+        adc = jif.ad9680()
+
+    # Check static
+    adc.validate_config()
+
+    required_clocks = adc.get_required_clocks()
+    required_clock_names = adc.get_required_clock_names()
+
+    # Add generic clock sources for solver
+    clks = []
+    for clock, name in zip(required_clocks, required_clock_names):  # noqa: B905
+        clk = jif.types.arb_source(name)
+        adc._add_equation(clk(adc.model) == clock)
+        clks.append(clk)
+
+    # Solve
+    solution = adc.model.solve(LogVerbosity="Quiet")
+    settings = adc.get_config(solution)
+
+    # Get clock values
+    clock_values = {}
+    for clk in clks:
+        clock_values.update(clk.get_config(solution))
+    settings["clocks"] = clock_values
+
+    adc.show_rates = False
+    return adc.draw(settings["clocks"])
+
+
+def draw_dac(dac: Optional[object] = None) -> str:
+    """Draw DAC clock tree diagram.
+
+    Args:
+        dac: DAC converter object. If None, uses ad9144 as default.
+
+    Returns:
+        Path to generated SVG file.
+    """
+    if dac is None:
+        dac = jif.ad9144()
+
+    # Check static
+    dac.validate_config()
+
+    required_clocks = dac.get_required_clocks()
+    required_clock_names = dac.get_required_clock_names()
+
+    # Add generic clock sources for solver
+    clks = []
+    for clock, name in zip(required_clocks, required_clock_names):  # noqa: B905
+        clk = jif.types.arb_source(name)
+        dac._add_equation(clk(dac.model) == clock)
+        clks.append(clk)
+
+    # Solve
+    solution = dac.model.solve(LogVerbosity="Quiet")
+    settings = dac.get_config(solution)
+
+    # Get clock values
+    clock_values = {}
+    for clk in clks:
+        clock_values.update(clk.get_config(solution))
+    settings["clocks"] = clock_values
+
+    dac.show_rates = False
+    return dac.draw(settings["clocks"])

adijif/tools/explorer/src/pages/helpers/jesd.py

@@ -0,0 +1,140 @@
+"""Helper functions for JESD mode handling."""
+
+import copy
+import logging
+from typing import Any, Dict, List, Optional, Tuple
+
+from adijif.utils import get_jesd_mode_from_params
+
+log = logging.getLogger(__name__)
+
+
+def get_jesd_controls(converter: object) -> Tuple[Dict[str, List[Any]], Dict[str, Any]]:
+    """Get JESD control options from converter.
+
+    Args:
+        converter: JESD converter object
+
+    Returns:
+        Tuple of (options dict, all_modes dict)
+
+    Raises:
+        Exception: When mode settings are not consistent across all subclasses
+    """
+    options_to_skip = ["global_index", "decimations", "interpolations"]
+
+    # Derive configurable jesd settings for specific converter based on mode table
+    all_modes = converter.quick_configuration_modes
+    all_modes = copy.deepcopy(all_modes)
+    subclasses = list(all_modes.keys())
+
+    mode_knobs = None
+
+    for subclass in subclasses:
+        # Pick first mode of subclass and extract settings
+        ks = all_modes[subclass].keys()
+        ks = list(ks)
+        if len(ks) == 0:
+            # print(f"No modes found for subclass {subclass}")
+            continue
+        first_mode = list(all_modes[subclass].keys())[0]
+        mode_settings = all_modes[subclass][first_mode].keys()
+        mode_settings = sorted(mode_settings)
+        if not mode_knobs:
+            mode_knobs = mode_settings
+            continue
+
+        # Compare settings in other subclasses to make sure they are the same
+        if mode_settings != mode_knobs:
+            differences = set(mode_settings) ^ set(mode_knobs)
+            log.warning(
+                f"Mode settings are not consistent across all subclasses: {differences}"
+            )
+            raise Exception("Mode settings are not consistent across all subclasses")
+
+    # Parse all options for each control across modes
+    options = {}
+    for setting in mode_knobs:
+        if setting in options_to_skip:
+            continue
+        options[setting] = []
+        for subclass in subclasses:
+            for mode in all_modes[subclass]:
+                data = all_modes[subclass][mode][setting]
+                if isinstance(data, list):
+                    print(f"Skipping list data for {setting}")
+                    continue
+                options[setting].append(data)
+
+    # Make sure options only contain unique values
+    for option in options:
+        options[option] = list(set(options[option]))
+
+    return options, all_modes
+
+
+def get_valid_jesd_modes(
+    converter: object, all_modes: Dict[str, Any], selections: Dict[str, Any]
+) -> Tuple[List[Dict[str, Any]], Optional[List[Dict[str, Any]]]]:
+    """Get valid JESD modes based on selections.
+
+    Args:
+        converter: JESD converter object
+        all_modes: Dictionary of all available modes
+        selections: User selections for filtering
+
+    Returns:
+        Tuple of (modes info list, found modes list or None)
+    """
+    modes_all_info: Any = {}
+
+    try:
+        found_modes = get_jesd_mode_from_params(converter, **selections)
+
+    except Exception:
+        log.info("No modes found")
+        found_modes = None
+        return modes_all_info, found_modes
+
+    options_to_skip = ["global_index", "decimations"]
+
+    # Get remaining mode parameters
+    modes_all_info = []
+    for mode in found_modes:
+        jesd_cfg = all_modes[mode["jesd_class"]][mode["mode"]]
+        jesd_cfg["mode"] = mode["mode"]
+        jesd_cfg["jesd_class"] = mode["jesd_class"]
+
+        # Remove options to skip
+        for option in options_to_skip:
+            jesd_cfg.pop(option, None)
+
+        modes_all_info.append(jesd_cfg)
+
+    # For each mode calculate the clocks and if valid
+    for mode in modes_all_info:
+        rate = converter.sample_clock
+        # print("A", converter.sample_clock)
+        converter.set_quick_configuration_mode(mode["mode"], mode["jesd_class"])
+        # print("B", converter.sample_clock)
+        log.warning("Logical BUG")
+        converter.sample_clock = rate
+
+        clocks = {
+            "Sample Rate (MSPS)": converter.sample_clock / 1e6,
+            "Lane Rate (GSPS)": converter.bit_clock / 1e9,
+        }
+
+        for clock in clocks:
+            mode[clock] = clocks[clock]
+
+        try:
+            converter.validate_config()
+            mode["Valid"] = "Yes"
+        except Exception:
+            mode["Valid"] = "No"
+
+    # from pprint import pprint
+    # pprint(modes_all_info)
+
+    return modes_all_info, found_modes

adijif/tools/explorer/src/pages/jesdmodeselector.py

@@ -0,0 +1,209 @@
+"""JESD204 mode selector page."""
+
+from typing import Optional
+
+import pandas as pd
+import streamlit as st
+
+from adijif.converters import supported_parts as sp
+
+from ..utils import Page
+from .helpers.datapath import gen_datapath
+from .helpers.drawers import draw_adc, draw_dac
+from .helpers.jesd import get_jesd_controls, get_valid_jesd_modes
+
+# options_to_skip = ["global_index", "decimations"]
+
+
+class JESDModeSelector(Page):
+    """JESD204 mode selector tool page."""
+
+    def __init__(self, state: Optional[object]) -> None:
+        """Initialize JESD mode selector page.
+
+        Args:
+            state: Application state object
+        """
+        self.state = state
+        self.part_images = {}
+
+    def write(self) -> None:
+        """Render the JESD mode selector page."""
+        # Get supported parts that have quick_configuration_modes
+        import adijif  # noqa: F401
+
+        supported_parts_filtered = []
+        for part in sp:
+            try:
+                converter = eval(f"adijif.{part}()")  # noqa: S307
+                qsm = converter.quick_configuration_modes  # noqa: F841
+                supported_parts_filtered.append(part)
+            except Exception:  # noqa: S110
+                pass
+        supported_parts = supported_parts_filtered
+
+        st.title("JESD204 Mode Selector")
+
+        @st.dialog("About JESD204 Mode Selector")
+        def help() -> None:
+            """Display help dialog."""
+            st.write(  # noqa: S608
+                "This tool helps you select the appropriate JESD204 mode for "
+                "your application. It supports both ADCs, DACs, MxFEs, and "
+                "Transceivers from the ADI portfolio. Modeling their JESD204 "
+                "mode tables and clocking limitations of the individual "
+                "devices.\n\n"
+                "To use the tool, select a part from the dropdown menu. You "
+                "can then configure the datapath settings such as "
+                "decimation/interpolation and the converter sample rate. The "
+                "tool will derive the necessary clocks for the selected "
+                "configuration. Filter different JESD204 parameters to find a "
+                "suitable mode for your application. The valid modes will be "
+                "displayed in a table, along with the derived settings."
+                "\n\n"
+                "JESD204 settings can be exported as CSV from the table."
+            )
+
+        st.button("Help", on_click=help)
+
+        sb = st.selectbox(
+            label="Select a part",
+            options=supported_parts,
+            format_func=lambda x: x.upper(),
+            key="converter_part_select",
+        )
+
+        converter = eval(f"adijif.{sb}()")  # noqa: S307
+
+        # Show diagram
+        with st.expander(label="Diagram", expanded=True):
+            if sb not in self.part_images:
+                if converter.converter_type.lower() == "adc":
+                    self.part_images[sb] = draw_adc(converter)
+                    # FIXME: State is not being saved
+                else:
+                    self.part_images[sb] = draw_dac(converter)
+            st.image(self.part_images[sb], width="stretch")
+
+        # Datapath Configuration
+        with st.expander("Datapath Configuration", expanded=True):
+            decimation = gen_datapath(converter)
+
+            scalar = st.selectbox("Units", options=["Hz", "kHz", "MHz", "GHz"], index=3)
+            if scalar == "Hz":
+                scalar_value = 1
+                new_default = 1e9
+                min_value = 1
+                max_value = 28e9
+            elif scalar == "kHz":
+                scalar_value = 1e3
+                new_default = 1e6
+                min_value = 100
+                max_value = 28e6
+            elif scalar == "MHz":
+                scalar_value = 1e6
+                new_default = 1e3
+                min_value = 1e3
+                max_value = 28e3
+            elif scalar == "GHz":
+                scalar_value = 1e9
+                new_default = 1
+                min_value = 0.1
+                max_value = 28
+
+            min_value = float(min_value)
+            max_value = float(max_value)
+            new_default = float(new_default)
+
+            converter_rate = st.number_input(
+                f"Converter Rate ({scalar})",
+                value=new_default,
+                min_value=min_value,
+                max_value=max_value,
+            )
+            converter_rate = scalar_value * converter_rate
+            converter.sample_clock = converter_rate / decimation
+
+        # Derived settings
+        dict_data = {
+            "Derived Setting": ["Sample Rate (MSPS)"],
+            "Value": [converter.sample_clock / 1e6],
+        }
+        df = pd.DataFrame.from_dict(dict_data)
+        st.dataframe(df, hide_index=True, width="stretch")
+
+        cols = st.columns(2, border=True)
+
+        # JESD204 Configuration Inputs
+        options, all_modes = get_jesd_controls(converter)
+        selections = {}
+
+        with cols[0]:
+            st.subheader("Configuration")
+
+            for option in options:
+                selections[option] = st.multiselect(
+                    option, options[option]
+                )  # noqa: S608
+
+        # Output table of valid modes and calculate clocks
+        selections = {k: v for k, v in selections.items() if v != []}
+        modes_all_info, found_modes = get_valid_jesd_modes(
+            converter, all_modes, selections
+        )
+
+        with cols[1]:
+            st.subheader("JESD204 Modes")
+
+            if found_modes:
+                # Create formatted table of modes
+
+                # Convert to DataFrame so we can change orientation
+                df = pd.DataFrame(modes_all_info)
+
+                show_valid = st.toggle("Show only valid modes", value=True)
+                if show_valid:
+                    df = df[df["Valid"] == "Yes"]
+                    df = df.drop(columns=["Valid"])
+
+                # Create new index column and move mode to separate column
+                df["Mode"] = df.index
+                df = df.reset_index(drop=True)
+                # Make mode first column
+                cols = df.columns.tolist()
+                cols = cols[-1:] + cols[:-1]
+                df = df[cols]
+
+                # Change jesd_class column name to be JESD204 Class
+                df = df.rename(columns={"jesd_class": "JESD204 Class"})
+                df = df.rename(columns={"Mode": "Quickset Mode"})
+
+                # Change data in jesd_class column to be more human readable
+                df["JESD204 Class"] = df["JESD204 Class"].replace(
+                    {"jesd204b": "204B", "jesd204c": "204C"}
+                )
+
+                # Remove any blank rows (rows where all values are NaN or empty)
+                df = df.dropna(how="all")
+                df = df[df.astype(str).ne("").any(axis=1)]
+
+                to_disable = df.columns
+                # Use fixed height with scrolling for consistent display
+                # Calculate dynamic height but cap it for better UX
+                min_height = 150
+                max_height = 600
+                row_height = 35
+                calculated_height = min(
+                    max(len(df) * row_height + 38, min_height), max_height
+                )
+
+                st.data_editor(  # noqa: F841
+                    df,
+                    width="stretch",
+                    disabled=to_disable,
+                    hide_index=True,
+                    height=calculated_height,
+                )
+
+            else:
+                st.write("No modes found")