siliconcompiler 0.27.1__py3-none-any.whl → 0.28.1__py3-none-any.whl

siliconcompiler/schema/schema_cfg.py

@@ -10,7 +10,7 @@ try:
 except ImportError:
     from siliconcompiler.schema.utils import trim
 
-SCHEMA_VERSION = '0.44.4'
+SCHEMA_VERSION = '0.48.2'
 
 #############################################################################
 # PARAM DEFINITION
@@ -175,7 +175,7 @@ def schema_cfg():
                 sctype='[file]',
                 pernode='optional',
                 copy=val[1],
-                shorthelp=f"{val[0]}: files",
+                shorthelp=f"{val[0]} files",
                 switch=f"-{item} 'fileset filetype <file>'",
                 example=[
                     f"cli: -{item} 'rtl verilog hello_world.v'",
@@ -215,6 +215,71 @@ def schema_cfg():
     # Packaging
     cfg = schema_package(cfg)
 
+    # Packaging
+    cfg = schema_schematic(cfg)
+
+    return cfg
+
+
+###############################################################################
+# SCHEMATIC
+###############################################################################
+def schema_schematic(cfg, name='default'):
+    ''' Schematic
+    '''
+
+    scparam(cfg, ['schematic', 'component', name, 'model'],
+            sctype='str',
+            shorthelp="Schematic: component model",
+            switch="-schematic_component_model 'name <str>'",
+            example=["cli: -schematic_component_model 'B0 NAND2X1'",
+                     "api: chip.set('schematic', 'component', 'B0, 'model', 'NAND2X1')"],
+            schelp="""Model of a component, specified on a per instance basis.""")
+
+    scparam(cfg, ['schematic', 'pin', name, 'dir'],
+            sctype='enum',
+            enum=['input', 'output', 'inout'],
+            shorthelp="Schematic: pin direction",
+            switch="-schematic_pin_dir 'name <str>'",
+            example=["cli: -schematic_pin_dir 'A input'",
+                     "api: chip.set('schematic', 'pin', 'A', 'dir', 'input')"],
+            schelp="""Direction of pin specified on a per pin basis.""")
+
+    scparam(cfg, ['schematic', 'net', name, 'connect'],
+            sctype='[str]',
+            shorthelp="Schematic: net connection",
+            switch="-schematic_net_connect 'name <str>'",
+            example=["cli: -schematic_net_connect 'net0 I42.Z'",
+                     "api: chip.set('schematic', 'net', 'net0', 'connect', 'I42.Z')"],
+            schelp="""Component and pin connectivity specified as a list
+            of connection points on a per net basis. The connection point
+            point format is "INSTANCE.PIN", where "." is the hierarchy
+            character. Connections without ".PIN" implies the connection is
+            a primary design I/O pin. Specifying "INSTANCE.*" implies that
+            all pins of INSTANCE get connected to the net.""")
+
+    scparam(cfg, ['schematic', 'hierchar'],
+            sctype='str',
+            defvalue='.',
+            shorthelp="Schematic: hierarchy character",
+            switch="-schematic_hierchar <str>",
+            example=["cli: -schematic_hierchar '/'",
+                     "api: chip.set('schematic', 'hierchar', '/')"],
+            schelp="""Specifies the character used to express hierarchy. If
+            the hierarchy character is used as part of a name, it must be
+            escaped with a backslash('\').""")
+
+    scparam(cfg, ['schematic', 'buschar'],
+            sctype='str',
+            defvalue='[]',
+            shorthelp="Schematic: bus character",
+            switch="-schematic_buschar <str>",
+            example=["cli: -schematic_buschar '[]'",
+                     "api: chip.set('schematic', 'buschar', '[]')"],
+            schelp="""Specifies the character used to express bus bits. If the
+            bus character is used as part of a name, it must be
+            escaped with a backslash('\').""")
+
     return cfg
 
 
@@ -307,6 +372,7 @@ def schema_pdk(cfg, stackup='default'):
     scparam(cfg, ['pdk', pdkname, 'node'],
             sctype='float',
             scope='global',
+            unit='nm',
             shorthelp="PDK: process node",
             switch="-pdk_node 'pdkname <float>'",
             example=["cli: -pdk_node 'asap7 130'",
@@ -387,7 +453,7 @@ def schema_pdk(cfg, stackup='default'):
             Wafer diameter used in wafer based manufacturing process.
             The standard diameter for leading edge manufacturing is 300mm. For
             older process technologies and specialty fabs, smaller diameters
-            such as 200, 100, 125, 100 are common. The value is used to
+            such as 200, 150, 125, and 100 are common. The value is used to
             calculate dies per wafer and full factory chip costs.""")
 
     scparam(cfg, ['pdk', pdkname, 'panelsize'],
@@ -555,7 +621,7 @@ def schema_pdk(cfg, stackup='default'):
             'filetype' used in the aprtech is used by the tool specific APR TCL scripts
             to set up the technology parameters. Some tools may require additional
             files beyond the tech.lef file. Examples of extra file types include
-            antenna, tracks, tapcell, viarules, em.""")
+            antenna, tracks, tapcell, viarules, and em.""")
 
     checks = ['lvs', 'drc', 'erc', 'fill']
     name = 'default'
@@ -590,7 +656,7 @@ def schema_pdk(cfg, stackup='default'):
     scparam(cfg, ['pdk', pdkname, 'file', tool, key, stackup],
             sctype='[file]',
             scope='global',
-            shorthelp="PDK: special file",
+            shorthelp="PDK: custom file",
             switch="-pdk_file 'pdkname tool key stackup <file>'",
             example=[
                 "cli: -pdk_file 'asap7 xyce spice M10 asap7.sp'",
@@ -603,7 +669,7 @@ def schema_pdk(cfg, stackup='default'):
     scparam(cfg, ['pdk', pdkname, 'dir', tool, key, stackup],
             sctype='[dir]',
             scope='global',
-            shorthelp="PDK: special directory",
+            shorthelp="PDK: custom directory",
             switch="-pdk_dir 'pdkname tool key stackup <dir>'",
             example=[
                 "cli: -pdk_dir 'asap7 xyce rfmodel M10 rftechdir'",
@@ -617,7 +683,7 @@ def schema_pdk(cfg, stackup='default'):
     scparam(cfg, ['pdk', pdkname, 'var', tool, key, stackup],
             sctype='[str]',
             scope='global',
-            shorthelp="PDK: special variable",
+            shorthelp="PDK: custom, variable",
             switch="-pdk_var 'pdkname tool stackup key <str>'",
             example=[
                 "cli: -pdk_var 'asap7 xyce modeltype M10 bsim4'",
@@ -639,8 +705,7 @@ def schema_pdk(cfg, stackup='default'):
             switch="-pdk_doc 'pdkname doctype <file>'",
             example=["cli: -pdk_doc 'asap7 reference reference.pdf'",
                      "api: chip.set('pdk', 'asap7', 'doc', 'reference', 'reference.pdf')"],
-            schelp="""
-            Filepath to pdk documentation.""")
+            schelp="""Filepath to pdk documentation.""")
 
     return cfg
 
@@ -660,44 +725,44 @@ def schema_datasheet(cfg, name='default', mode='default'):
                   'sram', 'dram', 'flash', 'rom',
                   'interface', 'clock', 'amplifier',
                   'filter', 'mixer', 'modulator', 'lna'],
-            shorthelp="Datasheet: part type",
+            shorthelp="Datasheet: type",
             switch="-datasheet_type '<str>'",
             example=[
                 "cli: -datasheet_type 'digital'",
                 "api: chip.set('datasheet', 'type', 'digital')"],
-            schelp="""Part type.""")
+            schelp="""Device type.""")
 
     # Documentation
     scparam(cfg, ['datasheet', 'doc'],
             sctype='[file]',
-            shorthelp="Datasheet: part documentation",
+            shorthelp="Datasheet: documentation",
             switch="-datasheet_doc '<file>'",
             example=[
                 "cli: -datasheet_doc 'za001.pdf'",
                 "api: chip.set('datasheet', 'doc', 'za001.pdf)"],
-            schelp="""Device datasheet document.""")
+            schelp="""Datasheet document.""")
 
     # Series
     scparam(cfg, ['datasheet', 'series'],
             sctype='str',
-            shorthelp="Datasheet: device series",
+            shorthelp="Datasheet: series",
             switch="-datasheet_series '<str>'",
             example=[
                 "cli: -datasheet_series 'ZA0'",
                 "api: chip.set('datasheet', 'series', 'ZA0)"],
             schelp="""Device series describing a family of devices or
             a singular device with multiple packages and/or qualification
-            SKUs.""")
+            `SKUs <https://en.wikipedia.org/wiki/Stock_keeping_unit>`_.""")
 
     # Manufacturer
     scparam(cfg, ['datasheet', 'manufacturer'],
             sctype='str',
-            shorthelp="Datasheet: part manufacturer",
+            shorthelp="Datasheet: manufacturer",
             switch="-datasheet_manufacturer '<str>'",
             example=[
                 "cli: -datasheet_manufacturer 'Acme'",
                 "api: chip.set('datasheet', 'manufacturer', 'Acme')"],
-            schelp="""Device manufacturer/vendor.""")
+            schelp="""Device manufacturer.""")
 
     # Device description
     scparam(cfg, ['datasheet', 'description'],
@@ -707,17 +772,17 @@ def schema_datasheet(cfg, name='default', mode='default'):
             example=[
                 "cli: -datasheet_description 'Yet another CPU'",
                 "api: chip.set('datasheet', 'description', 'Yet another CPU')"],
-            schelp="""Free text device description""")
+            schelp="""Device description entered as free text.""")
 
     # Features
     scparam(cfg, ['datasheet', 'features'],
             sctype='[str]',
-            shorthelp="Datasheet: part features",
+            shorthelp="Datasheet: features",
             switch="-datasheet_features '<str>'",
             example=[
                 "cli: -datasheet_features 'usb3.0'",
                 "api: chip.set('datasheet', 'features', 'usb3.0')"],
-            schelp="""List of manufacturer specified device features""")
+            schelp="""Device features.""")
 
     # Grade
     scparam(cfg, ['datasheet', 'grade'],
@@ -725,7 +790,7 @@ def schema_datasheet(cfg, name='default', mode='default'):
             enum=['consumer', 'industrial',
                   'medical', 'automotive',
                   'military', 'space'],
-            shorthelp="Datasheet: part manufacturing grade",
+            shorthelp="Datasheet: manufacturing grade",
             switch="-datasheet_grade '<str>'",
             example=[
                 "cli: -datasheet_grade 'automotive'",
@@ -735,7 +800,7 @@ def schema_datasheet(cfg, name='default', mode='default'):
     # Qualification
     scparam(cfg, ['datasheet', 'qual'],
             sctype='[str]',
-            shorthelp="Datasheet: qualification",
+            shorthelp="Datasheet: qualification level",
             switch="-datasheet_qual '<str>'",
             example=[
                 "cli: -datasheet_qual 'AEC-Q100'",
@@ -770,7 +835,7 @@ def schema_datasheet(cfg, name='default', mode='default'):
     scparam(cfg, ['datasheet', 'fmax'],
             sctype='float',
             unit='MHz',
-            shorthelp="Datasheet: device maximum frequency",
+            shorthelp="Datasheet: maximum frequency",
             switch="-datasheet_fmax '<float>'",
             example=[
                 "cli: -datasheet_fmax 100'",
@@ -859,7 +924,7 @@ def schema_datasheet(cfg, name='default', mode='default'):
                 "cli: -datasheet_io_arch 'pio spi'",
                 "api: chip.set('datasheet', 'io', 'pio', 'arch', 'spi')"],
             schelp="""Datasheet: List of IO standard architectures supported
-            by the named port.""")
+            by the named IO port.""")
 
     metrics = {'fmax': ['maximum frequency', 100, 'float', 'MHz'],
                'width': ['width', 4, 'int', None],
@@ -875,7 +940,7 @@ def schema_datasheet(cfg, name='default', mode='default'):
                 example=[
                     f"cli: -datasheet_io_{i} 'name {v[1]}'",
                     f"api: chip.set('datasheet', 'io', name, '{i}', {v[1]})"],
-                schelp=f"""Datasheet: IO {v[1]} metrics specified on a named port basis.
+                schelp=f"""Datasheet: IO {v[1]} metrics specified on a per IO port basis.
                 """)
 
     ######################
@@ -889,7 +954,7 @@ def schema_datasheet(cfg, name='default', mode='default'):
             example=[
                 "cli: -datasheet_proc_arch '0 RV64GC'",
                 "api: chip.set('datasheet', 'proc', name, 'arch', 'openfpga')"],
-            schelp="""Processor architecture.""")
+            schelp="""Processor architecture specified on a per core basis.""")
 
     scparam(cfg, ['datasheet', 'proc', name, 'features'],
             sctype='[str]',
@@ -898,7 +963,7 @@ def schema_datasheet(cfg, name='default', mode='default'):
             example=[
                 "cli: -datasheet_proc_features '0 SIMD'",
                 "api: chip.set('datasheet','proc','cpu','features', 'SIMD')"],
-            schelp="""List of maker specified processor features.""")
+            schelp="""List of maker specified processor features specified on a per core basis.""")
 
     scparam(cfg, ['datasheet', 'proc', name, 'datatypes'],
             sctype='[enum]',
@@ -910,13 +975,14 @@ def schema_datasheet(cfg, name='default', mode='default'):
             example=[
                 "cli: -datasheet_proc_datatypes '0 int8'",
                 "api: chip.set('datasheet', 'proc', 'cpu', 'datatypes', 'int8')"],
-            schelp="""List of datatypes supported by the processor.""")
+            schelp="""List of datatypes supported by the processor specified
+            on a per core basis.""")
 
     metrics = {'archsize': ['architecture size', 64, None],
                'cores': ['number of cores', 4, None],
                'fmax': ['maximum frequency', 100, 'MHz'],
-               'ops': ['operations per cycle per core', 4, None],
-               'mults': ['hard multiplier units per core', 100, None],
+               'ops': ['operations per cycle', 4, None],
+               'mults': ['hard multiplier units', 100, None],
                'icache': ['l1 icache size', 32, 'KB'],
                'dcache': ['l1 dcache size', 32, 'KB'],
                'l2cache': ['l2 cache size', 1024, 'KB'],
@@ -933,7 +999,7 @@ def schema_datasheet(cfg, name='default', mode='default'):
                 example=[
                     f"cli: -datasheet_proc_{i} 'cpu {v[1]}'",
                     f"api: chip.set('datasheet', 'proc', 'cpu', '{i}', {v[1]})"],
-                schelp=f"""Processor metric: {v[0]}.""")
+                schelp=f"""Processor metric: {v[0]} specified on a per core basis.""")
 
     ######################
     # Memory
@@ -946,7 +1012,7 @@ def schema_datasheet(cfg, name='default', mode='default'):
             example=[
                 "cli: -datasheet_memory_bits 'm0 1024'",
                 "api: chip.set('datasheet', 'memory', 'm0', 'bits', 1024)"],
-            schelp="""Memory total number of bits.""")
+            schelp="""Memory total number of bits specified on a per memory basis.""")
 
     scparam(cfg, ['datasheet', 'memory', name, 'width'],
             sctype='int',
@@ -955,7 +1021,7 @@ def schema_datasheet(cfg, name='default', mode='default'):
             example=[
                 "cli: -datasheet_memory_width 'm0 16'",
                 "api: chip.set('datasheet', 'memory', 'm0', 'width', 16)"],
-            schelp="""Memory width.""")
+            schelp="""Memory width specified on a per memory basis.""")
 
     scparam(cfg, ['datasheet', 'memory', name, 'depth'],
             sctype='int',
@@ -964,7 +1030,7 @@ def schema_datasheet(cfg, name='default', mode='default'):
             example=[
                 "cli: -datasheet_memory_depth 'm0 128'",
                 "api: chip.set('datasheet', 'memory', 'm0', 'depth', 128)"],
-            schelp="""Memory depth.""")
+            schelp="""Memory depth specified on a per memory basis.""")
 
     scparam(cfg, ['datasheet', 'memory', name, 'banks'],
             sctype='int',
@@ -973,7 +1039,7 @@ def schema_datasheet(cfg, name='default', mode='default'):
             example=[
                 "cli: -datasheet_memory_banks 'm0 4'",
                 "api: chip.set('datasheet', 'memory', 'm0', 'banks', 4)"],
-            schelp="""Memory banks.""")
+            schelp="""Memory banks specified on a per memory basis.""")
 
     # Timing
     metrics = {'fmax': ['max frequency', (1e9, 1e9, 1e9), 'Hz'],
@@ -998,7 +1064,7 @@ def schema_datasheet(cfg, name='default', mode='default'):
                 example=[
                     f"cli: -datasheet_memory_{i} 'name {v[1]}'",
                     f"api: chip.set('datasheet', 'memory', name, '{i}', {v[1]})"],
-                schelp=f"""Memory {v[1]}.""")
+                schelp=f"""Memory {v[1]} specified on a per memory basis.""")
 
     # Latency (cycles)
     metrics = {'tcl': ['column address latency', (100, 100, 100), 'cycles'],
@@ -1016,7 +1082,7 @@ def schema_datasheet(cfg, name='default', mode='default'):
                 example=[
                     f"cli: -datasheet_memory_{i} 'name {v[1]}'",
                     f"api: chip.set('datasheet', 'memory', name, '{i}', {v[1]})"],
-                schelp=f"""Memory {v[1]}.""")
+                schelp=f"""Memory {v[1]} specified on a per memory basis.""")
 
     ######################
     # FPGA
@@ -1032,7 +1098,7 @@ def schema_datasheet(cfg, name='default', mode='default'):
             schelp="""FPGA architecture.
             """)
 
-    metrics = {'luts': ['LUTs (4 input)', 32000, None],
+    metrics = {'luts': ['LUTs', 32000, None],
                'registers': ['registers', 100, None],
                'plls': ['pll blocks', 1, None],
                'mults': ['multiplier/dsp elements', 100, None],
@@ -1079,7 +1145,7 @@ def schema_datasheet(cfg, name='default', mode='default'):
     for i, v in metrics.items():
         scparam(cfg, ['datasheet', 'analog', name, i],
                 sctype='int',
-                shorthelp=f"Datasheet: Analog {v[0]}",
+                shorthelp=f"Datasheet: analog {v[0]}",
                 switch=f"-datasheet_analog_{i} 'name <int>'",
                 example=[
                     f"cli: -datasheet_analog_{i} 'i0 {v[1]}'",
@@ -1122,7 +1188,7 @@ def schema_datasheet(cfg, name='default', mode='default'):
         scparam(cfg, ['datasheet', 'analog', name, i],
                 unit=v[2],
                 sctype='(float,float,float)',
-                shorthelp=f"Datasheet: Analog {v[0]}",
+                shorthelp=f"Datasheet: analog {v[0]}",
                 switch=f"-datasheet_analog_{i} 'name <(float,float,float)>'",
                 example=[
                     f"cli: -datasheet_analog_{i} 'i0 {v[1]}'",
@@ -1186,6 +1252,7 @@ def schema_datasheet(cfg, name='default', mode='default'):
     # Package Description
     #########################
 
+    # high level description
     scparam(cfg, ['datasheet', 'package', name, 'type'],
             sctype='enum',
             enum=['bga', 'lga', 'csp', 'qfn', 'qfp', 'sop', 'die', 'wafer'],
@@ -1194,7 +1261,7 @@ def schema_datasheet(cfg, name='default', mode='default'):
             example=[
                 "cli: -datasheet_package_type 'abcd bga'",
                 "api: chip.set('datasheet', 'package', 'abcd', 'type', 'bga')"],
-            schelp="""Datasheet: package type.""")
+            schelp="""Package type specified on a named package basis.""")
 
     scparam(cfg, ['datasheet', 'package', name, 'drawing'],
             sctype='[file]',
@@ -1203,21 +1270,38 @@ def schema_datasheet(cfg, name='default', mode='default'):
             example=[
                 "cli: -datasheet_package_drawing 'abcd p484.pdf'",
                 "api: chip.set('datasheet', 'package', 'abcd', 'drawing', 'p484.pdf')"],
-            schelp="""Datasheet: package drawing""")
+            schelp="""Mechanical package outline for documentation purposes.
+            Common file formats include PDF, DOC, SVG, and PNG.""")
 
     scparam(cfg, ['datasheet', 'package', name, 'pincount'],
             sctype='int',
-            shorthelp="Datasheet: package pincount",
+            shorthelp="Datasheet: package total pincount",
             switch="-datasheet_package_pincount 'name <int>'",
             example=[
                 "cli: -datasheet_package_pincount 'abcd 484'",
                 "api: chip.set('datasheet', 'package', 'abcd', 'pincount', '484')"],
-            schelp="""Datasheet: package pincount""")
+            schelp="""Total number package pins of the named package.""")
 
-    metrics = {'length': ['length', (20, 20, 20), 'mm'],
-               'width': ['width', (20, 20, 20), 'mm'],
-               'thickness': ['thickness', (1.0, 1.1, 1.2), 'mm'],
-               'pitch': ['pitch', (0.8, 0.85, 0.9), 'mm']
+    scparam(cfg, ['datasheet', 'package', name, 'anchor'],
+            sctype='(float,float)',
+            defvalue=(0.0, 0.0),
+            unit='um',
+            shorthelp="Datasheeet: package anchor",
+            switch="-datasheet_package_anchor 'name <(float,float)>'",
+            example=[
+                "cli: -datasheet_package_anchor 'i0 (3.0,3.0)'",
+                "api: chip.set('datasheet', 'package', 'i0', 'anchor', (3.0, 3.0))"],
+            schelp="""
+            Package anchor point with respect to the lower left corner of the package.
+            When placing a component on a substrate, the placement location specifies
+            the distance from the substrate origin to the anchor point of the placed
+            object.""")
+
+    # critical dimensions
+    metrics = {'length': ['length', (4000, 4000, 4000), 'um'],
+               'width': ['width', (4000, 4000, 4000), 'um'],
+               'thickness': ['thickness', (900, 1000, 1100), 'um'],
+               'pitch': ['pitch', (800, 850, 900), 'um']
                }
 
     for i, v in metrics.items():
@@ -1232,62 +1316,60 @@ def schema_datasheet(cfg, name='default', mode='default'):
                 schelp=f"""Datasheet: package {v[0]}. Values are tuples of
                 (min, nominal, max).""")
 
-    scparam(cfg, ['datasheet', 'package', name, 'pinshape', name],
+    # pinout diagram
+    pinnumber = 'default'
+    scparam(cfg, ['datasheet', 'package', name, 'pin', pinnumber, 'shape'],
             sctype='enum',
-            enum=['circle', 'rectangle'],
+            enum=['circle', 'rectangle', 'square', 'octagon'],
             shorthelp="Datasheet: package pin shape",
-            switch="-datasheet_package_pinshape 'name name <str>'",
+            switch="-datasheet_package_pin_shape 'name pinnumber <str>'",
             example=[
-                "cli: -datasheet_package_pinshape 'abcd B1 circle'",
-                "api: chip.set('datasheet', 'package', 'abcd', 'pinshape', 'B1', 'circle')"],
-            schelp="""Datasheet: pin shape (rectangle or circle) specified on a per package
-            and per pin basis.""")
+                "cli: -datasheet_package_pin_shape 'abcd B1 circle'",
+                "api: chip.set('datasheet', 'package', 'abcd', 'pin', 'B1', 'shape', 'circle')"],
+            schelp="""Datasheet: package pin shape specified on a per package
+            and per pin number basis.""")
 
-    metrics = {'pinwidth': ['pinwidth', (0.2, 0.25, 0.3), 'mm'],
-               'pinlength': ['pinlength', (0.2, 0.25, 0.3), 'mm']
+    metrics = {'width': ['width', (200, 250, 300), 'um'],
+               'length': ['length', (200, 250, 300), 'um']
                }
 
     for i, v in metrics.items():
-        scparam(cfg, ['datasheet', 'package', name, i, name],
+        scparam(cfg, ['datasheet', 'package', name, 'pin', pinnumber, i],
                 unit=v[2],
                 sctype='(float,float,float)',
                 shorthelp=f"Datasheet: package pin {v[0]}",
-                switch=f"-datasheet_package_{i} 'name name <(float,float,float)>'",
+                switch=f"-datasheet_package_pin_{i} 'name pinnumber <(float,float,float)>'",
                 example=[
-                    f"cli: -datasheet_package_{i} 'abcd B1 {v[1]}'",
-                    f"api: chip.set('datasheet', 'package', 'abcd', '{i}', 'B1', {v[1]}"],
-                schelp=f"""Datsheet: {v[0]} specified on a per package and per pin basis.
-                Values are tuples of (min, nominal, max).""")
+                    f"cli: -datasheet_package_pin_{i} 'abcd B1 {v[1]}'",
+                    f"api: chip.set('datasheet', 'package', 'abcd', 'pin', 'B1', '{i}', {v[1]}"],
+                schelp=f"""Datsheet: {v[0]} specified on a per package and per pin number
+                basis. Values are tuples of (min, nominal, max).""")
 
-    scparam(cfg, ['datasheet', 'package', name, 'pinloc', name],
+    scparam(cfg, ['datasheet', 'package', name, 'pin', pinnumber, 'loc'],
             sctype='(float,float)',
-            unit='mm',
+            unit='um',
             shorthelp="Datasheet: package pin location",
-            switch="-datasheet_package_pinloc 'name name <(float,float)>'",
+            switch="-datasheet_package_pin_loc 'name pinnumber <(float,float)>'",
             example=[
-                "cli: -datasheet_package_pinloc 'abcd B1 (0.5,0.5)'",
-                "api: chip.set('datasheet', 'package', 'abcd', 'pinloc', 'B1', (0.5,0.5)"],
-            schelp="""Datsheet: Pin location specified as an (x,y) tuple. Locations
-            specify the center of the pin with respect to the center of the package.
-            """)
+                "cli: -datasheet_package_pin_loc 'abcd B1 (500,500)'",
+                "api: chip.set('datasheet', 'package', 'abcd', 'pin', 'B1', 'loc', (500,500)"],
+            schelp="""Datsheet: Package pin location specified as an (x,y) tuple on a per
+            package and per pin number basis. Locations specify the center of the pin with
+            respect to the center of the package.""")
 
-    scparam(cfg, ['datasheet', 'package', name, 'netname', name],
+    scparam(cfg, ['datasheet', 'package', name, 'pin', pinnumber, 'name'],
             sctype='str',
-            shorthelp="Datasheet: package pin net name",
-            switch="-datasheet_package_netname 'name name <str>'",
-            example=[
-                "cli: -datasheet_package_netname 'abcd B1 VDD'",
-                "api: chip.set('datasheet', 'package', 'abcd', 'netname', 'B1', 'VDD')"],
-            schelp="""Datsheet: Device net connected to the pin.""")
-
-    scparam(cfg, ['datasheet', 'package', name, 'portname', name],
-            sctype='str',
-            shorthelp="Datasheet: package pin port name",
-            switch="-datasheet_package_portname 'name name <str>'",
-            example=[
-                "cli: -datasheet_package_portname 'abcd B1 VDD'",
-                "api: chip.set('datasheet', 'package', 'abcd', 'portname', 'B1', 'VDD')"],
-            schelp="""Datsheet: Device port connected to the pin.""")
+            shorthelp="Datasheet: package pin name",
+            switch="-datasheet_package_pin_name 'name pinnumber <str>'",
+            example=[
+                "cli: -datasheet_package_pin_name 'abcd B1 clk'",
+                "api: chip.set('datasheet', 'package', 'abcd', 'pin', 'B1', 'name', 'clk')"],
+            schelp="""Datsheet: Package pin name specified on a per package and per pin
+            number basis. The pin number is generally an integer starting at '1' in the case of
+            packages like qfn, qfp and an array index ('A1', 'A2') in the case of array packages
+            like bgas. The pin name refers to the logical function assigned to the physical
+            pin number (e.g clk, vss, in). Details regarding the logical pin is stored in
+            the :keypath:`datasheet,pin`.""")
 
     ######################
     # Pin Specifications
@@ -1313,8 +1395,7 @@ def schema_datasheet(cfg, name='default', mode='default'):
             example=[
                 "cli: -datasheet_pin_dir 'clk global input'",
                 "api: chip.set('datasheet', 'pin', 'clk', 'dir', 'global', 'input')"],
-            schelp="""Pin direction specified on a per mode basis. Acceptable pin
-            directions include: input, output, inout.""")
+            schelp="""Pin direction specified on a per mode basis.""")
 
     # Pin complement (for differential pair)
     scparam(cfg, ['datasheet', 'pin', name, 'complement', mode],
@@ -1490,8 +1571,7 @@ def schema_flowgraph(cfg, flow='default', step='default', index='default'):
             example=[
                 "cli: -flowgraph_tool 'asicflow place 0 openroad'",
                 "api: chip.set('flowgraph', 'asicflow', 'place', '0', 'tool', 'openroad')"],
-            schelp="""Name of the tool name used for task execution. The 'tool' parameter
-            is ignored for builtin tasks.""")
+            schelp="""Name of the tool name used for task execution.""")
 
     # task (belonging to tool)
     scparam(cfg, ['flowgraph', flow, step, index, 'task'],
@@ -1501,8 +1581,7 @@ def schema_flowgraph(cfg, flow='default', step='default', index='default'):
             example=[
                 "cli: -flowgraph_task 'asicflow myplace 0 place'",
                 "api: chip.set('flowgraph', 'asicflow', 'myplace', '0', 'task', 'place')"],
-            schelp="""Name of the tool associated task used for step execution. Builtin
-            task names include: minimum, maximum, join, verify, mux. """)
+            schelp="""Name of the tool associated task used for step execution.""")
 
     scparam(cfg, ['flowgraph', flow, step, index, 'taskmodule'],
             sctype='str',
@@ -1573,7 +1652,7 @@ def schema_tool(cfg, tool='default'):
             schelp="""
             File system path to tool executable. The path is prepended to the
             system PATH environment variable for batch and interactive runs. The
-            path parameter can be left blank if the 'exe' is already in the
+            path parameter can be left blank if the :keypath:`tool,<tool>,exe` is already in the
             environment search path.""")
 
     scparam(cfg, ['tool', tool, 'vswitch'],
@@ -1584,8 +1663,8 @@ def schema_tool(cfg, tool='default'):
                      "api: chip.set('tool', 'openroad', 'vswitch', '-version')"],
             schelp="""
             Command line switch to use with executable used to print out
-            the version number. Common switches include -v, -version,
-            --version. Some tools may require extra flags to run in batch mode.""")
+            the version number. Common switches include ``-v``, ``-version``,
+            ``--version``. Some tools may require extra flags to run in batch mode.""")
 
     scparam(cfg, ['tool', tool, 'vendor'],
             sctype='str',
@@ -1616,7 +1695,7 @@ def schema_tool(cfg, tool='default'):
             then the job is halted pre-execution. For backwards compatibility,
             entries that do not conform to the standard will be interpreted as a
             version with an '==' specifier. This check can be disabled by
-            setting 'novercheck' to True.""")
+            setting :keypath:`option,novercheck` to True.""")
 
     scparam(cfg, ['tool', tool, 'format'],
             sctype='enum',
@@ -1641,7 +1720,7 @@ def schema_tool(cfg, tool='default'):
             Defines a set of tool specific environment variables used by the executable
             that depend on license key servers to control access. For multiple servers,
             separate each server by a 'colon'. The named license variable are read at
-            runtime (run()) and the environment variables are set.
+            runtime (:meth:`.run()`) and the environment variables are set.
             """)
 
     return cfg
@@ -1747,7 +1826,7 @@ def schema_task(cfg, tool='default', task='default', step='default', index='defa
             sctype='[file]',
             pernode='optional',
             copy=True,
-            shorthelp="Task: setup files",
+            shorthelp="Task: custom setup files",
             switch="-tool_task_file 'tool task key <file>'",
             example=[
                 "cli: -tool_task_file 'openroad floorplan macroplace macroplace.tcl'",
@@ -1763,7 +1842,7 @@ def schema_task(cfg, tool='default', task='default', step='default', index='defa
             sctype='[dir]',
             pernode='optional',
             copy=True,
-            shorthelp="Task: setup directories",
+            shorthelp="Task: custom setup directories",
             switch="-tool_task_dir 'tool task key <dir>'",
             example=[
                 "cli: -tool_task_dir 'verilator compile cincludes include'",
@@ -1779,7 +1858,7 @@ def schema_task(cfg, tool='default', task='default', step='default', index='defa
     scparam(cfg, ['tool', tool, 'task', task, 'input'],
             sctype='[file]',
             pernode='required',
-            shorthelp="Task: inputs",
+            shorthelp="Task: input files",
             switch="-tool_task_input 'tool task <file>'",
             example=[
                 "cli: -tool_task_input 'openroad place place 0 oh_add.def'",
@@ -1788,14 +1867,14 @@ def schema_task(cfg, tool='default', task='default', step='default', index='defa
             schelp="""
             List of data files to be copied from previous flowgraph steps 'output'
             directory. The list of steps to copy files from is defined by the
-            list defined by the dictionary key ['flowgraph', step, index, 'input'].
+            list defined by the dictionary key :keypath:`flowgraph,<step>,<index>',input`.
             All files must be available for flow to continue. If a file
             is missing, the program exists on an error.""")
 
     scparam(cfg, ['tool', tool, 'task', task, 'output'],
             sctype='[file]',
             pernode='required',
-            shorthelp="Task: outputs",
+            shorthelp="Task: output files",
             switch="-tool_task_output 'tool task <file>'",
             example=[
                 "cli: -tool_task_output 'openroad place place 0 oh_add.def'",
@@ -1813,7 +1892,7 @@ def schema_task(cfg, tool='default', task='default', step='default', index='defa
             defvalue='log',
             scope='job',
             pernode='optional',
-            shorthelp="Task: Destination for stdout",
+            shorthelp="Task: destination for stdout",
             switch="-tool_task_stdout_destination 'tool task <str>'",
             example=["cli: -tool_task_stdout_destination 'ghdl import log'",
                      "api: chip.set('tool', 'ghdl', 'task', 'import', 'stdout', 'destination', "
@@ -1831,7 +1910,7 @@ def schema_task(cfg, tool='default', task='default', step='default', index='defa
             defvalue='log',
             scope='job',
             pernode='optional',
-            shorthelp="Task: File suffix for redirected stdout",
+            shorthelp="Task: file suffix for redirected stdout",
             switch="-tool_task_stdout_suffix 'tool task <str>'",
             example=["cli: -tool_task_stdout_suffix 'ghdl import log'",
                      "api: chip.set('tool', ghdl', 'task', 'import', 'stdout', 'suffix', 'log')"],
@@ -1844,7 +1923,7 @@ def schema_task(cfg, tool='default', task='default', step='default', index='defa
             defvalue='log',
             scope='job',
             pernode='optional',
-            shorthelp="Task: Destination for stderr",
+            shorthelp="Task: destination for stderr",
             switch="-tool_task_stderr_destination 'tool task <str>'",
             example=["cli: -tool_task_stderr_destination 'ghdl import log'",
                      "api: chip.set('tool', ghdl', 'task', 'import', 'stderr', 'destination', "
@@ -1862,7 +1941,7 @@ def schema_task(cfg, tool='default', task='default', step='default', index='defa
             defvalue='log',
             scope='job',
             pernode='optional',
-            shorthelp="Task: File suffix for redirected stderr",
+            shorthelp="Task: file suffix for redirected stderr",
             switch="-tool_task_stderr_suffix 'tool task <str>'",
             example=["cli: -tool_task_stderr_suffix 'ghdl import log'",
                      "api: chip.set('tool', 'ghdl', 'task', 'import', 'stderr', 'suffix', 'log')"],
@@ -1879,14 +1958,14 @@ def schema_task(cfg, tool='default', task='default', step='default', index='defa
                 "api: chip.set('tool', 'openroad', 'task', 'cts', 'require', 'design')"],
             schelp="""
             List of keypaths to required task parameters. The list is used
-            by check_manifest() to verify that all parameters have been set up before
+            by :meth:`.check_manifest()` to verify that all parameters have been set up before
             step execution begins.""")
 
     metric = 'default'
     scparam(cfg, ['tool', tool, 'task', task, 'report', metric],
             sctype='[file]',
             pernode='required',
-            shorthelp="Task: reports",
+            shorthelp="Task: metric report files",
             switch="-tool_task_report 'tool task metric <file>'",
             example=[
                 "cli: -tool_task_report 'openroad place holdtns place 0 place.log'",
@@ -1976,7 +2055,7 @@ def schema_arg(cfg):
     scparam(cfg, ['arg', 'step'],
             sctype='str',
             scope='scratch',
-            shorthelp="ARG: Step argument",
+            shorthelp="ARG: step argument",
             switch="-arg_step <str>",
             example=["cli: -arg_step 'route'",
                      "api: chip.set('arg', 'step', 'route')"],
@@ -1984,13 +2063,13 @@ def schema_arg(cfg):
             Dynamic parameter passed in by the SC runtime as an argument to
             a runtime task. The parameter enables configuration code
             (usually TCL) to use control flow that depend on the current
-            'step'. The parameter is used the run() function and
+            'step'. The parameter is used the :meth:`.run()` function and
             is not intended for external use.""")
 
     scparam(cfg, ['arg', 'index'],
             sctype='str',
             scope='scratch',
-            shorthelp="ARG: Index argument",
+            shorthelp="ARG: index argument",
             switch="-arg_index <str>",
             example=["cli: -arg_index 0",
                      "api: chip.set('arg', 'index', '0')"],
@@ -1998,7 +2077,7 @@ def schema_arg(cfg):
             Dynamic parameter passed in by the SC runtime as an argument to
             a runtime task. The parameter enables configuration code
             (usually TCL) to use control flow that depend on the current
-            'index'. The parameter is used the run() function and
+            'index'. The parameter is used the :meth:`.run()` function and
             is not intended for external use.""")
 
     return cfg
@@ -2292,7 +2371,7 @@ def schema_metric(cfg, step='default', index='default'):
                 f"api: chip.set('metric', '{item}', 10.0, step='dfm', index=0)"],
             pernode='required',
             schelp="""
-            Metric tracking time spent by the EDA executable 'exe' on a
+            Metric tracking time spent by the EDA executable :keypath:`tool,<tool>,exe` on a
             per step and index basis. It does not include the SiliconCompiler
             runtime overhead or time waiting for I/O operations and
             inter-processor communication to complete.""")
@@ -2479,7 +2558,7 @@ def schema_option(cfg):
     scparam(cfg, ['option', 'remote'],
             sctype='bool',
             scope='job',
-            shorthelp="Enable remote processing",
+            shorthelp="Option: enable remote processing",
             switch="-remote <bool>",
             example=[
                 "cli: -remote",
@@ -2493,7 +2572,7 @@ def schema_option(cfg):
     scparam(cfg, ['option', 'credentials'],
             sctype='file',
             scope='job',
-            shorthelp="User credentials file",
+            shorthelp="Option: user credentials file",
             switch="-credentials <file>",
             example=[
                 "cli: -credentials /home/user/.sc/credentials",
@@ -2515,7 +2594,7 @@ def schema_option(cfg):
     scparam(cfg, ['option', 'cachedir'],
             sctype='file',
             scope='job',
-            shorthelp="User cache directory",
+            shorthelp="Option: user cache directory",
             switch="-cachedir <file>",
             example=[
                 "cli: -cachedir /home/user/.sc/cache",
@@ -2529,7 +2608,7 @@ def schema_option(cfg):
             sctype='int',
             scope='job',
             pernode='optional',
-            shorthelp="Tool execution scheduling priority",
+            shorthelp="Option: tool scheduling priority",
             switch="-nice <int>",
             example=[
                 "cli: -nice 5",
@@ -2543,7 +2622,7 @@ def schema_option(cfg):
     scparam(cfg, ['option', 'pdk'],
             sctype='str',
             scope='job',
-            shorthelp="PDK target",
+            shorthelp="Option: PDK target",
             switch="-pdk <str>",
             example=["cli: -pdk freepdk45",
                      "api: chip.set('option', 'pdk', 'freepdk45')"],
@@ -2553,7 +2632,7 @@ def schema_option(cfg):
     scparam(cfg, ['option', 'stackup'],
             sctype='str',
             scope='job',
-            shorthelp="Stackup target",
+            shorthelp="Option: stackup target",
             switch="-stackup <str>",
             example=["cli: -stackup 2MA4MB2MC",
                      "api: chip.set('option', 'stackup', '2MA4MB2MC')"],
@@ -2564,7 +2643,7 @@ def schema_option(cfg):
     scparam(cfg, ['option', 'flow'],
             sctype='str',
             scope='job',
-            shorthelp="Flow target",
+            shorthelp="Option: flow target",
             switch="-flow <str>",
             example=["cli: -flow asicflow",
                      "api: chip.set('option', 'flow', 'asicflow')"],
@@ -2577,7 +2656,7 @@ def schema_option(cfg):
             pernode='optional',
             scope='job',
             defvalue='O0',
-            shorthelp="Optimization mode",
+            shorthelp="Option: optimization mode",
             switch=["-O<str>",
                     "-optmode <str>"],
             example=["cli: -O3",
@@ -2598,7 +2677,7 @@ def schema_option(cfg):
     scparam(cfg, ['option', 'cfg'],
             sctype='[file]',
             scope='job',
-            shorthelp="Configuration manifest",
+            shorthelp="Option: configuration manifest",
             switch="-cfg <file>",
             example=["cli: -cfg mypdk.json",
                      "api: chip.set('option', 'cfg', 'mypdk.json')"],
@@ -2607,13 +2686,13 @@ def schema_option(cfg):
             manifests. The files are read in automatically when using the
             'sc' command line application. In Python programs, JSON manifests
             can be merged into the current working manifest using the
-            read_manifest() method.""")
+            :meth:`Chip.read_manifest()` method.""")
 
     key = 'default'
     scparam(cfg, ['option', 'env', key],
             sctype='str',
             scope='job',
-            shorthelp="Environment variables",
+            shorthelp="Option: environment variables",
             switch="-env 'key <str>'",
             example=[
                 "cli: -env 'PDK_HOME /disk/mypdk'",
@@ -2626,7 +2705,7 @@ def schema_option(cfg):
     scparam(cfg, ['option', 'var', key],
             sctype='[str]',
             scope='job',
-            shorthelp="Custom variables",
+            shorthelp="Option: custom variables",
             switch="-var 'key <str>'",
             example=[
                 "cli: -var 'openroad_place_density 0.4'",
@@ -2641,7 +2720,7 @@ def schema_option(cfg):
             sctype='[file]',
             scope='job',
             copy=True,
-            shorthelp="Custom files",
+            shorthelp="Option: custom files",
             switch="-file 'key <file>'",
             example=[
                 "cli: -file 'openroad_tapcell ./tapcell.tcl'",
@@ -2656,7 +2735,7 @@ def schema_option(cfg):
             sctype='[dir]',
             scope='job',
             copy=True,
-            shorthelp="Custom directories",
+            shorthelp="Option: custom directories",
             switch="-dir 'key <dir>'",
             example=[
                 "cli: -dir 'openroad_tapcell ./tapcell.tcl'",
@@ -2673,7 +2752,7 @@ def schema_option(cfg):
             pernode='optional',
             scope='job',
             defvalue='info',
-            shorthelp="Logging level",
+            shorthelp="Option: logging level",
             switch="-loglevel <str>",
             example=[
                 "cli: -loglevel info",
@@ -2685,27 +2764,27 @@ def schema_option(cfg):
             sctype='dir',
             scope='job',
             defvalue='build',
-            shorthelp="Build directory",
+            shorthelp="Option: build directory",
             switch="-builddir <dir>",
             example=[
                 "cli: -builddir ./build_the_future",
                 "api: chip.set('option', 'builddir', './build_the_future')"],
             schelp="""
             The default build directory is in the local './build' where SC was
-            executed. The 'builddir' parameter can be used to set an alternate
+            executed. This can be used to set an alternate
             compilation directory path.""")
 
     scparam(cfg, ['option', 'jobname'],
             sctype='str',
             scope='job',
             defvalue='job0',
-            shorthelp="Job name",
+            shorthelp="Option: job name",
             switch="-jobname <str>",
             example=[
                 "cli: -jobname may1",
                 "api: chip.set('option', 'jobname', 'may1')"],
             schelp="""
-            Jobname during invocation of run(). The jobname combined with a
+            Jobname during invocation of :meth:`.run()`. The jobname combined with a
             defined director structure (<dir>/<design>/<jobname>/<step>/<index>)
             enables multiple levels of transparent job, step, and index
             introspection.""")
@@ -2713,7 +2792,7 @@ def schema_option(cfg):
     scparam(cfg, ['option', 'from'],
             sctype='[str]',
             scope='job',
-            shorthelp="Start flowgraph execution from",
+            shorthelp="Option: starting step",
             switch="-from <str>",
             example=[
                 "cli: -from 'import'",
@@ -2725,7 +2804,7 @@ def schema_option(cfg):
     scparam(cfg, ['option', 'to'],
             sctype='[str]',
             scope='job',
-            shorthelp="End flowgraph execution with",
+            shorthelp="Option: ending step",
             switch="-to <str>",
             example=[
                 "cli: -to 'syn'",
@@ -2737,7 +2816,7 @@ def schema_option(cfg):
     scparam(cfg, ['option', 'prune'],
             sctype='[(str,str)]',
             scope='job',
-            shorthelp="Prune flowgraph branches starting with",
+            shorthelp="Option: flowgraph pruning",
             switch="-prune 'node <(str,str)>'",
             example=[
                 "cli: -prune (syn,0)",
@@ -2750,7 +2829,7 @@ def schema_option(cfg):
             sctype='bool',
             scope='job',
             pernode='optional',
-            shorthelp="Breakpoint list",
+            shorthelp="Option: breakpoint list",
             switch="-breakpoint <bool>",
             example=[
                 "cli: -breakpoint true",
@@ -2765,7 +2844,7 @@ def schema_option(cfg):
             sctype='[str]',
             scope='job',
             pernode='optional',
-            shorthelp="Soft libraries",
+            shorthelp="Option: library list",
             switch="-library <str>",
             example=["cli: -library lambdalib_asap7",
                      "api: chip.set('option', 'library', 'lambdalib_asap7')"],
@@ -2776,7 +2855,7 @@ def schema_option(cfg):
     scparam(cfg, ['option', 'clean'],
             sctype='bool',
             scope='job',
-            shorthelp="Start a job from the beginning",
+            shorthelp="Option: cleanup previous job",
             switch="-clean <bool>",
             example=["cli: -clean",
                      "api: chip.set('option', 'clean', True)"],
@@ -2789,7 +2868,7 @@ def schema_option(cfg):
     scparam(cfg, ['option', 'hash'],
             sctype='bool',
             scope='job',
-            shorthelp="Enable file hashing",
+            shorthelp="Option: file hashing",
             switch="-hash <bool>",
             example=["cli: -hash",
                      "api: chip.set('option', 'hash', True)"],
@@ -2801,19 +2880,19 @@ def schema_option(cfg):
     scparam(cfg, ['option', 'nodisplay'],
             sctype='bool',
             scope='job',
-            shorthelp="Headless execution",
+            shorthelp="Option: headless execution",
             switch="-nodisplay <bool>",
             example=["cli: -nodisplay",
                      "api: chip.set('option', 'nodisplay', True)"],
             schelp="""
-            The '-nodisplay' flag prevents SiliconCompiler from
-            opening GUI windows such as the final metrics report.""")
+            This flag prevents SiliconCompiler from opening GUI windows such as
+            the final metrics report.""")
 
     scparam(cfg, ['option', 'quiet'],
             sctype='bool',
             pernode='optional',
             scope='job',
-            shorthelp="Quiet execution",
+            shorthelp="Option: quiet execution",
             switch="-quiet <bool>",
             example=["cli: -quiet",
                      "api: chip.set('option', 'quiet', True)"],
@@ -2825,7 +2904,7 @@ def schema_option(cfg):
     scparam(cfg, ['option', 'jobincr'],
             sctype='bool',
             scope='job',
-            shorthelp="Autoincrement jobname",
+            shorthelp="Option: autoincrement jobname",
             switch="-jobincr <bool>",
             example=["cli: -jobincr",
                      "api: chip.set('option', 'jobincr', True)"],
@@ -2841,20 +2920,20 @@ def schema_option(cfg):
             pernode='optional',
             defvalue=False,
             scope='job',
-            shorthelp="Disable version checking",
+            shorthelp="Option: disable version checking",
             switch="-novercheck <bool>",
             example=["cli: -novercheck",
                      "api: chip.set('option', 'novercheck', True)"],
             schelp="""
             Disables strict version checking on all invoked tools if True.
             The list of supported version numbers is defined in the
-            'version' parameter in the 'tool' dictionary for each tool.""")
+            :keypath:`tool,<tool>,version`.""")
 
     scparam(cfg, ['option', 'track'],
             sctype='bool',
             pernode='optional',
             scope='job',
-            shorthelp="Enable provenance tracking",
+            shorthelp="Option: enable provenance tracking",
             switch="-track <bool>",
             example=["cli: -track",
                      "api: chip.set('option', 'track', True)"],
@@ -2868,16 +2947,16 @@ def schema_option(cfg):
     scparam(cfg, ['option', 'entrypoint'],
             sctype='str',
             pernode='optional',
-            shorthelp="Program entry point",
+            shorthelp="Option: program entry point",
             switch="-entrypoint <str>",
             example=["cli: -entrypoint top",
                      "api: chip.set('option', 'entrypoint', 'top')"],
             schelp="""Alternative entrypoint for compilation and
-            simulation. The default entry point is 'design'.""")
+            simulation. The default entry point is :keypath:`design`.""")
 
     scparam(cfg, ['option', 'idir'],
             sctype='[dir]',
-            shorthelp="Design search paths",
+            shorthelp="Option: design search paths",
             copy=True,
             switch=['+incdir+<dir>',
                     '-I <dir>',
@@ -2893,7 +2972,7 @@ def schema_option(cfg):
 
     scparam(cfg, ['option', 'ydir'],
             sctype='[dir]',
-            shorthelp="Design module search paths",
+            shorthelp="Option: design module search paths",
             copy=True,
             switch=['-y <dir>',
                     '-ydir <dir>'],
@@ -2904,11 +2983,11 @@ def schema_option(cfg):
             schelp="""
             Search paths to look for verilog modules found in the the
             source list. The import engine will look for modules inside
-            files with the specified +libext+ param suffix.""")
+            files with the specified :keypath:`option,libext` param suffix.""")
 
     scparam(cfg, ['option', 'vlib'],
             sctype='[file]',
-            shorthelp="Design libraries",
+            shorthelp="Option: design libraries",
             copy=True,
             switch=['-v <file>',
                     '-vlib <file>'],
@@ -2921,7 +3000,7 @@ def schema_option(cfg):
 
     scparam(cfg, ['option', 'define'],
             sctype='[str]',
-            shorthelp="Design pre-processor symbol",
+            shorthelp="Option: design pre-processor symbol",
             switch=["-D<str>",
                     "-define <str>"],
             example=["cli: -DCFG_ASIC=1",
@@ -2931,7 +3010,7 @@ def schema_option(cfg):
 
     scparam(cfg, ['option', 'libext'],
             sctype='[str]',
-            shorthelp="Design file extensions",
+            shorthelp="Option: design file extensions",
             switch=["+libext+<str>",
                     "-libext <str>"],
             example=[
@@ -2940,14 +3019,14 @@ def schema_option(cfg):
                 "api: chip.set('option', 'libext', 'sv')"],
             schelp="""
             List of file extensions that should be used for finding modules.
-            For example, if -y is specified as ./lib", and '.v' is specified as
-            libext then the files ./lib/\\*.v ", will be searched for
+            For example, if :keypath:`option,ydir` is specified as ./lib", and '.v'
+            is specified as libext then the files ./lib/\\*.v ", will be searched for
             module matches.""")
 
     name = 'default'
     scparam(cfg, ['option', 'param', name],
             sctype='str',
-            shorthelp="Design parameter",
+            shorthelp="Option: design parameter",
             switch="-param 'name <str>'",
             example=[
                 "cli: -param 'N 64'",
@@ -2962,7 +3041,7 @@ def schema_option(cfg):
     scparam(cfg, ['option', 'continue'],
             sctype='bool',
             pernode='optional',
-            shorthelp='continue-on-error',
+            shorthelp='Option: continue-on-error',
             switch='-continue <bool>',
             example=["cli: -continue",
                      "api: chip.set('option', 'continue', True)"],
@@ -2979,19 +3058,18 @@ def schema_option(cfg):
             pernode='optional',
             scope='job',
             unit='s',
-            shorthelp="Option: Timeout value",
+            shorthelp="Option: timeout value",
             switch="-timeout <float>",
             example=["cli: -timeout 3600",
                      "api: chip.set('option', 'timeout', 3600)"],
             schelp="""
             Timeout value in seconds. The timeout value is compared
             against the wall time tracked by the SC runtime to determine
-            if an operation should continue. The timeout value is also
-            used by the jobscheduler to automatically kill jobs.""")
+            if an operation should continue.""")
 
     scparam(cfg, ['option', 'strict'],
             sctype='bool',
-            shorthelp="Option: Strict checking",
+            shorthelp="Option: strict checking",
             switch="-strict <bool>",
             example=["cli: -strict true",
                      "api: chip.set('option', 'strict', True)"],
@@ -3007,7 +3085,7 @@ def schema_option(cfg):
             enum=["slurm", "lsf", "sge", "docker"],
             scope='job',
             pernode='optional',
-            shorthelp="Option: Scheduler platform",
+            shorthelp="Option: scheduler platform",
             switch="-scheduler <str>",
             example=[
                 "cli: -scheduler slurm",
@@ -3040,7 +3118,7 @@ def schema_option(cfg):
             unit='MB',
             scope='job',
             pernode='optional',
-            shorthelp="Option: Scheduler memory constraint",
+            shorthelp="Option: scheduler memory constraint",
             switch="-memory <int>",
             example=["cli: -memory 8000",
                      "api: chip.set('option', 'scheduler', 'memory', '8000')"],
@@ -3054,7 +3132,7 @@ def schema_option(cfg):
             sctype='str',
             scope='job',
             pernode='optional',
-            shorthelp="Option: Scheduler queue",
+            shorthelp="Option: scheduler queue",
             switch="-queue <str>",
             example=["cli: -queue nightrun",
                      "api: chip.set('option', 'scheduler', 'queue', 'nightrun')"],
@@ -3068,7 +3146,7 @@ def schema_option(cfg):
             sctype='str',
             scope='job',
             pernode='optional',
-            shorthelp="Option: Scheduler start time",
+            shorthelp="Option: scheduler start time",
             switch="-defer <str>",
             example=["cli: -defer 16:00",
                      "api: chip.set('option', 'scheduler', 'defer', '16:00')"],
@@ -3083,7 +3161,7 @@ def schema_option(cfg):
     scparam(cfg, ['option', 'scheduler', 'options'],
             sctype='[str]',
             pernode='optional',
-            shorthelp="Option: Scheduler arguments",
+            shorthelp="Option: scheduler arguments",
             switch="-scheduler_options <str>",
             example=[
                 "cli: -scheduler_options \"--pty\"",
@@ -3099,14 +3177,14 @@ def schema_option(cfg):
             enum=['all', 'summary', 'begin', 'end', 'timeout', 'fail'],
             scope='job',
             pernode='optional',
-            shorthelp="Option: Message event trigger",
+            shorthelp="Option: message event trigger",
             switch="-msgevent <str>",
             example=[
                 "cli: -msgevent all",
                 "api: chip.set('option', 'scheduler', 'msgevent', 'all')"],
             schelp="""
             Directs job scheduler to send a message to the user in
-            ['optoion', 'scheduler', 'msgcontact'] when certain events occur
+            :keypath:`option,scheduler,msgcontact` when certain events occur
             during a task.
 
             * fail: send an email on failures
@@ -3121,19 +3199,19 @@ def schema_option(cfg):
             sctype='[str]',
             scope='job',
             pernode='optional',
-            shorthelp="Option: Message contact",
+            shorthelp="Option: message contact",
             switch="-msgcontact <str>",
             example=[
                 "cli: -msgcontact 'wile.e.coyote@acme.com'",
                 "api: chip.set('option', 'scheduler', 'msgcontact', 'wiley@acme.com')"],
             schelp="""
-            List of email addresses to message on a 'msgevent'. Support for
-            email messages relies on job scheduler daemon support.
+            List of email addresses to message on a :keypath:`option,scheduler,msgevent`.
+            Support for email messages relies on job scheduler daemon support.
             For more information, see the job scheduler documentation. """)
 
     scparam(cfg, ['option', 'scheduler', 'maxnodes'],
             sctype='int',
-            shorthelp="Option: Maximum concurrent nodes",
+            shorthelp="Option: maximum concurrent nodes",
             switch="-maxnodes <int>",
             example=["cli: -maxnodes 4",
                      "api: chip.set('option', 'scheduler', 'maxnodes', 4)"],
@@ -3214,7 +3292,7 @@ def schema_package(cfg):
                 example=[
                     f"cli: -package_doc_{item} {item}.pdf",
                     f"api: chip.set('package', 'doc', '{item}', '{item}.pdf')"],
-                schelp=f""" Package list of {item} documents.""")
+                schelp=f"""Package list of {item} documents.""")
 
     scparam(cfg, ['package', 'license'],
             sctype='[str]',
@@ -3236,7 +3314,7 @@ def schema_package(cfg):
                 "api: chip.set('package', 'licensefile', './LICENSE')"],
             schelp="""Package list of license files for to be
             applied in cases when a SPDX identifier is not available.
-            (eg. proprietary licenses).list of SPDX license identifiers.""")
+            (eg. proprietary licenses).""")
 
     scparam(cfg, ['package', 'organization'],
             sctype='[str]',
@@ -3273,7 +3351,7 @@ def schema_package(cfg):
     scparam(cfg, ['package', 'source', source, 'path'],
             sctype='str',
             scope='global',
-            shorthelp="Package data source path",
+            shorthelp="Package: data source path",
             switch="-package_source_path 'source <str>'",
             example=[
                 "cli: -package_source_path "
@@ -3297,14 +3375,12 @@ def schema_package(cfg):
     scparam(cfg, ['package', 'source', source, 'ref'],
             sctype='str',
             scope='global',
-            shorthelp="Package data source reference",
+            shorthelp="Package: data source reference",
             switch="-package_source_ref 'source <str>'",
             example=[
                 "cli: -package_source_ref 'freepdk45_data 07ec4aa'",
                 "api: chip.set('package', 'source', 'freepdk45_data', 'ref', '07ec4aa')"],
-            schelp="""
-            Package data source reference
-            """)
+            schelp="""Package data source reference""")
 
     return cfg
 
@@ -3473,7 +3549,7 @@ def schema_asic(cfg):
             example=["cli: -asic_delaymodel ccs",
                      "api: chip.set('asic', 'delaymodel', 'ccs')"],
             schelp="""
-            Delay model to use for the target libs. Supported values
+            Delay model to use for the target libs. Commonly supported values
             are nldm and ccs.""")
 
     # TODO: Expand on the exact definitions of these types of cells.
@@ -3522,7 +3598,7 @@ def schema_asic(cfg):
     scparam(cfg, ['asic', 'site', libarch],
             sctype='[str]',
             pernode='optional',
-            shorthelp="ASIC: Library sites",
+            shorthelp="ASIC: library sites",
             switch="-asic_site 'libarch <str>'",
             example=[
                 "cli: -asic_site '12track Site_12T'",
@@ -3585,8 +3661,7 @@ def schema_constraint(cfg):
             example=["cli: -constraint_timing_pexcorner 'worst max'",
                      "api: chip.set('constraint', 'timing', 'worst', 'pexcorner', 'max')"],
             schelp="""Parasitic corner applied to the scenario. The
-            'pexcorner' string must match a corner found in the pdk
-            pexmodel setup.""")
+            'pexcorner' string must match a corner found in :keypath:`pdk,<pdk>,pexmodel`.""")
 
     scparam(cfg, ['constraint', 'timing', scenario, 'opcond'],
             sctype='str',
@@ -3598,7 +3673,7 @@ def schema_constraint(cfg):
                      "api: chip.set('constraint', 'timing', 'worst', 'opcond', 'typical_1.0')"],
             schelp="""Operating condition applied to the scenario. The value
             can be used to access specific conditions within the library
-            timing models from the 'logiclib' timing models.""")
+            timing models from the :keypath:`asic,logiclib` timing models.""")
 
     scparam(cfg, ['constraint', 'timing', scenario, 'mode'],
             sctype='str',
@@ -3647,38 +3722,30 @@ def schema_constraint(cfg):
     inst = 'default'
 
     scparam(cfg, ['constraint', 'component', inst, 'placement'],
-            sctype='(float,float,float)',
+            sctype='(float,float)',
             pernode='optional',
             unit='um',
-            shorthelp="Constraint: Component placement",
-            switch="-constraint_component_placement 'inst <(float,float,float)>'",
-            example=[
-                "cli: -constraint_component_placement 'i0 (2.0,3.0,0.0)'",
-                "api: chip.set('constraint', 'component', 'i0', 'placement', (2.0, 3.0, 0.0))"],
-            schelp="""
-            Placement location of a named instance, specified as a (x, y, z) tuple of
-            floats. The location refers to the placement of the center/centroid of the
-            component. The 'placement' parameter is a goal/intent, not an exact specification.
-            The compiler and layout system may adjust coordinates to meet competing
-            goals such as manufacturing design rules and grid placement
-            guidelines. The 'z' coordinate shall be set to 0 for planar systems
-            with only (x, y) coordinates. Discretized systems like PCB stacks,
-            package stacks, and breadboards only allow a reduced
-            set of floating point values (0, 1, 2, 3). The user specifying the
-            placement will need to have some understanding of the type of
-            layout system the component is being placed in (ASIC, SIP, PCB) but
-            should not need to know exact manufacturing specifications.""")
+            shorthelp="Constraint: component placement",
+            switch="-constraint_component_placement 'inst <(float,float)>'",
+            example=[
+                "cli: -constraint_component_placement 'i0 (2.0,3.0)'",
+                "api: chip.set('constraint', 'component', 'i0', 'placement', (2.0, 3.0))"],
+            schelp="""
+            Placement location of a named instance, specified as a (x, y) tuple of
+            floats. The location refers to the distance from the substrate origin to
+            the anchor point of the placed component, defined by
+            the :keypath:`datasheet,package,<name>,anchor` parameter.""")
 
     scparam(cfg, ['constraint', 'component', inst, 'partname'],
             sctype='str',
             pernode='optional',
-            shorthelp="Constraint: Component part name",
+            shorthelp="Constraint: component part name",
             switch="-constraint_component_partname 'inst <str>'",
             example=[
                 "cli: -constraint_component_partname 'i0 filler_x1'",
                 "api: chip.set('constraint', 'component', 'i0', 'partname', 'filler_x1')"],
             schelp="""
-            Part name of a named instance. The parameter is required for instances
+            Part name of the instance. The parameter is required for instances
             that are not contained within the design netlist (ie. physical only cells).
             """)
 
@@ -3686,75 +3753,81 @@ def schema_constraint(cfg):
             sctype='(float,float)',
             pernode='optional',
             unit='um',
-            shorthelp="Constraint: Component halo",
+            shorthelp="Constraint: component halo",
             switch="-constraint_component_halo 'inst <(float,float)>'",
             example=[
                 "cli: -constraint_component_halo 'i0 (1,1)'",
                 "api: chip.set('constraint', 'component', 'i0', 'halo', (1, 1))"],
             schelp="""
             Placement keepout halo around the named component, specified as a
-            (horizontal, vertical) tuple represented in microns.
-            """)
+            (horizontal, vertical) tuple represented in microns.""")
 
     scparam(cfg, ['constraint', 'component', inst, 'rotation'],
-            sctype='float',
-            pernode='optional',
-            shorthelp="Constraint: Component rotation",
-            switch="-constraint_component_rotation 'inst <float>'",
-            example=[
-                "cli: -constraint_component_rotation 'i0 90'",
-                "api: chip.set('constraint', 'component', 'i0', 'rotation', '90')"],
-            schelp="""
-            Placement rotation of the component specified in degrees. Rotation
-            goes counter-clockwise for all parts on top and clock-wise for parts
-            on the bottom. In both cases, this is from the perspective of looking
-            at the top of the board. Rotation is specified in degrees. Most gridded
-            layout systems (like ASICs) only allow a finite number of rotation
-            values (0, 90, 180, 270).""")
-
-    scparam(cfg, ['constraint', 'component', inst, 'flip'],
-            sctype='bool',
-            pernode='optional',
-            shorthelp="Constraint: Component flip option",
-            switch="-constraint_component_flip 'inst <bool>'",
-            example=[
-                "cli: -constraint_component_flip 'i0 true'",
-                "api: chip.set('constraint', 'component', 'i0', 'flip', True)"],
-            schelp="""
-            Boolean parameter specifying that the instanced library component should be flipped
-            around the vertical axis before being placed on the substrate. The need to
-            flip a component depends on the component footprint. Most dies have pads
-            facing up and so must be flipped when assembled face down (eg. flip-chip,
-            WCSP).""")
+            sctype='enum',
+            defvalue='R0',
+            enum=['R0', 'R90', 'R180', 'R270',
+                  'MX', 'MX_R90', 'MX_R180', 'MX_R270',
+                  'MY', 'MY_R90', 'MY_R180', 'MY_R270',
+                  'MZ', 'MZ_R90', 'MZ_R180', 'MZ_R270',
+                  'MZ_MX', 'MZ_MX_R90', 'MZ_MX_R180', 'MZ_MX_R270',
+                  'MZ_MY', 'MZ_MY_R90', 'MZ_MY_R180', 'MZ_MY_R270'],
+            pernode='optional',
+            shorthelp="Constraint: component rotation",
+            switch="-constraint_component_rotation 'inst <str>'",
+            example=[
+                "cli: -constraint_component_rotation 'i0 R90'",
+                "api: chip.set('constraint', 'component', 'i0', 'rotation', 'R90')"],
+            schelp="""
+        Placement rotation of the component. Components are always placed
+        such that the lower left corner of the cell is at the anchor point
+        (0,0) after any orientation. The MZ type rotations are for 3D design and
+        typically not supported by 2D layout systems like traditional
+        ASIC tools. For graphical illustrations of the rotation types, see
+        the SiliconCompiler documentation.
+
+        * ``R0``: North orientation (no rotation)
+        * ``R90``: West orientation, rotate 90 deg counter clockwise (ccw)
+        * ``R180``: South orientation, rotate 180 deg counter ccw
+        * ``R270``: East orientation, rotate 180 deg counter ccw
+
+        * ``MX``, ``MY_R180``: Flip on x-axis
+        * ``MX_R90``, ``MY_R270``: Flip on x-axis and rotate 90 deg ccw
+        * ``MX_R180``, ``MY``: Flip on x-axis and rotate 180 deg ccw
+        * ``MX_R270``, ``MY_R90``: Flip on x-axis and rotate 270 deg ccw
+
+        * ``MZ``: Reverse component metal stack
+        * ``MZ_R90``: Reverse metal stack and rotate 90 deg ccw
+        * ``MZ_R180``: Reverse metal stack and rotate 180 deg ccw
+        * ``MZ_R270``: Reverse  metal stack and rotate 270 deg ccw
+        * ``MZ_MX``, ``MZ_MY_R180``: Reverse metal stack and flip on x-axis
+        * ``MZ_MX_R90``, ``MZ_MY_R270``: Reverse metal stack, flip on x-axis, and rotate 90 deg ccw
+        * ``MZ_MX_R180``, ``MZ_MY``: Reverse metal stack, flip on x-axis, and rotate 180 deg ccw
+        * ``MZ_MX_R270``, ``MZ_MY_R90``: Reverse metal stack, flip on x-axis and rotate 270 deg ccw
+            """)
 
     # PINS
     name = 'default'
-
     scparam(cfg, ['constraint', 'pin', name, 'placement'],
-            sctype='(float,float,float)',
+            sctype='(float,float)',
             pernode='optional',
             unit='um',
-            shorthelp="Constraint: Pin placement",
-            switch="-constraint_pin_placement 'name <(float,float,float)>'",
-            example=[
-                "cli: -constraint_pin_placement 'nreset (2.0,3.0,0.0)'",
-                "api: chip.set('constraint', 'pin', 'nreset', 'placement', (2.0, 3.0, 0.0))"],
-            schelp="""
-            Placement location of a named pin, specified as a (x, y, z) tuple of
-            floats. The location refers to the placement of the center of the
-            pin. The 'placement' parameter is a goal/intent, not an exact specification.
-            The compiler and layout system may adjust sizes to meet competing
-            goals such as manufacturing design rules and grid placement
-            guidelines. The 'z' coordinate shall be set to 0 for planar components
-            with only (x, y) coordinates. Discretized systems like 3D chips with
-            pins on top and bottom may choose to discretize the top and bottom
-            layer as 0, 1 or use absolute coordinates. Values are specified
-            in microns.""")
+            shorthelp="Constraint: pin placement",
+            switch="-constraint_pin_placement 'name <(float,float)>'",
+            example=[
+                "cli: -constraint_pin_placement 'nreset (2.0,3.0)'",
+                "api: chip.set('constraint', 'pin', 'nreset', 'placement', (2.0, 3.0))"],
+            schelp="""
+            Placement location of a named pin, specified as a (x,y) tuple of
+            floats with respect to the lower left corner of the substrate. The location
+            refers to the center of the pin. The 'placement' parameter
+            is a goal/intent, not an exact specification. The layout system
+            may adjust sizes to meet competing goals such as manufacturing design
+            rules and grid placement guidelines.""")
 
     scparam(cfg, ['constraint', 'pin', name, 'layer'],
             sctype='str',
             pernode='optional',
-            shorthelp="Constraint: Pin layer",
+            shorthelp="Constraint: pin layer",
             switch="-constraint_pin_layer 'name <str>'",
             example=[
                 "cli: -constraint_pin_layer 'nreset m4'",
@@ -3767,7 +3840,7 @@ def schema_constraint(cfg):
     scparam(cfg, ['constraint', 'pin', name, 'side'],
             sctype='int',
             pernode='optional',
-            shorthelp="Constraint: Pin side",
+            shorthelp="Constraint: pin side",
             switch="-constraint_pin_side 'name <int>'",
             example=[
                 "cli: -constraint_pin_side 'nreset 1'",
@@ -3783,7 +3856,7 @@ def schema_constraint(cfg):
     scparam(cfg, ['constraint', 'pin', name, 'order'],
             sctype='int',
             pernode='optional',
-            shorthelp="Constraint: Pin order",
+            shorthelp="Constraint: pin order",
             switch="-constraint_pin_order 'name <int>'",
             example=[
                 "cli: -constraint_pin_order 'nreset 1'",
@@ -3800,7 +3873,7 @@ def schema_constraint(cfg):
             sctype='float',
             pernode='optional',
             unit='um',
-            shorthelp="Constraint: Net max length",
+            shorthelp="Constraint: net max length",
             switch="-constraint_net_maxlength 'name <float>'",
             example=[
                 "cli: -constraint_net_maxlength 'nreset 1000'",
@@ -3813,7 +3886,7 @@ def schema_constraint(cfg):
             sctype='float',
             pernode='optional',
             unit='ohm',
-            shorthelp="Constraint: Net max resistance",
+            shorthelp="Constraint: net max resistance",
             switch="-constraint_net_maxresistance 'name <float>'",
             example=[
                 "cli: -constraint_net_maxresistance 'nreset 1'",
@@ -3826,7 +3899,7 @@ def schema_constraint(cfg):
             sctype='(float,float)',
             pernode='optional',
             unit='um',
-            shorthelp="Constraint: Net routing rule",
+            shorthelp="Constraint: net routing rule",
             switch="-constraint_net_ndr 'name <(float,float)>'",
             example=[
                 "cli: -constraint_net_ndr 'nreset (0.4,0.4)'",
@@ -3840,7 +3913,7 @@ def schema_constraint(cfg):
     scparam(cfg, ['constraint', 'net', name, 'minlayer'],
             sctype='str',
             pernode='optional',
-            shorthelp="Constraint: Net minimum routing layer",
+            shorthelp="Constraint: net minimum routing layer",
             switch="-constraint_net_minlayer 'name <str>'",
             example=[
                 "cli: -constraint_net_minlayer 'nreset m1'",
@@ -3854,7 +3927,7 @@ def schema_constraint(cfg):
     scparam(cfg, ['constraint', 'net', name, 'maxlayer'],
             sctype='str',
             pernode='optional',
-            shorthelp="Constraint: Net maximum routing layer",
+            shorthelp="Constraint: net maximum routing layer",
             switch="-constraint_net_maxlayer 'name <str>'",
             example=[
                 "cli: -constraint_net_maxlayer 'nreset m1'",
@@ -3868,7 +3941,7 @@ def schema_constraint(cfg):
     scparam(cfg, ['constraint', 'net', name, 'shield'],
             sctype='str',
             pernode='optional',
-            shorthelp="Constraint: Net shielding",
+            shorthelp="Constraint: net shielding",
             switch="-constraint_net_shield 'name <str>'",
             example=[
                 "cli: -constraint_net_shield 'clk vss'",
@@ -3880,7 +3953,7 @@ def schema_constraint(cfg):
     scparam(cfg, ['constraint', 'net', name, 'match'],
             sctype='[str]',
             pernode='optional',
-            shorthelp="Constraint: Net matched routing",
+            shorthelp="Constraint: net matched routing",
             switch="-constraint_net_match 'name <str>'",
             example=[
                 "cli: -constraint_net_match 'clk1 clk2'",
@@ -3893,7 +3966,7 @@ def schema_constraint(cfg):
     scparam(cfg, ['constraint', 'net', name, 'diffpair'],
             sctype='str',
             pernode='optional',
-            shorthelp="Constraint: Net diffpair",
+            shorthelp="Constraint: net diffpair",
             switch="-constraint_net_diffpair 'name <str>'",
             example=[
                 "cli: -constraint_net_diffpair 'clkn clkp'",
@@ -3905,7 +3978,7 @@ def schema_constraint(cfg):
     scparam(cfg, ['constraint', 'net', name, 'sympair'],
             sctype='str',
             pernode='optional',
-            shorthelp="Constraint: Net sympair",
+            shorthelp="Constraint: net sympair",
             switch="-constraint_net_sympair 'name <str>'",
             example=[
                 "cli: -constraint_net_sympair 'netA netB'",
@@ -3921,50 +3994,47 @@ def schema_constraint(cfg):
             pernode='optional',
             unit='um',
             scope='job',
-            shorthelp="Constraint: Layout outline",
+            shorthelp="Constraint: layout outline",
             switch="-constraint_outline <(float,float)>",
             example=["cli: -constraint_outline '(0,0)'",
                      "api: chip.set('constraint', 'outline', (0, 0))"],
             schelp="""
             List of (x, y) points that define the outline physical layout
             physical design. Simple rectangle areas can be defined with two points,
-            one for the lower left corner and one for the upper right corner. All
-            values are specified in microns.""")
+            one for the lower left corner and one for the upper right corner.""")
 
     scparam(cfg, ['constraint', 'corearea'],
             sctype='[(float,float)]',
             pernode='optional',
             unit='um',
             scope='job',
-            shorthelp="Constraint: Layout core area",
+            shorthelp="Constraint: layout core area",
             switch="-constraint_corearea <(float,float)>",
             example=["cli: -constraint_corearea '(0,0)'",
                      "api: chip.set('constraint', 'corearea', (0, 0))"],
             schelp="""
             List of (x, y) points that define the outline of the core area for the
             physical design. Simple rectangle areas can be defined with two points,
-            one for the lower left corner and one for the upper right corner. All
-            values are specified in microns.""")
+            one for the lower left corner and one for the upper right corner.""")
 
     scparam(cfg, ['constraint', 'coremargin'],
             sctype='float',
             pernode='optional',
             unit='um',
             scope='job',
-            shorthelp="Constraint: Layout core margin",
+            shorthelp="Constraint: layout core margin",
             switch="-constraint_coremargin <float>",
             example=["cli: -constraint_coremargin 1",
                      "api: chip.set('constraint', 'coremargin', '1')"],
             schelp="""
             Halo/margin between the outline and core area for fully
-            automated layout sizing and floorplanning, specified in
-            microns.""")
+            automated layout sizing and floorplanning.""")
 
     scparam(cfg, ['constraint', 'density'],
             sctype='float',
             pernode='optional',
             scope='job',
-            shorthelp="Constraint: Layout density",
+            shorthelp="Constraint: layout density",
             switch="-constraint_density <float>",
             example=["cli: -constraint_density 30",
                      "api: chip.set('constraint', 'density', '30')"],
@@ -3980,7 +4050,7 @@ def schema_constraint(cfg):
             pernode='optional',
             defvalue='1.0',
             scope='job',
-            shorthelp="Constraint: Layout aspect ratio",
+            shorthelp="Constraint: layout aspect ratio",
             switch="-constraint_aspectratio <float>",
             example=["cli: -constraint_aspectratio 2.0",
                      "api: chip.set('constraint', 'aspectratio', '2.0')"],