siliconcompiler 0.26.5__py3-none-any.whl

siliconcompiler/units.py

@@ -0,0 +1,259 @@
+import math
+import re
+
+SI_UNITS = (
+    ('y', -24),
+    ('z', -21),
+    ('a', -18),
+    ('f', -15),
+    ('p', -12),
+    ('n', -9),
+    ('u', -6),
+    ('m', -3),
+    ('', 0),
+    ('k', 3),
+    ('M', 6),
+    ('G', 9),
+    ('T', 12),
+    ('P', 15),
+    ('E', 18),
+    ('Z', 21),
+    ('Y', 24)
+)
+
+BINARY_UNITS = (
+    ('', 0),
+    ('k', 10),
+    ('M', 20),
+    ('G', 30),
+    ('T', 40),
+    ('P', 50),
+    ('E', 60),
+    ('Z', 70)
+)
+
+SI_TYPES = (
+    's',
+    'Hz',
+    'F',
+    'm',
+    'A',
+    'V',
+    'W',
+    'ohm',
+    'C',
+)
+
+
+BINARY_TYPES = (
+    'B',
+    'b'
+)
+
+
+def convert(value, from_unit=None, to_unit=None):
+    '''
+    Convert a value to from one SI power to another SI power
+
+    Args:
+        value (float): value to convert
+        from_unit (str): unit of the value, default is None and assumes no magnitude
+        to_unit (str): unit of the return, default is None and assumes no magnitude
+
+    Returns:
+        float: scaled value
+    '''
+    value = float(value)
+
+    power = get_si_power(to_unit)
+
+    from_scale = _get_scale(from_unit) ** power
+    to_scale = _get_scale(to_unit) ** power
+    scale = from_scale / to_scale
+    if scale > 1:
+        scale = round(scale)
+    elif scale < 1:
+        scale = 1.0 / round(1.0 / scale)
+    else:
+        scale = round(scale)
+
+    return value * scale
+
+
+def _get_scale(unit):
+    if not unit:
+        unit = ''
+    unit_prefix = get_si_prefix(unit)
+    for prefix, scale in SI_UNITS:
+        if prefix == unit_prefix:
+            return 10**scale
+
+    return 1
+
+
+def get_si_prefix(unit):
+    '''
+    Get the SI prefix of the specific unit.
+
+    For example:
+    get_si_prefix('um') -> 'u'
+    '''
+    if not unit:
+        return ''
+
+    for si_type in list(SI_TYPES) + ['']:
+        re_find = fr'^(.*){si_type}(\^[0-9]+)?$'
+        matches = re.findall(re_find, unit, re.IGNORECASE)
+        if matches:
+            return matches[0][0]
+
+    return ''
+
+
+def get_si_power(unit):
+    '''
+    Get the SI power of the specific unit.
+    This is mainly needed for area units.
+
+    For example:
+    get_si_prefix('um') -> 1
+    get_si_prefix('um^2') -> 2
+    '''
+    if not unit:
+        return 1
+
+    for si_type in list(SI_TYPES) + ['']:
+        re_find = fr'^.*{si_type}\^([0-9]+)$'
+        matches = re.findall(re_find, unit, re.IGNORECASE)
+        if matches:
+            return int(matches[0][-1])
+
+    return 1
+
+
+def is_base_si_unit(unit):
+    '''
+    Check if a unit has no magnitude
+    '''
+    return unit in SI_TYPES
+
+
+def is_base_si_unit_power(unit):
+    '''
+    Check if a unit has a power associated with it
+    '''
+    return get_si_power(unit) > 1
+
+
+def is_base_binary_unit(unit):
+    '''
+    Check if a unit is binary
+    '''
+    return unit in BINARY_TYPES
+
+
+def format_si(value, unit, margin=3, digits=3):
+    '''
+    Format a number as an SI number. Returns a string.
+
+    Args:
+        value (float): value to convert
+        unit (str): unit of the value
+        margin (int): number of extra digits to ensure are preserved
+            when picking the right magnitude
+        digits (int): number of digits to print after .
+    '''
+    scaled_value, prefix = scale_si(value, unit, margin=margin, digits=digits)
+    # need to do this in case float shortens scaled_value
+    return f'{scaled_value:.{digits}f}{prefix}'
+
+
+def scale_si(value, unit, margin=3, digits=3):
+    '''
+    Format a number as an SI number. Returns a float.
+
+    Args:
+        value (float): value to convert
+        unit (str): unit of the value
+        margin (int): number of extra digits to ensure are preserved
+            when picking the right magnitude
+        digits (int): number of digits to print after .
+    '''
+    if unit and is_base_si_unit(unit):
+        value = float(value)
+        log_value = math.log10(value) - margin
+
+        if digits < 0:
+            # Default to 0
+            digits = 0
+
+        for prefix, scale in SI_UNITS:
+            if log_value <= scale:
+                value /= 10**scale
+                return (float(f'{value:.{digits}f}'), prefix)
+
+        return (float(f'{value:.{digits}f}'), '')
+
+    return (float(f'{value:.{digits}f}'), '')
+
+
+def format_binary(value, unit, digits=3):
+    '''
+    Format a number as a binary number. Returns a string.
+
+    Args:
+        value (float): value to convert
+        unit (str): unit of the value
+        digits (int): number of digits to print after .
+    '''
+    scaled_value, prefix = scale_binary(value, unit, digits=digits)
+    # need to do this in case float shortens scaled_value
+    return f'{scaled_value:.{digits}f}{prefix}'
+
+
+def scale_binary(value, unit, digits=3):
+    '''
+    Format a number as a binary number. Returns a float.
+
+    Args:
+        value (float): value to convert
+        unit (str): unit of the value
+        digits (int): number of digits to print after .
+    '''
+    value = float(value)
+
+    fvalue = (int(value), '')
+    if is_base_binary_unit(unit):
+        for prefix, scale in BINARY_UNITS:
+            new_value = value / 2**scale
+
+            if new_value > 1:
+                fvalue = (float(f'{new_value:.{digits}f}'), prefix)
+                continue
+
+            return fvalue
+
+    return (float(f'{value:.{digits}f}'), '')
+
+
+def format_time(value):
+    '''
+    Format a number as time.
+    Prints as hh:mm:ss.ms (hours:minutes:seconds.milliseconds)
+
+    Args:
+        value (float): number of seconds to convert
+    '''
+    # Report as hh:mm::ss.ms
+    value, milliseconds = divmod(value, 1)
+    hours, value = divmod(value, 3600)
+    minutes, seconds = divmod(value, 60)
+    milliseconds *= 1000
+    ftime = ''
+    if hours > 0:
+        ftime += f'{int(hours)}:'
+    if hours > 0 or minutes > 0:
+        ftime += f'{int(minutes):02}:'
+    ftime += f'{int(seconds):02}.'
+    ftime += f'{int(milliseconds):03}'
+    return ftime

siliconcompiler/use.py

@@ -0,0 +1,177 @@
+# Copyright 2023 Silicon Compiler Authors. All Rights Reserved.
+
+from siliconcompiler import Chip
+
+
+class PackageChip(Chip):
+    def __init__(self, chip, name, package=None):
+        # Start with None as init setting will not depend on package
+        self.__package = None
+
+        super().__init__(name)
+        self.logger = chip.logger
+
+        path = None
+        ref = None
+        if isinstance(package, (tuple, list)):
+            if len(package) == 3:
+                package, path, ref = package
+            elif len(package) == 2:
+                package, path = package
+            else:
+                raise ValueError(f"{package} should be a 2 or 3 item tuple or list.")
+        elif isinstance(package, dict):
+            if len(package) == 1:
+                info = list(package.values())[0]
+                if "path" not in info:
+                    raise ValueError(f"{package} should contain a path key.")
+                path = info["path"]
+                if "ref" in info:
+                    ref = info["ref"]
+
+                package = list(package.keys())[0]
+            else:
+                raise ValueError(f"{package} cannot contain multiple packages.")
+        elif isinstance(package, str):
+            pass
+        else:
+            if package is not None:
+                raise ValueError(f"{package} is not supported.")
+
+        if path:
+            self.register_source(package, path, ref=ref)
+
+        self.__package = package
+
+        # Clear all copy flags since these are libraries, pdks, fpga, etc.
+        for key in self.allkeys():
+            sc_type = self.get(*key, field='type')
+            if 'file' in sc_type or 'dir' in sc_type:
+                self.set(*key, False, field='copy')
+
+    def add(self, *args, field='value', step=None, index=None, package=None):
+        if not package:
+            package = self.__package
+        super().add(*args, field=field, step=step,
+                    index=index, package=package)
+
+    def set(self, *args, field='value', clobber=True, step=None, index=None, package=None):
+        if not package:
+            package = self.__package
+        super().set(*args, field=field, clobber=clobber, step=step,
+                    index=index, package=package)
+
+    def input(self, filename, fileset=None, filetype=None, iomap=None,
+              step=None, index=None, package=None):
+        self._add_input_output('input', filename, fileset, filetype, iomap,
+                               step=step, index=index, package=package,
+                               quiet=True)
+
+    def output(self, filename, fileset=None, filetype=None, iomap=None,
+               step=None, index=None, package=None):
+        self._add_input_output('output', filename, fileset, filetype, iomap,
+                               step=step, index=index, package=package,
+                               quiet=True)
+
+
+class PDK(PackageChip):
+    """
+    Object for configuring a process development kit.
+    This is the main object used for configuration and data for a PDK
+    within the SiliconCompiler platform.
+
+    This inherits all methods from :class:`~siliconcompiler.Chip`.
+
+    Args:
+        chip (Chip): A real only copy of the parent chip.
+        name (string): Name of the PDK.
+        package (string): Name of the data source
+    Examples:
+        >>> siliconcompiler.PDK(chip, "asap7")
+        Creates a flow object with name "asap7".
+    """
+
+
+class FPGA(PackageChip):
+    """
+    Object for configuring an FPGA
+    This is the main object used for configuration and data for a FPGA
+    within the SiliconCompiler platform.
+
+    This inherits all methods from :class:`~siliconcompiler.Chip`.
+
+    Args:
+        chip (Chip): A real only copy of the parent chip.
+        name (string): Name of the FPGA.
+        package (string): Name of the data source
+    Examples:
+        >>> siliconcompiler.FPGA(chip, "lattice_ice40")
+        Creates a flow object with name "lattice_ice40".
+    """
+
+
+class Library(PackageChip):
+    """
+    Object for configuring a library.
+    This is the main object used for configuration and data for a library
+    within the SiliconCompiler platform.
+
+    This inherits all methods from :class:`~siliconcompiler.Chip`.
+
+    Args:
+        chip (Chip): A real only copy of the parent chip.
+        name (string): Name of the library.
+        package (string): Name of the data source
+        auto_enable (boolean): If True, will automatically be added to ['option','library'].
+            This is only valid for non-logiclibs and macrolibs
+    Examples:
+        >>> siliconcompiler.Library(chip, "asap7sc7p5t")
+        Creates a library object with name "asap7sc7p5t".
+    """
+    def __init__(self, chip, name, package=None, auto_enable=False):
+        super().__init__(chip, name, package=package)
+
+        self.__auto_enable = auto_enable
+
+    def is_auto_enable(self):
+        return self.__auto_enable
+
+
+class Flow(Chip):
+    """
+    Object for configuring a flow.
+    This is the main object used for configuration and data for a flow
+    within the SiliconCompiler platform.
+
+    This inherits all methods from :class:`~siliconcompiler.Chip`.
+
+    Args:
+        chip (Chip): A real only copy of the parent chip.
+        name (string): Name of the flow.
+    Examples:
+        >>> siliconcompiler.Flow(chip, "asicflow")
+        Creates a flow object with name "asicflow".
+    """
+    def __init__(self, chip, name):
+        super().__init__(name)
+        self.logger = chip.logger
+
+
+class Checklist(Chip):
+    """
+    Object for configuring a checklist.
+    This is the main object used for configuration and data for a checklist
+    within the SiliconCompiler platform.
+
+    This inherits all methods from :class:`~siliconcompiler.Chip`.
+
+    Args:
+        chip (Chip): A real only copy of the parent chip.
+        name (string): Name of the checklist.
+    Examples:
+        >>> siliconcompiler.Checklist(chip, "tapeout")
+        Creates a checklist object with name "tapeout".
+    """
+    def __init__(self, chip, name):
+        super().__init__(name)
+        self.logger = chip.logger