Start an LVS comparison with the correct settings and technology files

Use the matched release and understand what it compares

The inspected Windows and Linux archives are named InductEx-LVS_package_v1.1.05_windows.tar.gz and InductEx-LVS_package_v1.1.05_linux.tar.gz. Both contain exactly the published InductEx-LVS™ v1.1.05 manual. The exercised Windows binary identifies itself as v1.1.05 (27 July 2026). The catalog display v1.1.0.5 is a different spelling for these inspected archive records; this check does not change the catalog or infer future package contents.

LVS extracts layout and schematic graphs, applies the configured transformations and compares the resulting connectivity, labels and selected polarity. This teaching route does not qualify device values, extracted inductance/resistance, timing, design rules or fabrication readiness. Its schematic contains topological placeholders and is not a complete numerical JoSIM testbench.

Use the technology JSON supplied for this LVS package and process. InductEx® LDF is a different input; do not rename it to JSON. Studio can export selected technology information, but that alone does not prove the LVS definitions or a comparison are correct. Maintained LVS source authority and Linux runtime execution remain unverified.

Extract all five teaching inputs together

The download contains the shipped public JTL layout jtl.gds, its topological schematic jtl.cir, mitll_sfq5ee.json, portable lvs_settings.json and the complete standard-library run_lvs.py client. Geometry bytes are unchanged; circuit and technology text only normalise line endings. The settings retain the shipped layout/schematic transformations and comparison rules, while placing all inputs beside the settings and keeping graph debug output.

This distributed example uses the named MITLL technology library as supplied. It is a teaching input, not customer data, a foundry-qualified process release or an endorsement. Keep all five files in one writable folder. The archive contains no executable, issued licence, local settings, report or support correspondence.

Run the complete example from PowerShell

Run this complete command from the extracted teaching folder. Select the actual compatible LVS executable, Python and your existing issued licence path. The checked host used Windows CPython 3.13.11. The client references the licence path in private generated settings; it does not copy licence contents or alter installed configuration.

Use a new result directory for every attempt. The client copies the complete input set, invokes LVS with the generated settings file and requires a current explicit pass report plus four DOT files. This fixed teaching client checks the stated dependency names; use the product manual for a different project.

$ErrorActionPreference = 'Stop'
$python = 'python'
$lvs = 'C:\Program Files\SUN Magnetics\InductEx\bin\inductex-lvs.exe'
$licence = 'C:\Program Files\SUN Magnetics\Licenses\sm_license.txt'
& $python -B .\run_lvs.py --lvs $lvs --licence $licence --results .\lvs-results
if ($LASTEXITCODE -ne 0) { throw 'The current LVS comparison or its outputs failed validation.' }
Get-Content -LiteralPath .\lvs-results\receipt.json -Raw | ConvertFrom-Json | Select-Object status,comparison,process_exit,dot_graphs

Read the current report before accepting success

Open lvs-results/output/lvs_report.txt and retain it with layout/schematic transform logs and the selected inputs. The checked JTL reports 14 devices and 12 nets on each side, with three layout transformations and 16 schematic transformations. Review those operations rather than treating matching counts alone as proof of graph equivalence.

In this Windows release, deliberate label and wiring mismatches still return product exit code 0 while the report says LVS FAILED. KB-LVS-001 tracks that behaviour. The client accepts only the current explicit LVS PASSED!!! result, normal process completion and required new artifacts. It returns 3 for a failed/unavailable comparison or missing requested artifacts, and 2 for input or execution failure.

A report that passes the configured transformations proves that comparison, not that every original label or electrical parameter is equal. Do not relax or remove comparison rules merely to obtain a pass. For a real project, decide which device names, pin names, polarity and net equivalences must be preserved and review the transformation logs accordingly.

Exercise failure and recover deliberately

1. On a separate teaching copy, change the schematic B1 label to B999 or change Lout’s first node from 8 to 3. Run the same client with a different new result directory. Both checked changes produce LVS FAILED and client exit 3 even though the product process exits 0.
2. Read the current report’s error IDs, layout/schematic device and net lists, and retained transformations. When generated, errors.gds provides spatial annotations; a missing error graphic does not replace the report.
3. Restore the intended source or correct a genuinely wrong technology, cell/subcircuit or label-layer definition. Use a fresh result directory and require a new explicit pass. Missing cell and missing technology were rejected rather than accepted as empty matching circuits.
4. Review local logs, generated settings, source paths and licence-holder details before sharing. Keep raw reports private unless their contents have been checked. Do not reuse an old passed report after a failed run.

Request graph PDFs separately

The default example retains four DOT files and requires no Graphviz. To request PDFs, add --dot followed by the path to an existing Graphviz dot executable to the run_lvs.py command, and choose another new result directory. The client prepends only that executable’s directory to its child process PATH and uses its simple command name; it does not modify the system PATH.

All four current PDFs must then exist before the client accepts the run. They show layout and schematic graphs before and after transformations. Their diagram placement is a graph layout, not the physical layout geometry. Compare labels and connections alongside the report.

KB-LVS-002 tracks the exercised Windows failure when an unquoted or embedded-quoted full Graphviz path with spaces is passed directly through the product setting. Using the command discovered through the child PATH produced all four PDFs. Missing rendering and a failed connectivity comparison are separate outcomes; see the dedicated graph troubleshooting guide.

Prepare a complete working example

1. Use the example and manual supplied for the exact LVS package. Copy its complete directory to a writable location.
2. Inspect the settings JSON references to the layout, schematic, technology file and selected cell. Keep referenced files together as the example expects.
3. Check pin, net and device labels against the technology's layer definitions. A visible label on the wrong text layer may not identify the intended object.
4. Run the documented executable with the settings file, then read the comparison report before interpreting any exported graph.

Manual invocation

The v1.1.05 manual gives this generic invocation for another project. Here settings.json means your complete project settings, including its selected inputs and SETTINGS/PATHS/LICENSE_FILE where needed. Use the actual executable path when it is not on PATH. For the supplied download, use the complete client command above rather than this generic filename.

The direct product command does not provide the teaching client’s report and artifact checks. Always inspect the current report, including after process exit 0.

inductex-lvs settings.json

Scope of the checked result

Twenty-two independent checks cover both archive/manual identities, the current Windows runtime, complete client, known JTL counts and graph labels, two deliberately failed comparisons, missing inputs/cell, current report handling, Graphviz recovery, source preservation and refusal to overwrite results. The published checksum is MD5; a separate SHA-256 snapshot records the downloaded bytes. Neither is a code-signing assertion.

The Linux archive’s contents and identical manual were inspected, but its executable was not run in this check. Maintained source, non-Windows behaviour, arbitrary process/device policies, numerical compact-model extraction and a final installed-product walkthrough remain separate work.

Save jtl.gds

The binary GDSII input is included unchanged in the complete download. The record envelope and all ASCII fields were reviewed; it contains only the distributed example/library metadata and circuit labels. Use the download rather than reconstructing binary geometry from a code listing.

Save jtl.cir

.subckt jtl a b
IB1 0 I
LIB 1 2 L
Lina3L
L12 3 L
L22 8 L
B13 4 L
LJ14 0L
RJ13 5 R
LRJ15 0 L
B28 6 L
LJ26 0L
RJ28 7 R
Lout8bL
LRJ27 0 L
.ends

Save mitll_sfq5ee.json

{
"LAYERS": {
"M0":{ "LAYER": [1,0],"TYPE": "S" },
"I0":{ "LAYER": [2,0],"TYPE": "I" },
"L0":{ "LAYER": [3,0],"TYPE": "S" },
"C0":{ "LAYER": [4,0],"TYPE": "I" },
"M1":{ "LAYER": [10,0],"TYPE": "S" },
"I1":{ "LAYER": [11,0],"TYPE": "I" },
"M2":{ "LAYER": [20,0],"TYPE": "S" },
"I2":{ "LAYER": [21,0],"TYPE": "I" },
"M3":{ "LAYER": [30,0],"TYPE": "S" },
"I3":{ "LAYER": [31,0],"TYPE": "I" },
"M4":{ "LAYER": [40,0],"TYPE": "S" },
"I4":{ "LAYER": [41,0],"TYPE": "I" },
"M5":{ "LAYER": [50,0],"TYPE": "S" },
"J5":{ "LAYER": [51,0],"TYPE": "A" },
"R5":{ "LAYER": [52,0],"TYPE": "R" },
"I5":{ "LAYER": [54,0],"TYPE": "I" },
"C5J":{ "LAYER": [55,0],"TYPE": "A" },
"C5R":{ "LAYER": [56,0],"TYPE": "I" },
"M6":{ "LAYER": [60,0],"TYPE": "S" },
"I6":{ "LAYER": [61,0],"TYPE": "I" },
"M7":{ "LAYER": [70,0],"TYPE": "S" },
"I7":{ "LAYER": [71,0],"TYPE": "I" },
"M8":{ "LAYER": [80,0],"TYPE": "N" },
"NOFILL":{ "LAYER": [177,0],"TYPE": "A" },
"CE":{ "LAYER": [180,0],"TYPE": "A" },
"IXTEXT":{ "LAYER": [182,0],"TYPE": "IXTEXT" },
"IXTERM":{ "LAYER": [19,0], "TYPE": "IXTERM" }
},
"VIAS": {
"v00": { "LAYERS": ["M0", "C0", "L0"] },
"v01": { "LAYERS": ["M1", "I0", "M0"] },
"v12": { "LAYERS": ["M2", "I1", "M1"] },
"v23": { "LAYERS": ["M3", "I2", "M2"] },
"v34": { "LAYERS": ["M4", "I3", "M3"] },
"v45": { "LAYERS": ["M5", "I4", "M4"] },
"v56": { "LAYERS": ["M6", "I5", "M5"] },
"v67": { "LAYERS": ["M7", "I6", "M6"] },
"v78": { "LAYERS": ["M8", "I7", "M7"] },
"vR6": { "LAYERS": ["M6", "C5R","R5"] }
},
"DEVICES": {
"J": { 
"LAYERS": ["M6", "C5J", "J5", "M5"], 
"AREA": "J5",
"AREA_SCALE": "PI*((sqrt(D^2-0.0625)-0.020)/2)^2",
"MIN_EDGES": 10
}
},
"SETTINGS": {
"NET_DATATYPE" : 0,
"PIN_DATATYPE" : 5,
"DEVICE_DATATYPE" : 11,
"LVS_ERROR_DATATYPE" : 230,
"BLANK_LAYER": [255,0]
}
}

Save lvs_settings.json

{
  "LAYOUT": {
    "FILE": "jtl.gds",
    "CELL": "jtl",
    "TECHFILE": "mitll_sfq5ee.json",
    "TRANSFORM": {
      "RENAME_DEVICE": {
        "*::J*": "#::B#"
      },
      "CONNECT_NETS": [
        [
          "GND"
        ],
        [
          "VDD"
        ]
      ]
    }
  },
  "SCHEMATIC": {
    "FILE": "jtl.cir",
    "SUBCKT": "jtl",
    "FORMAT": "JOSIM",
    "TRANSFORM": {
      "REPLACE_DEVICE": {
        "*::IB*": [
          "#::RIB#",
          "#::#",
          "VDD"
        ]
      },
      "RENAME_NET": {
        "*::0": "GND"
      },
      "CONNECT_NETS": [
        [
          "GND"
        ],
        [
          "VDD"
        ]
      ],
      "RENAME_PIN": {
        "*::A": "#::IN",
        "*::B": "#::OUT"
      }
    }
  },
  "LVS": {
    "COMPARE_DEVICES": {
      "#::L#": {
        "POLAR": true
      },
      "#::R#": {},
      "#::B#": {
        "POLAR": true
      }
    },
    "COMPARE_PINS": {
      "#::#": {}
    },
    "COMPARE_NETS": {
      "*::#": {
        "MISMATCH": "REMOVE_LABEL"
      }
    }
  },
  "SETTINGS": {
    "PATHS": {
      "OUTPUT_DIR": "output"
    },
    "OUTPUT": {
      "WRITE_DOT_GRAPHS": true,
      "WRITE_DOT_GRAPHS_PDF": false,
      "DELETE_DEBUG_FILES": false,
      "COPY_REPORT_TO_CWD": false
    }
  }
}

Save run_lvs.py

"""Run the supplied JTL comparison into a new directory and check its report.

Raw logs and the generated private settings contain local paths and may contain
licence-holder details. Review before sharing; no licence contents are copied.
"""
import argparse
import hashlib
import json
import os
import re
import shutil
import subprocess
import sys
from pathlib import Path

INPUTS = ('jtl.gds', 'jtl.cir', 'mitll_sfq5ee.json', 'lvs_settings.json')

def sha(path):
    return hashlib.sha256(path.read_bytes()).hexdigest()

def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--lvs', required=True, type=Path)
    parser.add_argument('--licence', required=True, type=Path)
    parser.add_argument('--results', required=True, type=Path)
    parser.add_argument('--dot', type=Path, help='Optional existing Graphviz dot executable; require all four PDFs')
    args = parser.parse_args()
    work = None
    receipt = None
    try:
        binary = args.lvs.resolve(strict=True)
        licence = args.licence.resolve(strict=True)
        root = Path(__file__).resolve().parent
        if not binary.is_file() or not licence.is_file():
            raise ValueError('Select the existing LVS executable and issued licence file.')
        hashes = {name: sha(root / name) for name in INPUTS}
        settings = json.loads((root / 'lvs_settings.json').read_text(encoding='utf-8'))
        if settings['LAYOUT']['FILE'] != 'jtl.gds' or settings['LAYOUT']['TECHFILE'] != 'mitll_sfq5ee.json' or settings['SCHEMATIC']['FILE'] != 'jtl.cir':
            raise ValueError('This small client requires the complete local three-file dependency set.')
        env = os.environ.copy()
        dot = args.dot.resolve(strict=True) if args.dot else None
        if dot:
            if not dot.is_file() or not re.fullmatch(r'[A-Za-z0-9_.-]+', dot.name):
                raise ValueError('Select an existing Graphviz executable with a simple command filename.')
            env['PATH'] = str(dot.parent) + os.pathsep + env.get('PATH', '')
        destination = args.results.absolute()
        if destination.exists() or not destination.parent.is_dir():
            raise ValueError('Choose a new result directory under an existing parent.')
        destination.mkdir()
        work = destination
        for name in INPUTS:
            shutil.copyfile(root / name, work / name)
        paths = settings.setdefault('SETTINGS', {}).setdefault('PATHS', {})
        paths.update(LICENSE_FILE=str(licence), OUTPUT_DIR='output')
        if dot:
            paths['PROG_GRAPHVIZ_DOT'] = dot.name
        settings['SETTINGS']['OUTPUT'] = {'WRITE_DOT_GRAPHS': True, 'WRITE_DOT_GRAPHS_PDF': bool(dot), 'DELETE_DEBUG_FILES': False, 'COPY_REPORT_TO_CWD': False}
        (work / 'private-settings.json').write_text(json.dumps(settings, indent=2) + '\n', encoding='utf-8')
        receipt = {'status': 'failed', 'comparison': 'unavailable', 'inputs': hashes,
                   'client_sha256': sha(Path(__file__)), 'lvs_sha256': sha(binary),
                   'graphs_requested': bool(dot), 'scope': 'Current shipped JTL topology comparison only; no numerical/device-parameter acceptance.'}
        run = subprocess.run([str(binary), 'private-settings.json'], cwd=work, env=env,
            stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=60,
            **({'creationflags': subprocess.CREATE_NO_WINDOW} if os.name == 'nt' else {}))
        (work / 'private-run.log').write_bytes(run.stdout)
        receipt['process_exit'] = run.returncode
        report = work / 'output/lvs_report.txt'
        if report.is_file():
            text = report.read_text(encoding='utf-8-sig')
            results = re.findall(r'^RESULT:\s*(LVS PASSED!!!|LVS FAILED)\s*$', text, re.MULTILINE)
            receipt['comparison'] = 'passed' if results == ['LVS PASSED!!!'] else ('failed' if results == ['LVS FAILED'] else 'unavailable')
            receipt['report_sha256'] = sha(report)
        graphs = ('layout_graph', 'layout_graph_transform', 'schematic_graph', 'schematic_graph_transform')
        receipt['dot_graphs'] = {name: sha(work / 'output' / (name + '.dot')) for name in graphs if (work / 'output' / (name + '.dot')).is_file()}
        receipt['pdf_graphs'] = {name: sha(work / 'output' / (name + '.pdf')) for name in graphs if (work / 'output' / (name + '.pdf')).is_file() and (work / 'output' / (name + '.pdf')).read_bytes().startswith(b'%PDF-')}
        receipt['source_inputs_preserved'] = all(sha(root / name) == digest for name, digest in hashes.items())
        if run.returncode == 0 and receipt['comparison'] == 'passed' and len(receipt['dot_graphs']) == 4 and (not dot or len(receipt['pdf_graphs']) == 4) and receipt['source_inputs_preserved']:
            receipt['status'] = 'passed'
        (work / 'receipt.json').write_text(json.dumps(receipt, indent=2) + '\n', encoding='utf-8')
        print(json.dumps({'status': receipt['status'], 'comparison': receipt['comparison'], 'process_exit': run.returncode, 'pdf_graphs': len(receipt['pdf_graphs'])}))
        return 0 if receipt['status'] == 'passed' else 3
    except (OSError, ValueError, KeyError, subprocess.TimeoutExpired) as error:
        if work is not None:
            failure = receipt or {'status': 'failed', 'comparison': 'unavailable'}
            failure.update(status='failed', error=type(error).__name__)
            (work / 'receipt.json').write_text(json.dumps(failure, indent=2) + '\n', encoding='utf-8')
        print('Input, execution or report validation failed; review private evidence before sharing.', file=sys.stderr)
        return 2

if __name__ == '__main__':
    raise SystemExit(main())